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

Last change on this file since 1475 was 1475, checked in by seregin, 9 years ago

port rev 4600, remove macro Q0074_COLOUR_REMAPPING_SEI
  • Property svn:eol-style set to native
File size: 98.8 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-2015, 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#if !SVC_EXTENSION
45#include <iomanip>
46#endif
47
48#include "TAppEncTop.h"
49#include "TLibEncoder/AnnexBwrite.h"
50
51using namespace std;
52
53//! \ingroup TAppEncoder
54//! \{
55
56// ====================================================================================================================
57// Constructor / destructor / initialization / destroy
58// ====================================================================================================================
59
60TAppEncTop::TAppEncTop()
61{
62  m_iFrameRcvd = 0;
63  m_totalBytes = 0;
64  m_essentialBytes = 0;
65#if SVC_EXTENSION
66  memset( m_apcTVideoIOYuvInputFile, 0, sizeof(m_apcTVideoIOYuvInputFile) );
67  memset( m_apcTVideoIOYuvReconFile, 0, sizeof(m_apcTVideoIOYuvReconFile) );
68  memset( m_apcTEncTop, 0, sizeof(m_apcTEncTop) );
69#endif
70}
71
72TAppEncTop::~TAppEncTop()
73{
74}
75
76Void TAppEncTop::xInitLibCfg()
77{
78#if SVC_EXTENSION
79  TComVPS& vps = *m_apcTEncTop[0]->getVPS();
80
81  vps.setMaxTLayers                                               ( m_apcLayerCfg[0]->m_maxTempLayer );
82  if (m_apcLayerCfg[0]->m_maxTempLayer == 1)
83#else
84  TComVPS vps;
85
86  vps.setMaxTLayers                                               ( m_maxTempLayer );
87  if (m_maxTempLayer == 1)
88#endif
89  {
90    vps.setTemporalNestingFlag(true);
91  }
92  vps.setMaxLayers                                                ( 1 );
93  for(Int i = 0; i < MAX_TLAYER; i++)
94  {
95    vps.setNumReorderPics                                         ( m_numReorderPics[i], i );
96    vps.setMaxDecPicBuffering                                     ( m_maxDecPicBuffering[i], i );
97  }
98
99#if !SVC_EXTENSION
100  m_cTEncTop.setVPS(&vps);
101#endif
102 
103#if SVC_EXTENSION
104  vps.setVpsPocLsbAlignedFlag(false); 
105
106  Int maxRepFormatIdx = -1;
107  Int formatIdx = -1;
108  for(UInt layer=0; layer < m_numLayers; layer++)
109  {
110    // Auto generation of the format index
111    if( m_apcLayerCfg[layer]->getRepFormatIdx() == -1 )
112    {     
113      Bool found = false;
114      for( UInt idx = 0; idx < layer; idx++ )
115      {
116        if( m_apcLayerCfg[layer]->m_iSourceWidth == m_apcLayerCfg[idx]->m_iSourceWidth && m_apcLayerCfg[layer]->m_iSourceHeight == m_apcLayerCfg[idx]->m_iSourceHeight
117#if AUXILIARY_PICTURES
118          && m_apcLayerCfg[layer]->m_chromaFormatIDC == m_apcLayerCfg[idx]->m_chromaFormatIDC
119#endif
120          && m_apcLayerCfg[layer]->m_internalBitDepth[CHANNEL_TYPE_LUMA] == m_apcLayerCfg[idx]->m_internalBitDepth[CHANNEL_TYPE_LUMA] && m_apcLayerCfg[layer]->m_internalBitDepth[CHANNEL_TYPE_CHROMA] == m_apcLayerCfg[idx]->m_internalBitDepth[CHANNEL_TYPE_CHROMA]
121          )
122        {
123          found = true;
124          break;
125        }
126      }
127      if( !found )
128      {
129        formatIdx++;
130      }
131
132      m_apcLayerCfg[layer]->setRepFormatIdx( formatIdx );
133    }
134
135    assert( m_apcLayerCfg[layer]->getRepFormatIdx() != -1 && "RepFormatIdx not assigned for a layer" );
136
137    vps.setVpsRepFormatIdx( layer, m_apcLayerCfg[layer]->getRepFormatIdx() );
138
139    maxRepFormatIdx = std::max( m_apcLayerCfg[layer]->getRepFormatIdx(), maxRepFormatIdx );
140  }
141
142  assert( vps.getVpsRepFormatIdx( 0 ) == 0 );  // Base layer should point to the first one.
143
144  Int* mapIdxToLayer = new Int[maxRepFormatIdx + 1];
145
146  // Check that all the indices from 0 to maxRepFormatIdx are used in the VPS
147  for(Int i = 0; i <= maxRepFormatIdx; i++)
148  {
149    mapIdxToLayer[i] = -1;
150    UInt layer;
151    for(layer=0; layer < m_numLayers; layer++)
152    {
153      if( vps.getVpsRepFormatIdx(layer) == i )
154      {
155        mapIdxToLayer[i] = layer;
156        break;
157      }
158    }
159    assert( layer != m_numLayers );   // One of the VPS Rep format indices not set
160  }
161
162  vps.setVpsNumRepFormats                                                ( maxRepFormatIdx + 1 );
163
164  // When not present, the value of rep_format_idx_present_flag is inferred to be equal to 0
165  vps.setRepFormatIdxPresentFlag                                         ( vps.getVpsNumRepFormats() > 1 ? true : false );
166
167  for(UInt idx=0; idx < vps.getVpsNumRepFormats(); idx++)
168  {
169    RepFormat *repFormat = vps.getVpsRepFormat( idx );
170    repFormat->setChromaAndBitDepthVpsPresentFlag                         ( true ); 
171    if (idx==0)
172    {
173      assert(repFormat->getChromaAndBitDepthVpsPresentFlag() == true); 
174    }
175
176    repFormat->setPicWidthVpsInLumaSamples                                ( m_apcLayerCfg[mapIdxToLayer[idx]]->m_iSourceWidth   );
177    repFormat->setPicHeightVpsInLumaSamples                               ( m_apcLayerCfg[mapIdxToLayer[idx]]->m_iSourceHeight  );
178#if AUXILIARY_PICTURES
179    repFormat->setChromaFormatVpsIdc                                      ( m_apcLayerCfg[mapIdxToLayer[idx]]->m_chromaFormatIDC );
180#else
181    repFormat->setChromaFormatVpsIdc                                      ( 1 );  // Need modification to change for each layer - corresponds to 420
182#endif
183    repFormat->setSeparateColourPlaneVpsFlag                              ( 0 );  // Need modification to change for each layer
184
185    repFormat->setBitDepthVpsLuma                                         ( getInternalBitDepth(mapIdxToLayer[idx], CHANNEL_TYPE_LUMA)      );  // Need modification to change for each layer
186    repFormat->setBitDepthVpsChroma                                       ( getInternalBitDepth(mapIdxToLayer[idx], CHANNEL_TYPE_CHROMA)    );  // Need modification to change for each layer
187
188    repFormat->getConformanceWindowVps().setWindow                        ( m_apcLayerCfg[mapIdxToLayer[idx]]->m_confWinLeft,                                                                             
189                                                                            m_apcLayerCfg[mapIdxToLayer[idx]]->m_confWinRight, 
190                                                                            m_apcLayerCfg[mapIdxToLayer[idx]]->m_confWinTop,
191                                                                            m_apcLayerCfg[mapIdxToLayer[idx]]->m_confWinBottom );
192
193    m_apcTEncTop[mapIdxToLayer[idx]]->setSkipPictureAtArcSwitch           ( m_skipPictureAtArcSwitch );
194  }
195
196  delete [] mapIdxToLayer;
197
198  //Populate PTL in VPS
199  for( Int ii = 0; ii < m_numPTLInfo; ii++ )
200  {
201    vps.getPTL(ii)->getGeneralPTL()->setLevelIdc(m_levelList[ii]);
202    vps.getPTL(ii)->getGeneralPTL()->setTierFlag(m_levelTierList[ii]);
203    vps.getPTL(ii)->getGeneralPTL()->setProfileIdc(m_profileList[ii]);
204    vps.getPTL(ii)->getGeneralPTL()->setProfileCompatibilityFlag(m_profileCompatibility[ii], 1);
205    vps.getPTL(ii)->getGeneralPTL()->setProgressiveSourceFlag(m_progressiveSourceFlagList[ii]);
206    vps.getPTL(ii)->getGeneralPTL()->setInterlacedSourceFlag(m_interlacedSourceFlagList[ii]);
207    vps.getPTL(ii)->getGeneralPTL()->setNonPackedConstraintFlag(m_nonPackedConstraintFlagList[ii]);
208    vps.getPTL(ii)->getGeneralPTL()->setFrameOnlyConstraintFlag(m_frameOnlyConstraintFlagList[ii]);
209  }
210  vps.setNumProfileTierLevel(m_numPTLInfo);
211
212  std::vector<Int> myvector;
213  vps.getProfileLevelTierIdx()->resize(m_numOutputLayerSets);
214  for( Int ii = 0; ii < m_numOutputLayerSets; ii++ )
215  {
216    myvector =  m_listOfLayerPTLofOlss[ii];
217
218    for( std::vector<Int>::iterator it = myvector.begin() ; it != myvector.end(); ++it )
219    {
220      vps.addProfileLevelTierIdx(ii, it[0]);
221    }
222  }
223
224  assert( m_numLayers <= MAX_LAYERS );
225
226  for( UInt layer=0; layer < m_numLayers; layer++ )
227  {
228    TEncTop& m_cTEncTop = *m_apcTEncTop[layer];
229    //1
230    m_cTEncTop.setInterLayerWeightedPredFlag                      ( m_useInterLayerWeightedPred );
231    m_cTEncTop.setMFMEnabledFlag                                  ( layer == 0 ? false : ( m_nonHEVCBaseLayerFlag ? false : true ) && m_apcLayerCfg[layer]->getNumMotionPredRefLayers());
232
233    // set layer ID
234    m_cTEncTop.setLayerId                                         ( m_apcLayerCfg[layer]->m_layerId );
235    m_cTEncTop.setNumLayer                                        ( m_numLayers );
236    m_cTEncTop.setLayerEnc                                        ( m_apcTEncTop );
237
238    if( layer < m_numLayers - 1 )
239    {
240       m_cTEncTop.setMaxTidIlRefPicsPlus1                         ( m_apcLayerCfg[layer]->getMaxTidIlRefPicsPlus1());
241    }
242
243    if( layer )
244    {
245      UInt prevLayerIdx = 0;
246      UInt prevLayerId  = 0;
247      if (m_apcLayerCfg[layer]->getNumActiveRefLayers() > 0)
248      {
249        prevLayerIdx = m_apcLayerCfg[layer]->getPredLayerIdx(m_apcLayerCfg[layer]->getNumActiveRefLayers() - 1);
250        prevLayerId  = m_cTEncTop.getRefLayerId(prevLayerIdx);
251      }
252      for(Int i = 0; i < MAX_VPS_LAYER_IDX_PLUS1; i++)
253      {
254        m_cTEncTop.setSamplePredEnabledFlag                       (i, false);
255        m_cTEncTop.setMotionPredEnabledFlag                       (i, false);
256      }
257      if(m_apcLayerCfg[layer]->getNumSamplePredRefLayers() == -1)
258      {
259        // Not included in the configuration file; assume that each layer depends on previous layer
260        m_cTEncTop.setNumSamplePredRefLayers                      (1);      // One sample pred ref. layer
261        m_cTEncTop.setSamplePredRefLayerId                        (prevLayerIdx, prevLayerId);   // Previous layer
262        m_cTEncTop.setSamplePredEnabledFlag                       (prevLayerIdx, true);
263      }
264      else
265      {
266        m_cTEncTop.setNumSamplePredRefLayers                      ( m_apcLayerCfg[layer]->getNumSamplePredRefLayers() );
267        for( Int i = 0; i < m_cTEncTop.getNumSamplePredRefLayers(); i++ )
268        {
269          m_cTEncTop.setSamplePredRefLayerId                      ( i, m_apcLayerCfg[layer]->getSamplePredRefLayerId(i));
270        }
271      }
272      if( m_apcLayerCfg[layer]->getNumMotionPredRefLayers() == -1)
273      {
274        // Not included in the configuration file; assume that each layer depends on previous layer
275        m_cTEncTop.setNumMotionPredRefLayers                      (1);      // One motion pred ref. layer
276        m_cTEncTop.setMotionPredRefLayerId                        (prevLayerIdx, prevLayerId);   // Previous layer
277        m_cTEncTop.setMotionPredEnabledFlag                       (prevLayerIdx, true);
278      }
279      else
280      {
281        m_cTEncTop.setNumMotionPredRefLayers                      ( m_apcLayerCfg[layer]->getNumMotionPredRefLayers() );
282        for( Int i = 0; i < m_cTEncTop.getNumMotionPredRefLayers(); i++ )
283        {
284          m_cTEncTop.setMotionPredRefLayerId                      ( i, m_apcLayerCfg[layer]->getMotionPredRefLayerId(i));
285        }
286      }
287      Int numDirectRefLayers = 0;
288
289      assert( layer < MAX_LAYERS );
290
291      for (Int i = 0; i < m_apcLayerCfg[layer]->m_layerId; i++)
292      {
293        Int refLayerId = -1;
294
295        for( Int layerIdc = 0; layerIdc < m_cTEncTop.getNumSamplePredRefLayers(); layerIdc++ )
296        {
297          if( m_apcLayerCfg[layer]->getSamplePredRefLayerId(layerIdc) == i )
298          {
299            refLayerId = i;
300            m_cTEncTop.setSamplePredEnabledFlag( numDirectRefLayers, true );
301            break;
302          }
303        }
304
305        for( Int layerIdc = 0; layerIdc < m_cTEncTop.getNumMotionPredRefLayers(); layerIdc++ )
306        {
307          if( m_apcLayerCfg[layer]->getMotionPredRefLayerId(layerIdc) == i )
308          {
309            refLayerId = i;
310            m_cTEncTop.setMotionPredEnabledFlag( numDirectRefLayers, true );
311            break;
312          }
313        }
314
315        if( refLayerId >= 0 )
316        {
317          m_cTEncTop.setRefLayerId                                ( numDirectRefLayers, refLayerId );
318          numDirectRefLayers++;
319        }
320      }
321
322      m_cTEncTop.setNumDirectRefLayers                            ( numDirectRefLayers );
323
324      if(m_apcLayerCfg[layer]->getNumActiveRefLayers() == -1)
325      {
326        m_cTEncTop.setNumActiveRefLayers                          ( m_cTEncTop.getNumDirectRefLayers() );
327        for( Int i = 0; i < m_cTEncTop.getNumActiveRefLayers(); i++ )
328        {
329          m_cTEncTop.setPredLayerIdx(i, i);
330        }
331      }
332      else
333      {
334        m_cTEncTop.setNumActiveRefLayers                          ( m_apcLayerCfg[layer]->getNumActiveRefLayers() );
335        for(Int i = 0; i < m_cTEncTop.getNumActiveRefLayers(); i++)
336        {
337          m_cTEncTop.setPredLayerIdx                              ( i, m_apcLayerCfg[layer]->getPredLayerIdx(i));
338        }
339      }
340    }
341    else
342    {
343      assert( layer == 0 );
344      m_cTEncTop.setNumDirectRefLayers(0);
345    }
346
347    if( layer > 0 )
348    {
349#if AUXILIARY_PICTURES
350      Int subWidthC  = ( m_apcLayerCfg[layer]->m_chromaFormatIDC == CHROMA_420 || m_apcLayerCfg[layer]->m_chromaFormatIDC == CHROMA_422 ) ? 2 : 1;
351      Int subHeightC = ( m_apcLayerCfg[layer]->m_chromaFormatIDC == CHROMA_420 ) ? 2 : 1;
352#else
353      Int subWidthC  = 2;
354      Int subHeightC = 2;
355#endif
356      m_cTEncTop.setNumRefLayerLocationOffsets          ( m_apcLayerCfg[layer]->m_numRefLayerLocationOffsets );
357      for(Int i = 0; i < m_apcLayerCfg[layer]->m_numRefLayerLocationOffsets; i++)
358      {
359        m_cTEncTop.setRefLocationOffsetLayerId          ( i, m_apcLayerCfg[layer]->m_refLocationOffsetLayerId[i]);
360        m_cTEncTop.setScaledRefLayerOffsetPresentFlag   ( i, m_apcLayerCfg[layer]->m_scaledRefLayerOffsetPresentFlag[i] );
361        m_cTEncTop.getScaledRefLayerWindow(i).setWindow ( subWidthC  * m_apcLayerCfg[layer]->m_scaledRefLayerLeftOffset[i], subWidthC  * m_apcLayerCfg[layer]->m_scaledRefLayerRightOffset[i],
362          subHeightC * m_apcLayerCfg[layer]->m_scaledRefLayerTopOffset[i],  subHeightC * m_apcLayerCfg[layer]->m_scaledRefLayerBottomOffset[i]);
363
364        Int rlSubWidthC  = ( m_apcLayerCfg[i]->m_chromaFormatIDC == CHROMA_420 || m_apcLayerCfg[i]->m_chromaFormatIDC == CHROMA_422 ) ? 2 : 1;
365        Int rlSubHeightC = ( m_apcLayerCfg[i]->m_chromaFormatIDC == CHROMA_420 ) ? 2 : 1;
366
367        m_cTEncTop.setRefRegionOffsetPresentFlag        ( i, m_apcLayerCfg[layer]->m_refRegionOffsetPresentFlag[i] );
368        m_cTEncTop.getRefLayerWindow(i).setWindow       ( rlSubWidthC  * m_apcLayerCfg[layer]->m_refRegionLeftOffset[i], rlSubWidthC  * m_apcLayerCfg[layer]->m_refRegionRightOffset[i],
369          rlSubHeightC * m_apcLayerCfg[layer]->m_refRegionTopOffset[i],  rlSubHeightC * m_apcLayerCfg[layer]->m_refRegionBottomOffset[i]);
370        m_cTEncTop.setResamplePhaseSetPresentFlag       ( i, m_apcLayerCfg[layer]->m_resamplePhaseSetPresentFlag[i] );
371        m_cTEncTop.setPhaseHorLuma                      ( i, m_apcLayerCfg[layer]->m_phaseHorLuma[i] );
372        m_cTEncTop.setPhaseVerLuma                      ( i, m_apcLayerCfg[layer]->m_phaseVerLuma[i] );
373        m_cTEncTop.setPhaseHorChroma                    ( i, m_apcLayerCfg[layer]->m_phaseHorChroma[i] );
374        m_cTEncTop.setPhaseVerChroma                    ( i, m_apcLayerCfg[layer]->m_phaseVerChroma[i] );
375      }
376    }
377
378    m_cTEncTop.setElRapSliceTypeB                        ( m_elRapSliceBEnabled );
379
380    m_cTEncTop.setAdaptiveResolutionChange               ( m_adaptiveResolutionChange );
381    m_cTEncTop.setLayerSwitchOffBegin                    ( m_apcLayerCfg[layer]->m_layerSwitchOffBegin );
382    m_cTEncTop.setLayerSwitchOffEnd                      ( m_apcLayerCfg[layer]->m_layerSwitchOffEnd );
383    m_cTEncTop.setChromaFormatIDC                        ( m_apcLayerCfg[layer]->m_chromaFormatIDC );
384    m_cTEncTop.setAltOuputLayerFlag                      ( m_altOutputLayerFlag );
385    m_cTEncTop.setCrossLayerBLAFlag                      ( m_crossLayerBLAFlag );
386#if CGS_3D_ASYMLUT
387    m_cTEncTop.setCGSFlag                                ( layer == 0 ? 0 : m_nCGSFlag );
388    m_cTEncTop.setCGSMaxOctantDepth                      ( m_nCGSMaxOctantDepth );
389    m_cTEncTop.setCGSMaxYPartNumLog2                     ( m_nCGSMaxYPartNumLog2 );
390    m_cTEncTop.setCGSLUTBit                              ( m_nCGSLUTBit );
391    m_cTEncTop.setCGSAdaptChroma                         ( m_nCGSAdaptiveChroma );
392#if R0179_ENC_OPT_3DLUT_SIZE
393    m_cTEncTop.setCGSLutSizeRDO                          ( m_nCGSLutSizeRDO );
394#endif
395#endif
396    m_cTEncTop.setNumAddLayerSets                        ( m_numAddLayerSets );
397
398#if FAST_INTRA_SHVC
399    m_cTEncTop.setUseFastIntraScalable                              ( m_useFastIntraScalable );
400#endif
401
402#if P0123_ALPHA_CHANNEL_SEI
403    m_cTEncTop.setAlphaSEIEnabled                                   ( m_alphaSEIEnabled );
404    m_cTEncTop.setAlphaCancelFlag                                   ( m_alphaCancelFlag );
405    m_cTEncTop.setAlphaUseIdc                                       ( m_alphaUseIdc );
406    m_cTEncTop.setAlphaBitDepthMinus8                               ( m_alphaBitDepthMinus8 );
407    m_cTEncTop.setAlphaTransparentValue                             ( m_alphaTransparentValue );
408    m_cTEncTop.setAlphaOpaqueValue                                  ( m_alphaOpaqueValue );
409    m_cTEncTop.setAlphaIncrementFlag                                ( m_alphaIncrementFlag );
410    m_cTEncTop.setAlphaClipFlag                                     ( m_alphaClipFlag );
411    m_cTEncTop.setAlphaClipTypeFlag                                 ( m_alphaClipTypeFlag );
412#endif
413#if Q0096_OVERLAY_SEI
414    m_cTEncTop.setOverlaySEIEnabled                                 ( m_overlaySEIEnabled );
415    m_cTEncTop.setOverlaySEICancelFlag                              ( m_overlayInfoCancelFlag );
416    m_cTEncTop.setOverlaySEIContentAuxIdMinus128                    ( m_overlayContentAuxIdMinus128 );
417    m_cTEncTop.setOverlaySEILabelAuxIdMinus128                      ( m_overlayLabelAuxIdMinus128 );
418    m_cTEncTop.setOverlaySEIAlphaAuxIdMinus128                      ( m_overlayAlphaAuxIdMinus128 );
419    m_cTEncTop.setOverlaySEIElementLabelValueLengthMinus8           ( m_overlayElementLabelValueLengthMinus8 );
420    m_cTEncTop.setOverlaySEINumOverlaysMinus1                       ( m_numOverlaysMinus1 );
421    m_cTEncTop.setOverlaySEIIdx                                     ( m_overlayIdx );
422    m_cTEncTop.setOverlaySEILanguagePresentFlag                     ( m_overlayLanguagePresentFlag );
423    m_cTEncTop.setOverlaySEIContentLayerId                          ( m_overlayContentLayerId );
424    m_cTEncTop.setOverlaySEILabelPresentFlag                        ( m_overlayLabelPresentFlag );
425    m_cTEncTop.setOverlaySEILabelLayerId                            ( m_overlayLabelLayerId );
426    m_cTEncTop.setOverlaySEIAlphaPresentFlag                        ( m_overlayAlphaPresentFlag );
427    m_cTEncTop.setOverlaySEIAlphaLayerId                            ( m_overlayAlphaLayerId );
428    m_cTEncTop.setOverlaySEINumElementsMinus1                       ( m_numOverlayElementsMinus1 );
429    m_cTEncTop.setOverlaySEIElementLabelMin                         ( m_overlayElementLabelMin );
430    m_cTEncTop.setOverlaySEIElementLabelMax                         ( m_overlayElementLabelMax );
431    m_cTEncTop.setOverlaySEILanguage                                ( m_overlayLanguage );
432    m_cTEncTop.setOverlaySEIName                                    ( m_overlayName );
433    m_cTEncTop.setOverlaySEIElementName                             ( m_overlayElementName );
434    m_cTEncTop.setOverlaySEIPersistenceFlag                         ( m_overlayInfoPersistenceFlag );
435#endif 
436#if Q0189_TMVP_CONSTRAINTS
437    m_cTEncTop.setTMVPConstraintsSEIEnabled                         ( m_TMVPConstraintsSEIEnabled);           
438#endif
439#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
440    m_cTEncTop.setInterLayerConstrainedTileSetsSEIEnabled           ( m_interLayerConstrainedTileSetsSEIEnabled );
441    m_cTEncTop.setIlNumSetsInMessage                                ( m_ilNumSetsInMessage );
442    m_cTEncTop.setSkippedTileSetPresentFlag                         ( m_skippedTileSetPresentFlag );
443    m_cTEncTop.setTopLeftTileIndex                                  ( m_topLeftTileIndex );
444    m_cTEncTop.setBottomRightTileIndex                              ( m_bottomRightTileIndex );
445    m_cTEncTop.setIlcIdc                                            ( m_ilcIdc );
446#endif
447
448    Int& layerPTLIdx                                            = m_apcLayerCfg[layer]->m_layerPTLIdx;
449
450    Profile::Name& m_profile                                    = m_profileList[layerPTLIdx];
451    Level::Tier&   m_levelTier                                  = m_levelTierList[layerPTLIdx];
452    Level::Name&   m_level                                      = m_levelList[layerPTLIdx];
453    UInt&          m_bitDepthConstraint                         = m_apcLayerCfg[layer]->m_bitDepthConstraint;
454    ChromaFormat&  m_chromaFormatConstraint                     = m_apcLayerCfg[layer]->m_chromaFormatConstraint;
455    Bool&          m_intraConstraintFlag                        = m_apcLayerCfg[layer]->m_intraConstraintFlag;
456    Bool&          m_onePictureOnlyConstraintFlag               = m_apcLayerCfg[layer]->m_onePictureOnlyConstraintFlag;
457    Bool&          m_lowerBitRateConstraintFlag                 = m_apcLayerCfg[layer]->m_lowerBitRateConstraintFlag;
458    Bool&          m_progressiveSourceFlag                      = m_progressiveSourceFlagList[layerPTLIdx];
459    Bool&          m_interlacedSourceFlag                       = m_interlacedSourceFlagList[layerPTLIdx];
460    Bool&          m_nonPackedConstraintFlag                    = m_nonPackedConstraintFlagList[layerPTLIdx];
461    Bool&          m_frameOnlyConstraintFlag                    = m_frameOnlyConstraintFlagList[layerPTLIdx];
462
463    Int&           m_iFrameRate                                 = m_apcLayerCfg[layer]->m_iFrameRate;
464    Int&           m_iSourceWidth                               = m_apcLayerCfg[layer]->m_iSourceWidth;
465    Int&           m_iSourceHeight                              = m_apcLayerCfg[layer]->m_iSourceHeight;
466    Int&           m_confWinLeft                                = m_apcLayerCfg[layer]->m_confWinLeft;
467    Int&           m_confWinRight                               = m_apcLayerCfg[layer]->m_confWinRight;
468    Int&           m_confWinTop                                 = m_apcLayerCfg[layer]->m_confWinTop;
469    Int&           m_confWinBottom                              = m_apcLayerCfg[layer]->m_confWinBottom;
470
471    Int&           m_iIntraPeriod                               = m_apcLayerCfg[layer]->m_iIntraPeriod;
472    Int&           m_iQP                                        = m_apcLayerCfg[layer]->m_iQP;
473    Int           *m_aiPad                                      = m_apcLayerCfg[layer]->m_aiPad;
474
475    Int&           m_iMaxCuDQPDepth                             = m_apcLayerCfg[layer]->m_iMaxCuDQPDepth;
476    ChromaFormat&  m_chromaFormatIDC                            = m_apcLayerCfg[layer]->m_chromaFormatIDC;
477    Int           *m_aidQP                                      = m_apcLayerCfg[layer]->m_aidQP;
478
479    UInt&          m_uiMaxCUWidth                               = m_apcLayerCfg[layer]->m_uiMaxCUWidth;
480    UInt&          m_uiMaxCUHeight                              = m_apcLayerCfg[layer]->m_uiMaxCUHeight;
481    UInt&          m_uiMaxTotalCUDepth                          = m_apcLayerCfg[layer]->m_uiMaxTotalCUDepth;
482    UInt&          m_uiLog2DiffMaxMinCodingBlockSize            = m_apcLayerCfg[layer]->m_uiLog2DiffMaxMinCodingBlockSize;
483    UInt&          m_uiQuadtreeTULog2MaxSize                    = m_apcLayerCfg[layer]->m_uiQuadtreeTULog2MaxSize;
484    UInt&          m_uiQuadtreeTULog2MinSize                    = m_apcLayerCfg[layer]->m_uiQuadtreeTULog2MinSize;
485    UInt&          m_uiQuadtreeTUMaxDepthInter                  = m_apcLayerCfg[layer]->m_uiQuadtreeTUMaxDepthInter;
486    UInt&          m_uiQuadtreeTUMaxDepthIntra                  = m_apcLayerCfg[layer]->m_uiQuadtreeTUMaxDepthIntra;
487
488    Bool&          m_entropyCodingSyncEnabledFlag               = m_apcLayerCfg[layer]->m_entropyCodingSyncEnabledFlag;
489    Bool&          m_RCEnableRateControl                        = m_apcLayerCfg[layer]->m_RCEnableRateControl;
490    Int&           m_RCTargetBitrate                            = m_apcLayerCfg[layer]->m_RCTargetBitrate;
491    Bool&          m_RCKeepHierarchicalBit                      = m_apcLayerCfg[layer]->m_RCKeepHierarchicalBit;
492    Bool&          m_RCLCULevelRC                               = m_apcLayerCfg[layer]->m_RCLCULevelRC;
493    Bool&          m_RCUseLCUSeparateModel                      = m_apcLayerCfg[layer]->m_RCUseLCUSeparateModel;
494    Int&           m_RCInitialQP                                = m_apcLayerCfg[layer]->m_RCInitialQP;
495    Bool&          m_RCForceIntraQP                             = m_apcLayerCfg[layer]->m_RCForceIntraQP;
496
497#if U0132_TARGET_BITS_SATURATION
498    Bool&          m_RCCpbSaturationEnabled                     = m_apcLayerCfg[layer]->m_RCCpbSaturationEnabled;
499    UInt&          m_RCCpbSize                                  = m_apcLayerCfg[layer]->m_RCCpbSize;
500    Double&        m_RCInitialCpbFullness                       = m_apcLayerCfg[layer]->m_RCInitialCpbFullness;
501#endif
502
503    ScalingListMode& m_useScalingListId                         = m_apcLayerCfg[layer]->m_useScalingListId;
504    string&        m_scalingListFileName                        = m_apcLayerCfg[layer]->m_scalingListFileName;
505    Bool&          m_bUseSAO                                    = m_apcLayerCfg[layer]->m_bUseSAO;
506
507    GOPEntry*      m_GOPList                                    = m_apcLayerCfg[layer]->m_GOPList;
508    Int&           m_extraRPSs                                  = m_apcLayerCfg[layer]->m_extraRPSs;
509    Int&           m_maxTempLayer                               = m_apcLayerCfg[layer]->m_maxTempLayer;
510
511    string&        m_colourRemapSEIFileRoot                     = m_apcLayerCfg[layer]->m_colourRemapSEIFileRoot;
512#endif
513
514  m_cTEncTop.setProfile                                           ( m_profile);
515  m_cTEncTop.setLevel                                             ( m_levelTier, m_level);
516  m_cTEncTop.setProgressiveSourceFlag                             ( m_progressiveSourceFlag);
517  m_cTEncTop.setInterlacedSourceFlag                              ( m_interlacedSourceFlag);
518  m_cTEncTop.setNonPackedConstraintFlag                           ( m_nonPackedConstraintFlag);
519  m_cTEncTop.setFrameOnlyConstraintFlag                           ( m_frameOnlyConstraintFlag);
520  m_cTEncTop.setBitDepthConstraintValue                           ( m_bitDepthConstraint );
521  m_cTEncTop.setChromaFormatConstraintValue                       ( m_chromaFormatConstraint );
522  m_cTEncTop.setIntraConstraintFlag                               ( m_intraConstraintFlag );
523  m_cTEncTop.setOnePictureOnlyConstraintFlag                      ( m_onePictureOnlyConstraintFlag );
524  m_cTEncTop.setLowerBitRateConstraintFlag                        ( m_lowerBitRateConstraintFlag );
525
526  m_cTEncTop.setPrintMSEBasedSequencePSNR                         ( m_printMSEBasedSequencePSNR);
527  m_cTEncTop.setPrintFrameMSE                                     ( m_printFrameMSE);
528  m_cTEncTop.setPrintSequenceMSE                                  ( m_printSequenceMSE);
529  m_cTEncTop.setCabacZeroWordPaddingEnabled                       ( m_cabacZeroWordPaddingEnabled );
530
531  m_cTEncTop.setFrameRate                                         ( m_iFrameRate );
532  m_cTEncTop.setFrameSkip                                         ( m_FrameSkip );
533  m_cTEncTop.setSourceWidth                                       ( m_iSourceWidth );
534  m_cTEncTop.setSourceHeight                                      ( m_iSourceHeight );
535  m_cTEncTop.setConformanceWindow                                 ( m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom );
536  m_cTEncTop.setFramesToBeEncoded                                 ( m_framesToBeEncoded );
537
538  //====== Coding Structure ========
539  m_cTEncTop.setIntraPeriod                                       ( m_iIntraPeriod );
540  m_cTEncTop.setDecodingRefreshType                               ( m_iDecodingRefreshType );
541  m_cTEncTop.setGOPSize                                           ( m_iGOPSize );
542  m_cTEncTop.setGopList                                           ( m_GOPList );
543  m_cTEncTop.setExtraRPSs                                         ( m_extraRPSs );
544  for(Int i = 0; i < MAX_TLAYER; i++)
545  {
546    m_cTEncTop.setNumReorderPics                                  ( m_numReorderPics[i], i );
547    m_cTEncTop.setMaxDecPicBuffering                              ( m_maxDecPicBuffering[i], i );
548  }
549  for( UInt uiLoop = 0; uiLoop < MAX_TLAYER; ++uiLoop )
550  {
551    m_cTEncTop.setLambdaModifier                                  ( uiLoop, m_adLambdaModifier[ uiLoop ] );
552  }
553  m_cTEncTop.setIntraLambdaModifier                               ( m_adIntraLambdaModifier );
554  m_cTEncTop.setIntraQpFactor                                     ( m_dIntraQpFactor );
555
556  m_cTEncTop.setQP                                                ( m_iQP );
557
558  m_cTEncTop.setPad                                               ( m_aiPad );
559
560  m_cTEncTop.setAccessUnitDelimiter                               ( m_AccessUnitDelimiter );
561
562  m_cTEncTop.setMaxTempLayer                                      ( m_maxTempLayer );
563  m_cTEncTop.setUseAMP( m_enableAMP );
564
565  //===== Slice ========
566
567  //====== Loop/Deblock Filter ========
568  m_cTEncTop.setLoopFilterDisable                                 ( m_bLoopFilterDisable       );
569  m_cTEncTop.setLoopFilterOffsetInPPS                             ( m_loopFilterOffsetInPPS );
570  m_cTEncTop.setLoopFilterBetaOffset                              ( m_loopFilterBetaOffsetDiv2  );
571  m_cTEncTop.setLoopFilterTcOffset                                ( m_loopFilterTcOffsetDiv2    );
572  m_cTEncTop.setDeblockingFilterMetric                            ( m_DeblockingFilterMetric );
573
574  //====== Motion search ========
575  m_cTEncTop.setDisableIntraPUsInInterSlices                      ( m_bDisableIntraPUsInInterSlices );
576  m_cTEncTop.setMotionEstimationSearchMethod                      ( m_motionEstimationSearchMethod  );
577  m_cTEncTop.setSearchRange                                       ( m_iSearchRange );
578  m_cTEncTop.setBipredSearchRange                                 ( m_bipredSearchRange );
579  m_cTEncTop.setClipForBiPredMeEnabled                            ( m_bClipForBiPredMeEnabled );
580  m_cTEncTop.setFastMEAssumingSmootherMVEnabled                   ( m_bFastMEAssumingSmootherMVEnabled );
581  m_cTEncTop.setMinSearchWindow                                   ( m_minSearchWindow );
582  m_cTEncTop.setRestrictMESampling                                ( m_bRestrictMESampling );
583
584  //====== Quality control ========
585  m_cTEncTop.setMaxDeltaQP                                        ( m_iMaxDeltaQP  );
586  m_cTEncTop.setMaxCuDQPDepth                                     ( m_iMaxCuDQPDepth  );
587  m_cTEncTop.setDiffCuChromaQpOffsetDepth                         ( m_diffCuChromaQpOffsetDepth );
588  m_cTEncTop.setChromaCbQpOffset                                  ( m_cbQpOffset     );
589  m_cTEncTop.setChromaCrQpOffset                                  ( m_crQpOffset  );
590
591  m_cTEncTop.setChromaFormatIdc                                   ( m_chromaFormatIDC  );
592
593#if ADAPTIVE_QP_SELECTION
594  m_cTEncTop.setUseAdaptQpSelect                                  ( m_bUseAdaptQpSelect   );
595#endif
596
597  m_cTEncTop.setUseAdaptiveQP                                     ( m_bUseAdaptiveQP  );
598  m_cTEncTop.setQPAdaptationRange                                 ( m_iQPAdaptationRange );
599  m_cTEncTop.setExtendedPrecisionProcessingFlag                   ( m_extendedPrecisionProcessingFlag );
600  m_cTEncTop.setHighPrecisionOffsetsEnabledFlag                   ( m_highPrecisionOffsetsEnabledFlag );
601
602  m_cTEncTop.setWeightedPredictionMethod( m_weightedPredictionMethod );
603
604  //====== Tool list ========
605  m_cTEncTop.setDeltaQpRD                                         ( m_uiDeltaQpRD  );
606  m_cTEncTop.setFastDeltaQp                                       ( m_bFastDeltaQP  );
607  m_cTEncTop.setUseASR                                            ( m_bUseASR      );
608  m_cTEncTop.setUseHADME                                          ( m_bUseHADME    );
609  m_cTEncTop.setdQPs                                              ( m_aidQP        );
610  m_cTEncTop.setUseRDOQ                                           ( m_useRDOQ     );
611  m_cTEncTop.setUseRDOQTS                                         ( m_useRDOQTS   );
612#if T0196_SELECTIVE_RDOQ
613  m_cTEncTop.setUseSelectiveRDOQ                                  ( m_useSelectiveRDOQ );
614#endif
615  m_cTEncTop.setRDpenalty                                         ( m_rdPenalty );
616  m_cTEncTop.setMaxCUWidth                                        ( m_uiMaxCUWidth );
617  m_cTEncTop.setMaxCUHeight                                       ( m_uiMaxCUHeight );
618  m_cTEncTop.setMaxTotalCUDepth                                   ( m_uiMaxTotalCUDepth );
619  m_cTEncTop.setLog2DiffMaxMinCodingBlockSize                     ( m_uiLog2DiffMaxMinCodingBlockSize );
620  m_cTEncTop.setQuadtreeTULog2MaxSize                             ( m_uiQuadtreeTULog2MaxSize );
621  m_cTEncTop.setQuadtreeTULog2MinSize                             ( m_uiQuadtreeTULog2MinSize );
622  m_cTEncTop.setQuadtreeTUMaxDepthInter                           ( m_uiQuadtreeTUMaxDepthInter );
623  m_cTEncTop.setQuadtreeTUMaxDepthIntra                           ( m_uiQuadtreeTUMaxDepthIntra );
624  m_cTEncTop.setFastInterSearchMode                               ( m_fastInterSearchMode );
625  m_cTEncTop.setUseEarlyCU                                        ( m_bUseEarlyCU  );
626  m_cTEncTop.setUseFastDecisionForMerge                           ( m_useFastDecisionForMerge  );
627  m_cTEncTop.setUseCbfFastMode                                    ( m_bUseCbfFastMode  );
628  m_cTEncTop.setUseEarlySkipDetection                             ( m_useEarlySkipDetection );
629  m_cTEncTop.setCrossComponentPredictionEnabledFlag               ( m_crossComponentPredictionEnabledFlag );
630  m_cTEncTop.setUseReconBasedCrossCPredictionEstimate             ( m_reconBasedCrossCPredictionEstimate );
631  m_cTEncTop.setLog2SaoOffsetScale                                ( CHANNEL_TYPE_LUMA  , m_log2SaoOffsetScale[CHANNEL_TYPE_LUMA]   );
632  m_cTEncTop.setLog2SaoOffsetScale                                ( CHANNEL_TYPE_CHROMA, m_log2SaoOffsetScale[CHANNEL_TYPE_CHROMA] );
633  m_cTEncTop.setUseTransformSkip                                  ( m_useTransformSkip      );
634  m_cTEncTop.setUseTransformSkipFast                              ( m_useTransformSkipFast  );
635  m_cTEncTop.setTransformSkipRotationEnabledFlag                  ( m_transformSkipRotationEnabledFlag );
636  m_cTEncTop.setTransformSkipContextEnabledFlag                   ( m_transformSkipContextEnabledFlag   );
637  m_cTEncTop.setPersistentRiceAdaptationEnabledFlag               ( m_persistentRiceAdaptationEnabledFlag );
638  m_cTEncTop.setCabacBypassAlignmentEnabledFlag                   ( m_cabacBypassAlignmentEnabledFlag );
639  m_cTEncTop.setLog2MaxTransformSkipBlockSize                     ( m_log2MaxTransformSkipBlockSize  );
640  for (UInt signallingModeIndex = 0; signallingModeIndex < NUMBER_OF_RDPCM_SIGNALLING_MODES; signallingModeIndex++)
641  {
642    m_cTEncTop.setRdpcmEnabledFlag                                ( RDPCMSignallingMode(signallingModeIndex), m_rdpcmEnabledFlag[signallingModeIndex]);
643  }
644  m_cTEncTop.setUseConstrainedIntraPred                           ( m_bUseConstrainedIntraPred );
645  m_cTEncTop.setFastUDIUseMPMEnabled                              ( m_bFastUDIUseMPMEnabled );
646  m_cTEncTop.setFastMEForGenBLowDelayEnabled                      ( m_bFastMEForGenBLowDelayEnabled );
647  m_cTEncTop.setUseBLambdaForNonKeyLowDelayPictures               ( m_bUseBLambdaForNonKeyLowDelayPictures );
648  m_cTEncTop.setPCMLog2MinSize                                    ( m_uiPCMLog2MinSize);
649  m_cTEncTop.setUsePCM                                            ( m_usePCM );
650
651  // set internal bit-depth and constants
652  for (UInt channelType = 0; channelType < MAX_NUM_CHANNEL_TYPE; channelType++)
653  {
654#if SVC_EXTENSION
655    m_cTEncTop.setBitDepth((ChannelType)channelType, m_apcLayerCfg[layer]->m_internalBitDepth[channelType]);
656    m_cTEncTop.setPCMBitDepth((ChannelType)channelType, m_bPCMInputBitDepthFlag ? m_apcLayerCfg[layer]->m_MSBExtendedBitDepth[channelType] : m_apcLayerCfg[layer]->m_internalBitDepth[channelType]);
657#else
658    m_cTEncTop.setBitDepth((ChannelType)channelType, m_internalBitDepth[channelType]);
659    m_cTEncTop.setPCMBitDepth((ChannelType)channelType, m_bPCMInputBitDepthFlag ? m_MSBExtendedBitDepth[channelType] : m_internalBitDepth[channelType]);
660#endif
661  }
662
663  m_cTEncTop.setPCMLog2MaxSize                                    ( m_pcmLog2MaxSize);
664  m_cTEncTop.setMaxNumMergeCand                                   ( m_maxNumMergeCand );
665
666
667  //====== Weighted Prediction ========
668  m_cTEncTop.setUseWP                                             ( m_useWeightedPred     );
669  m_cTEncTop.setWPBiPred                                          ( m_useWeightedBiPred   );
670
671  //====== Parallel Merge Estimation ========
672  m_cTEncTop.setLog2ParallelMergeLevelMinus2                      ( m_log2ParallelMergeLevel - 2 );
673
674  //====== Slice ========
675  m_cTEncTop.setSliceMode                                         ( m_sliceMode );
676  m_cTEncTop.setSliceArgument                                     ( m_sliceArgument );
677
678  //====== Dependent Slice ========
679  m_cTEncTop.setSliceSegmentMode                                  ( m_sliceSegmentMode );
680  m_cTEncTop.setSliceSegmentArgument                              ( m_sliceSegmentArgument );
681
682  if(m_sliceMode == NO_SLICES )
683  {
684    m_bLFCrossSliceBoundaryFlag = true;
685  }
686  m_cTEncTop.setLFCrossSliceBoundaryFlag                          ( m_bLFCrossSliceBoundaryFlag );
687  m_cTEncTop.setUseSAO                                            ( m_bUseSAO );
688  m_cTEncTop.setTestSAODisableAtPictureLevel                      ( m_bTestSAODisableAtPictureLevel );
689  m_cTEncTop.setSaoEncodingRate                                   ( m_saoEncodingRate );
690  m_cTEncTop.setSaoEncodingRateChroma                             ( m_saoEncodingRateChroma );
691  m_cTEncTop.setMaxNumOffsetsPerPic                               ( m_maxNumOffsetsPerPic);
692
693  m_cTEncTop.setSaoCtuBoundary                                    ( m_saoCtuBoundary);
694  m_cTEncTop.setPCMInputBitDepthFlag                              ( m_bPCMInputBitDepthFlag);
695  m_cTEncTop.setPCMFilterDisableFlag                              ( m_bPCMFilterDisableFlag);
696
697  m_cTEncTop.setIntraSmoothingDisabledFlag                        (!m_enableIntraReferenceSmoothing );
698  m_cTEncTop.setDecodedPictureHashSEIType                         ( m_decodedPictureHashSEIType );
699  m_cTEncTop.setRecoveryPointSEIEnabled                           ( m_recoveryPointSEIEnabled );
700  m_cTEncTop.setBufferingPeriodSEIEnabled                         ( m_bufferingPeriodSEIEnabled );
701  m_cTEncTop.setPictureTimingSEIEnabled                           ( m_pictureTimingSEIEnabled );
702  m_cTEncTop.setToneMappingInfoSEIEnabled                         ( m_toneMappingInfoSEIEnabled );
703  m_cTEncTop.setTMISEIToneMapId                                   ( m_toneMapId );
704  m_cTEncTop.setTMISEIToneMapCancelFlag                           ( m_toneMapCancelFlag );
705  m_cTEncTop.setTMISEIToneMapPersistenceFlag                      ( m_toneMapPersistenceFlag );
706  m_cTEncTop.setTMISEICodedDataBitDepth                           ( m_toneMapCodedDataBitDepth );
707  m_cTEncTop.setTMISEITargetBitDepth                              ( m_toneMapTargetBitDepth );
708  m_cTEncTop.setTMISEIModelID                                     ( m_toneMapModelId );
709  m_cTEncTop.setTMISEIMinValue                                    ( m_toneMapMinValue );
710  m_cTEncTop.setTMISEIMaxValue                                    ( m_toneMapMaxValue );
711  m_cTEncTop.setTMISEISigmoidMidpoint                             ( m_sigmoidMidpoint );
712  m_cTEncTop.setTMISEISigmoidWidth                                ( m_sigmoidWidth );
713  m_cTEncTop.setTMISEIStartOfCodedInterva                         ( m_startOfCodedInterval );
714  m_cTEncTop.setTMISEINumPivots                                   ( m_numPivots );
715  m_cTEncTop.setTMISEICodedPivotValue                             ( m_codedPivotValue );
716  m_cTEncTop.setTMISEITargetPivotValue                            ( m_targetPivotValue );
717  m_cTEncTop.setTMISEICameraIsoSpeedIdc                           ( m_cameraIsoSpeedIdc );
718  m_cTEncTop.setTMISEICameraIsoSpeedValue                         ( m_cameraIsoSpeedValue );
719  m_cTEncTop.setTMISEIExposureIndexIdc                            ( m_exposureIndexIdc );
720  m_cTEncTop.setTMISEIExposureIndexValue                          ( m_exposureIndexValue );
721  m_cTEncTop.setTMISEIExposureCompensationValueSignFlag           ( m_exposureCompensationValueSignFlag );
722  m_cTEncTop.setTMISEIExposureCompensationValueNumerator          ( m_exposureCompensationValueNumerator );
723  m_cTEncTop.setTMISEIExposureCompensationValueDenomIdc           ( m_exposureCompensationValueDenomIdc );
724  m_cTEncTop.setTMISEIRefScreenLuminanceWhite                     ( m_refScreenLuminanceWhite );
725  m_cTEncTop.setTMISEIExtendedRangeWhiteLevel                     ( m_extendedRangeWhiteLevel );
726  m_cTEncTop.setTMISEINominalBlackLevelLumaCodeValue              ( m_nominalBlackLevelLumaCodeValue );
727  m_cTEncTop.setTMISEINominalWhiteLevelLumaCodeValue              ( m_nominalWhiteLevelLumaCodeValue );
728  m_cTEncTop.setTMISEIExtendedWhiteLevelLumaCodeValue             ( m_extendedWhiteLevelLumaCodeValue );
729  m_cTEncTop.setChromaResamplingFilterHintEnabled                 ( m_chromaResamplingFilterSEIenabled );
730  m_cTEncTop.setChromaResamplingHorFilterIdc                      ( m_chromaResamplingHorFilterIdc );
731  m_cTEncTop.setChromaResamplingVerFilterIdc                      ( m_chromaResamplingVerFilterIdc );
732  m_cTEncTop.setFramePackingArrangementSEIEnabled                 ( m_framePackingSEIEnabled );
733  m_cTEncTop.setFramePackingArrangementSEIType                    ( m_framePackingSEIType );
734  m_cTEncTop.setFramePackingArrangementSEIId                      ( m_framePackingSEIId );
735  m_cTEncTop.setFramePackingArrangementSEIQuincunx                ( m_framePackingSEIQuincunx );
736  m_cTEncTop.setFramePackingArrangementSEIInterpretation          ( m_framePackingSEIInterpretation );
737  m_cTEncTop.setSegmentedRectFramePackingArrangementSEIEnabled    ( m_segmentedRectFramePackingSEIEnabled );
738  m_cTEncTop.setSegmentedRectFramePackingArrangementSEICancel     ( m_segmentedRectFramePackingSEICancel );
739  m_cTEncTop.setSegmentedRectFramePackingArrangementSEIType       ( m_segmentedRectFramePackingSEIType );
740  m_cTEncTop.setSegmentedRectFramePackingArrangementSEIPersistence( m_segmentedRectFramePackingSEIPersistence );
741  m_cTEncTop.setDisplayOrientationSEIAngle                        ( m_displayOrientationSEIAngle );
742  m_cTEncTop.setTemporalLevel0IndexSEIEnabled                     ( m_temporalLevel0IndexSEIEnabled );
743  m_cTEncTop.setGradualDecodingRefreshInfoEnabled                 ( m_gradualDecodingRefreshInfoEnabled );
744  m_cTEncTop.setNoDisplaySEITLayer                                ( m_noDisplaySEITLayer );
745  m_cTEncTop.setDecodingUnitInfoSEIEnabled                        ( m_decodingUnitInfoSEIEnabled );
746  m_cTEncTop.setSOPDescriptionSEIEnabled                          ( m_SOPDescriptionSEIEnabled );
747  m_cTEncTop.setScalableNestingSEIEnabled                         ( m_scalableNestingSEIEnabled );
748  m_cTEncTop.setTMCTSSEIEnabled                                   ( m_tmctsSEIEnabled );
749  m_cTEncTop.setTimeCodeSEIEnabled                                ( m_timeCodeSEIEnabled );
750  m_cTEncTop.setNumberOfTimeSets                                  ( m_timeCodeSEINumTs );
751  for(Int i = 0; i < m_timeCodeSEINumTs; i++)
752  {
753    m_cTEncTop.setTimeSet(m_timeSetArray[i], i);
754  }
755  m_cTEncTop.setKneeSEIEnabled                                    ( m_kneeSEIEnabled );
756  m_cTEncTop.setKneeSEIId                                         ( m_kneeSEIId );
757  m_cTEncTop.setKneeSEICancelFlag                                 ( m_kneeSEICancelFlag );
758  m_cTEncTop.setKneeSEIPersistenceFlag                            ( m_kneeSEIPersistenceFlag );
759  m_cTEncTop.setKneeSEIInputDrange                                ( m_kneeSEIInputDrange );
760  m_cTEncTop.setKneeSEIInputDispLuminance                         ( m_kneeSEIInputDispLuminance );
761  m_cTEncTop.setKneeSEIOutputDrange                               ( m_kneeSEIOutputDrange );
762  m_cTEncTop.setKneeSEIOutputDispLuminance                        ( m_kneeSEIOutputDispLuminance );
763  m_cTEncTop.setKneeSEINumKneePointsMinus1                        ( m_kneeSEINumKneePointsMinus1 );
764  m_cTEncTop.setKneeSEIInputKneePoint                             ( m_kneeSEIInputKneePoint );
765  m_cTEncTop.setKneeSEIOutputKneePoint                            ( m_kneeSEIOutputKneePoint );
766  m_cTEncTop.setColourRemapInfoSEIFileRoot                        ( m_colourRemapSEIFileRoot );
767  m_cTEncTop.setMasteringDisplaySEI                               ( m_masteringDisplay );
768
769  m_cTEncTop.setTileUniformSpacingFlag                            ( m_tileUniformSpacingFlag );
770  m_cTEncTop.setNumColumnsMinus1                                  ( m_numTileColumnsMinus1 );
771  m_cTEncTop.setNumRowsMinus1                                     ( m_numTileRowsMinus1 );
772  if(!m_tileUniformSpacingFlag)
773  {
774    m_cTEncTop.setColumnWidth                                     ( m_tileColumnWidth );
775    m_cTEncTop.setRowHeight                                       ( m_tileRowHeight );
776  }
777  m_cTEncTop.xCheckGSParameters();
778  Int uiTilesCount = (m_numTileRowsMinus1+1) * (m_numTileColumnsMinus1+1);
779  if(uiTilesCount == 1)
780  {
781    m_bLFCrossTileBoundaryFlag = true;
782  }
783  m_cTEncTop.setLFCrossTileBoundaryFlag                           ( m_bLFCrossTileBoundaryFlag );
784  m_cTEncTop.setEntropyCodingSyncEnabledFlag                      ( m_entropyCodingSyncEnabledFlag );
785  m_cTEncTop.setTMVPModeId                                        ( m_TMVPModeId );
786  m_cTEncTop.setUseScalingListId                                  ( m_useScalingListId  );
787  m_cTEncTop.setScalingListFileName                               ( m_scalingListFileName );
788  m_cTEncTop.setSignHideFlag                                      ( m_signHideFlag);
789  m_cTEncTop.setUseRateCtrl                                       ( m_RCEnableRateControl );
790  m_cTEncTop.setTargetBitrate                                     ( m_RCTargetBitrate );
791  m_cTEncTop.setKeepHierBit                                       ( m_RCKeepHierarchicalBit );
792  m_cTEncTop.setLCULevelRC                                        ( m_RCLCULevelRC );
793  m_cTEncTop.setUseLCUSeparateModel                               ( m_RCUseLCUSeparateModel );
794  m_cTEncTop.setInitialQP                                         ( m_RCInitialQP );
795  m_cTEncTop.setForceIntraQP                                      ( m_RCForceIntraQP );
796#if U0132_TARGET_BITS_SATURATION
797  m_cTEncTop.setCpbSaturationEnabled                              ( m_RCCpbSaturationEnabled );
798  m_cTEncTop.setCpbSize                                           ( m_RCCpbSize );
799  m_cTEncTop.setInitialCpbFullness                                ( m_RCInitialCpbFullness );
800#endif
801  m_cTEncTop.setTransquantBypassEnableFlag                        ( m_TransquantBypassEnableFlag );
802  m_cTEncTop.setCUTransquantBypassFlagForceValue                  ( m_CUTransquantBypassFlagForce );
803  m_cTEncTop.setCostMode                                          ( m_costMode );
804  m_cTEncTop.setUseRecalculateQPAccordingToLambda                 ( m_recalculateQPAccordingToLambda );
805  m_cTEncTop.setUseStrongIntraSmoothing                           ( m_useStrongIntraSmoothing );
806  m_cTEncTop.setActiveParameterSetsSEIEnabled                     ( m_activeParameterSetsSEIEnabled );
807  m_cTEncTop.setVuiParametersPresentFlag                          ( m_vuiParametersPresentFlag );
808  m_cTEncTop.setAspectRatioInfoPresentFlag                        ( m_aspectRatioInfoPresentFlag);
809  m_cTEncTop.setAspectRatioIdc                                    ( m_aspectRatioIdc );
810  m_cTEncTop.setSarWidth                                          ( m_sarWidth );
811  m_cTEncTop.setSarHeight                                         ( m_sarHeight );
812  m_cTEncTop.setOverscanInfoPresentFlag                           ( m_overscanInfoPresentFlag );
813  m_cTEncTop.setOverscanAppropriateFlag                           ( m_overscanAppropriateFlag );
814  m_cTEncTop.setVideoSignalTypePresentFlag                        ( m_videoSignalTypePresentFlag );
815  m_cTEncTop.setVideoFormat                                       ( m_videoFormat );
816  m_cTEncTop.setVideoFullRangeFlag                                ( m_videoFullRangeFlag );
817  m_cTEncTop.setColourDescriptionPresentFlag                      ( m_colourDescriptionPresentFlag );
818  m_cTEncTop.setColourPrimaries                                   ( m_colourPrimaries );
819  m_cTEncTop.setTransferCharacteristics                           ( m_transferCharacteristics );
820  m_cTEncTop.setMatrixCoefficients                                ( m_matrixCoefficients );
821  m_cTEncTop.setChromaLocInfoPresentFlag                          ( m_chromaLocInfoPresentFlag );
822  m_cTEncTop.setChromaSampleLocTypeTopField                       ( m_chromaSampleLocTypeTopField );
823  m_cTEncTop.setChromaSampleLocTypeBottomField                    ( m_chromaSampleLocTypeBottomField );
824  m_cTEncTop.setNeutralChromaIndicationFlag                       ( m_neutralChromaIndicationFlag );
825  m_cTEncTop.setDefaultDisplayWindow                              ( m_defDispWinLeftOffset, m_defDispWinRightOffset, m_defDispWinTopOffset, m_defDispWinBottomOffset );
826  m_cTEncTop.setFrameFieldInfoPresentFlag                         ( m_frameFieldInfoPresentFlag );
827  m_cTEncTop.setPocProportionalToTimingFlag                       ( m_pocProportionalToTimingFlag );
828  m_cTEncTop.setNumTicksPocDiffOneMinus1                          ( m_numTicksPocDiffOneMinus1    );
829  m_cTEncTop.setBitstreamRestrictionFlag                          ( m_bitstreamRestrictionFlag );
830  m_cTEncTop.setTilesFixedStructureFlag                           ( m_tilesFixedStructureFlag );
831  m_cTEncTop.setMotionVectorsOverPicBoundariesFlag                ( m_motionVectorsOverPicBoundariesFlag );
832  m_cTEncTop.setMinSpatialSegmentationIdc                         ( m_minSpatialSegmentationIdc );
833  m_cTEncTop.setMaxBytesPerPicDenom                               ( m_maxBytesPerPicDenom );
834  m_cTEncTop.setMaxBitsPerMinCuDenom                              ( m_maxBitsPerMinCuDenom );
835  m_cTEncTop.setLog2MaxMvLengthHorizontal                         ( m_log2MaxMvLengthHorizontal );
836  m_cTEncTop.setLog2MaxMvLengthVertical                           ( m_log2MaxMvLengthVertical );
837  m_cTEncTop.setEfficientFieldIRAPEnabled                         ( m_bEfficientFieldIRAPEnabled );
838  m_cTEncTop.setHarmonizeGopFirstFieldCoupleEnabled               ( m_bHarmonizeGopFirstFieldCoupleEnabled );
839
840  m_cTEncTop.setSummaryOutFilename                                ( m_summaryOutFilename );
841  m_cTEncTop.setSummaryPicFilenameBase                            ( m_summaryPicFilenameBase );
842  m_cTEncTop.setSummaryVerboseness                                ( m_summaryVerboseness );
843
844#if LAYERS_NOT_PRESENT_SEI
845  m_cTEncTop.setLayersNotPresentSEIEnabled                        ( m_layersNotPresentSEIEnabled );
846#endif 
847
848
849#if SVC_EXTENSION
850  if( layer != 0 && m_useInterLayerWeightedPred )
851  {
852    // Enable weighted prediction for enhancement layer
853    m_cTEncTop.setUseWP                                           ( true   );
854    m_cTEncTop.setWPBiPred                                        ( true   );
855  }
856
857  }
858#endif
859}
860
861Void TAppEncTop::xCreateLib()
862{
863  // Video I/O
864#if SVC_EXTENSION
865  // initialize global variables
866  initROM();
867
868  for(UInt layer=0; layer<m_numLayers; layer++)
869  {
870    //2
871    // Video I/O
872    m_apcTVideoIOYuvInputFile[layer]->open( m_apcLayerCfg[layer]->getInputFileName(),  false, m_apcLayerCfg[layer]->m_inputBitDepth, m_apcLayerCfg[layer]->m_MSBExtendedBitDepth, m_apcLayerCfg[layer]->m_internalBitDepth );  // read  mode
873    m_apcTVideoIOYuvInputFile[layer]->skipFrames(m_FrameSkip, m_apcLayerCfg[layer]->m_iSourceWidth - m_apcLayerCfg[layer]->m_aiPad[0], m_apcLayerCfg[layer]->m_iSourceHeight - m_apcLayerCfg[layer]->m_aiPad[1], m_apcLayerCfg[layer]->m_InputChromaFormatIDC);
874
875    if( !m_apcLayerCfg[layer]->getReconFileName().empty() )
876    {
877      m_apcTVideoIOYuvReconFile[layer]->open( m_apcLayerCfg[layer]->getReconFileName(), true, m_apcLayerCfg[layer]->m_outputBitDepth, m_apcLayerCfg[layer]->m_MSBExtendedBitDepth, m_apcLayerCfg[layer]->m_internalBitDepth );  // write mode
878    }
879
880    // Neo Decoder
881    m_apcTEncTop[layer]->create();
882  }
883#else //SVC_EXTENSION
884  // Video I/O
885  m_cTVideoIOYuvInputFile.open( m_inputFileName,     false, m_inputBitDepth, m_MSBExtendedBitDepth, m_internalBitDepth );  // read  mode
886  m_cTVideoIOYuvInputFile.skipFrames(m_FrameSkip, m_iSourceWidth - m_aiPad[0], m_iSourceHeight - m_aiPad[1], m_InputChromaFormatIDC);
887
888  if (!m_reconFileName.empty())
889  {
890    m_cTVideoIOYuvReconFile.open(m_reconFileName, true, m_outputBitDepth, m_outputBitDepth, m_internalBitDepth);  // write mode
891  }
892
893  // Neo Decoder
894  m_cTEncTop.create();
895#endif //SVC_EXTENSION
896}
897
898Void TAppEncTop::xDestroyLib()
899{
900  // Video I/O
901#if SVC_EXTENSION
902  // destroy ROM
903  destroyROM();
904
905  for( UInt layer=0; layer < m_numLayers; layer++ )
906  {
907    if( m_apcTVideoIOYuvInputFile[layer] )
908    {
909      m_apcTVideoIOYuvInputFile[layer]->close();
910      delete m_apcTVideoIOYuvInputFile[layer];
911      m_apcTVideoIOYuvInputFile[layer] = NULL;
912    }
913
914    if( m_apcTVideoIOYuvReconFile[layer] )
915    {
916      m_apcTVideoIOYuvReconFile[layer]->close();
917      delete m_apcTVideoIOYuvReconFile[layer];
918      m_apcTVideoIOYuvReconFile[layer] = NULL;
919    }
920
921    if( m_apcTEncTop[layer] )
922    {
923      m_apcTEncTop[layer]->destroy();
924      delete m_apcTEncTop[layer];
925      m_apcTEncTop[layer] = NULL;
926    }
927  }
928#else //SVC_EXTENSION
929  m_cTVideoIOYuvInputFile.close();
930  m_cTVideoIOYuvReconFile.close();
931
932  // Neo Decoder
933  m_cTEncTop.destroy();
934#endif //SVC_EXTENSION
935}
936
937Void TAppEncTop::xInitLib(Bool isFieldCoding)
938{
939#if SVC_EXTENSION
940  TComVPS* vps = m_apcTEncTop[0]->getVPS();
941  m_apcTEncTop[0]->getVPS()->setMaxLayers( m_numLayers );
942
943  UInt i = 0, dimIdLen = 0;
944
945  while((1 << dimIdLen) < m_numLayers)
946  {
947    dimIdLen++;
948  }
949  vps->setDimensionIdLen(0, dimIdLen);
950  vps->setNuhLayerIdPresentFlag(false);
951  vps->setLayerIdInNuh(0, 0);
952  vps->setLayerIdxInVps(0, 0);
953  for(i = 1; i < vps->getMaxLayers(); i++)
954  {
955    vps->setLayerIdInNuh(i, m_apcLayerCfg[i]->m_layerId);   
956    vps->setLayerIdxInVps(vps->getLayerIdInNuh(i), i);
957    vps->setDimensionId(i, 0, i);
958
959    if( m_apcLayerCfg[i]->m_layerId != i )
960    {
961      vps->setNuhLayerIdPresentFlag(true);
962    }
963  }
964
965  for(UInt layer=0; layer<m_numLayers; layer++)
966  {
967    //3
968#if LAYER_CTB
969    memcpy( g_auiZscanToRaster, g_auiLayerZscanToRaster[layer], sizeof( g_auiZscanToRaster ) );
970    memcpy( g_auiRasterToZscan, g_auiLayerRasterToZscan[layer], sizeof( g_auiRasterToZscan ) );
971    memcpy( g_auiRasterToPelX,  g_auiLayerRasterToPelX[layer],  sizeof( g_auiRasterToPelX ) );
972    memcpy( g_auiRasterToPelY,  g_auiLayerRasterToPelY[layer],  sizeof( g_auiRasterToPelY ) );
973#endif
974    m_apcTEncTop[layer]->init(isFieldCoding);
975  }
976
977  // Set max-layer ID
978  vps->setMaxLayerId( m_apcLayerCfg[m_numLayers - 1]->m_layerId );
979  vps->setVpsExtensionFlag( m_numLayers > 1 ? true : false );
980
981  if( m_numLayerSets > 1 )
982  {
983    vps->setNumLayerSets(m_numLayerSets);
984
985    for (Int setId = 1; setId < vps->getNumLayerSets(); setId++)
986    {
987      for (Int layerId = 0; layerId <= vps->getMaxLayerId(); layerId++)
988      {
989        vps->setLayerIdIncludedFlag(false, setId, layerId);
990      }
991    }
992    for (Int setId = 1; setId < vps->getNumLayerSets(); setId++)
993    {
994      for( i = 0; i < m_numLayerInIdList[setId]; i++ )
995      {
996        //4
997        vps->setLayerIdIncludedFlag(true, setId, m_layerSetLayerIdList[setId][i]);
998      }
999    }
1000  }
1001  else
1002  {
1003    // Default layer sets
1004    vps->setNumLayerSets(m_numLayers);
1005    for (Int setId = 1; setId < vps->getNumLayerSets(); setId++)
1006    {
1007      for (Int layerIdx = 0; layerIdx <= vps->getMaxLayers(); layerIdx++)
1008      {
1009        //4
1010        UInt layerId = vps->getLayerIdInNuh(layerIdx);
1011
1012        if (layerId <= setId)
1013        {
1014          vps->setLayerIdIncludedFlag(true, setId, layerId);
1015        }
1016        else
1017        {
1018          vps->setLayerIdIncludedFlag(false, setId, layerId);
1019        }
1020      }
1021    }
1022  }
1023
1024  vps->setVpsNumLayerSetsMinus1(vps->getNumLayerSets() - 1);
1025  vps->setNumAddLayerSets(m_numAddLayerSets);
1026  vps->setNumLayerSets(vps->getNumLayerSets() + vps->getNumAddLayerSets());
1027
1028  if( m_numAddLayerSets > 0 )
1029  {
1030    for (Int setId = 0; setId < m_numAddLayerSets; setId++)
1031    {
1032      for (Int j = 0; j < m_numHighestLayerIdx[setId]; j++)
1033      {
1034        vps->setHighestLayerIdxPlus1(setId, j + 1, m_highestLayerIdx[setId][j] + 1);
1035      }
1036    }
1037  }
1038
1039#if AVC_BASE
1040  vps->setNonHEVCBaseLayerFlag( m_nonHEVCBaseLayerFlag );
1041  if ( m_nonHEVCBaseLayerFlag )
1042  {
1043    vps->setBaseLayerInternalFlag (false);
1044  }
1045#else
1046  vps->setAvcBaseLayerFlag(false);
1047#endif
1048 
1049  for( Int idx = vps->getBaseLayerInternalFlag() ? 2 : 1; idx < vps->getNumProfileTierLevel(); idx++ )
1050  {
1051    vps->setProfilePresentFlag(idx, true);
1052  }
1053
1054  vps->setSplittingFlag(false);
1055
1056  for(i = 0; i < MAX_VPS_NUM_SCALABILITY_TYPES; i++)
1057  {
1058    vps->setScalabilityMask(i, false);
1059  }
1060  if(m_numLayers > 1)
1061  {
1062    Int scalabilityTypes = 0;
1063    for(i = 0; i < MAX_VPS_NUM_SCALABILITY_TYPES; i++)
1064    {
1065      vps->setScalabilityMask(i, m_scalabilityMask[i]);
1066      scalabilityTypes += m_scalabilityMask[i];
1067    }
1068#if AUXILIARY_PICTURES
1069    assert( scalabilityTypes <= 2 );
1070#else
1071    assert( scalabilityTypes == 1 );
1072#endif
1073    vps->setNumScalabilityTypes(scalabilityTypes);
1074  }
1075  else
1076  {
1077    vps->setNumScalabilityTypes(0);
1078  }
1079 
1080#if AUXILIARY_PICTURES
1081  if (m_scalabilityMask[AUX_ID])
1082  {
1083    UInt maxAuxId = 0;
1084    UInt auxDimIdLen = 1;
1085    Int  auxId = vps->getNumScalabilityTypes() - 1;
1086    for(i = 1; i < vps->getMaxLayers(); i++)
1087    {
1088      if (m_apcLayerCfg[i]->m_auxId > maxAuxId)
1089      {
1090        maxAuxId = m_apcLayerCfg[i]->m_auxId;
1091      }
1092    }
1093    while((1 << auxDimIdLen) < (maxAuxId + 1))
1094    {
1095      auxDimIdLen++;
1096    }
1097    vps->setDimensionIdLen(auxId, auxDimIdLen);
1098    for(i = 1; i < vps->getMaxLayers(); i++)
1099    {
1100      vps->setDimensionId(i, auxId, m_apcLayerCfg[i]->m_auxId);
1101    }
1102  }
1103#endif
1104
1105  vps->setMaxTSLayersPresentFlag(true);
1106
1107  for( i = 0; i < vps->getMaxLayers(); i++ )
1108  {
1109    vps->setMaxTSLayersMinus1(i, vps->getMaxTLayers()-1);
1110  }
1111
1112  vps->setMaxTidRefPresentFlag(m_maxTidRefPresentFlag);
1113  if (vps->getMaxTidRefPresentFlag())
1114  {
1115    for( i = 0; i < vps->getMaxLayers() - 1; i++ )
1116    {
1117      for( Int j = i+1; j < vps->getMaxLayers(); j++)
1118      {
1119        vps->setMaxTidIlRefPicsPlus1(i, j, m_apcTEncTop[i]->getMaxTidIlRefPicsPlus1());
1120      }
1121    }
1122  }
1123  else
1124  {
1125    for( i = 0; i < vps->getMaxLayers() - 1; i++ )
1126    {
1127      for( Int j = i+1; j < vps->getMaxLayers(); j++)
1128      {
1129        vps->setMaxTidIlRefPicsPlus1(i, j, 7);
1130      }
1131    }
1132  }
1133
1134  vps->setIlpSshSignalingEnabledFlag(false);
1135
1136  // Direct reference layers
1137  UInt maxDirectRefLayers = 0;
1138  Bool isDefaultDirectDependencyTypeSet = false;
1139  for (UInt layerCtr = 1; layerCtr < vps->getMaxLayers(); layerCtr++)
1140  {
1141    UInt layerId = vps->getLayerIdInNuh(layerCtr);
1142    Int numDirectRefLayers = 0;
1143
1144    vps->setNumDirectRefLayers(layerId, m_apcTEncTop[layerCtr]->getNumDirectRefLayers());
1145    maxDirectRefLayers = max<UInt>(maxDirectRefLayers, vps->getNumDirectRefLayers(layerId));
1146
1147    for (i = 0; i < vps->getNumDirectRefLayers(layerId); i++)
1148    {
1149      vps->setRefLayerId(layerId, i, m_apcTEncTop[layerCtr]->getRefLayerId(i));
1150    }
1151    // Set direct dependency flag
1152    // Initialize flag to 0
1153    for (Int refLayerCtr = 0; refLayerCtr < layerCtr; refLayerCtr++)
1154    {
1155      vps->setDirectDependencyFlag(layerCtr, refLayerCtr, false);
1156    }
1157    for (i = 0; i < vps->getNumDirectRefLayers(layerId); i++)
1158    {
1159      vps->setDirectDependencyFlag(layerCtr, vps->getLayerIdxInVps(m_apcTEncTop[layerCtr]->getRefLayerId(i)), true);
1160    }
1161    // prediction indications
1162    vps->setDirectDepTypeLen(2); // sample and motion types are encoded
1163    for (Int refLayerCtr = 0; refLayerCtr < layerCtr; refLayerCtr++)
1164    {
1165      if (vps->getDirectDependencyFlag(layerCtr, refLayerCtr))
1166      {
1167        assert(m_apcTEncTop[layerCtr]->getSamplePredEnabledFlag(numDirectRefLayers) || m_apcTEncTop[layerCtr]->getMotionPredEnabledFlag(numDirectRefLayers));
1168        vps->setDirectDependencyType(layerCtr, refLayerCtr, ((m_apcTEncTop[layerCtr]->getSamplePredEnabledFlag(numDirectRefLayers) ? 1 : 0) |
1169          (m_apcTEncTop[layerCtr]->getMotionPredEnabledFlag(numDirectRefLayers) ? 2 : 0)) - 1);
1170
1171        if (!isDefaultDirectDependencyTypeSet)
1172        {
1173          vps->setDefaultDirectDependecyTypeFlag(1);
1174          vps->setDefaultDirectDependecyType(vps->getDirectDependencyType(layerCtr, refLayerCtr));
1175          isDefaultDirectDependencyTypeSet = true;
1176        }
1177        else if (vps->getDirectDependencyType(layerCtr, refLayerCtr) != vps->getDefaultDirectDependencyType())
1178        {
1179          vps->setDefaultDirectDependecyTypeFlag(0);
1180        }
1181
1182        numDirectRefLayers ++;
1183      }
1184      else
1185      {
1186        vps->setDirectDependencyType(layerCtr, refLayerCtr, 0);
1187      }
1188    }
1189  }
1190
1191  // dependency constraint
1192  vps->setNumRefLayers();
1193
1194  if( vps->getMaxLayers() > MAX_REF_LAYERS )
1195  {
1196    for( UInt layerCtr = 1; layerCtr <= vps->getMaxLayers() - 1; layerCtr++ )
1197    {
1198      assert(vps->getNumRefLayers(vps->getLayerIdInNuh(layerCtr)) <= MAX_REF_LAYERS);
1199    }
1200  }
1201
1202  // The Layer ID List variables should be derived here.
1203  vps->deriveLayerIdListVariables();
1204  vps->setPredictedLayerIds();
1205  vps->setTreePartitionLayerIdList();
1206  vps->deriveLayerIdListVariablesForAddLayerSets();
1207
1208  vps->setDefaultTargetOutputLayerIdc( m_defaultTargetOutputLayerIdc ); // As per configuration file
1209
1210  if( m_numOutputLayerSets == -1 )  // # of output layer sets not specified in the configuration file
1211  {
1212    vps->setNumOutputLayerSets(vps->getNumLayerSets());
1213
1214    for(i = 1; i < vps->getNumLayerSets(); i++)
1215    {
1216        vps->setOutputLayerSetIdx(i, i);
1217    }
1218  }
1219  else
1220  {
1221    vps->setNumOutputLayerSets( m_numOutputLayerSets );
1222    for( Int olsCtr = 0; olsCtr < vps->getNumLayerSets(); olsCtr ++ ) // Default output layer sets
1223    {
1224      vps->setOutputLayerSetIdx(olsCtr, olsCtr);
1225    }
1226    for( Int olsCtr = vps->getNumLayerSets(); olsCtr < vps->getNumOutputLayerSets(); olsCtr ++ )  // Non-default output layer sets
1227    {
1228      vps->setOutputLayerSetIdx(olsCtr, m_outputLayerSetIdx[olsCtr - vps->getNumLayerSets()]);
1229    }
1230  }
1231
1232  // Target output layer
1233  vps->deriveNumberOfSubDpbs();
1234  vps->setOutputLayerFlag( 0, 0, 1 );
1235
1236  // derive OutputLayerFlag[i][j]
1237  // default_output_layer_idc equal to 1 specifies that only the layer with the highest value of nuh_layer_id such that nuh_layer_id equal to nuhLayerIdA and
1238  // AuxId[ nuhLayerIdA ] equal to 0 in each of the output layer sets with index in the range of 1 to vps_num_layer_sets_minus1, inclusive, is an output layer of its output layer set.
1239
1240  // Include the highest layer as output layer for each layer set
1241  for(Int lsIdx = 1; lsIdx <= vps->getVpsNumLayerSetsMinus1(); lsIdx++)
1242  {
1243    for( UInt layer = 0; layer < vps->getNumLayersInIdList(lsIdx); layer++ )
1244    {
1245      switch( vps->getDefaultTargetOutputLayerIdc() )
1246      {
1247      case 0: vps->setOutputLayerFlag( lsIdx, layer, 1 );
1248        break;
1249      case 1: vps->setOutputLayerFlag( lsIdx, layer, layer == vps->getNumLayersInIdList(lsIdx) - 1 );
1250        break;
1251      case 2:
1252      case 3: vps->setOutputLayerFlag( lsIdx, layer, (layer != vps->getNumLayersInIdList(lsIdx) - 1) ? std::find( m_listOfOutputLayers[lsIdx].begin(), m_listOfOutputLayers[lsIdx].end(), m_layerSetLayerIdList[lsIdx][layer]) != m_listOfOutputLayers[lsIdx].end() 
1253                : m_listOfOutputLayers[lsIdx][m_listOfOutputLayers[lsIdx].size()-1] == m_layerSetLayerIdList[lsIdx][layer] );
1254        break;
1255      }
1256    }
1257  }
1258
1259  for( Int olsIdx = vps->getVpsNumLayerSetsMinus1() + 1; olsIdx < vps->getNumOutputLayerSets(); olsIdx++ )
1260  {
1261    for( UInt layer = 0; layer < vps->getNumLayersInIdList(vps->getOutputLayerSetIdx(olsIdx)); layer++ )
1262    {
1263      vps->setOutputLayerFlag( olsIdx, layer, (layer != vps->getNumLayersInIdList(vps->getOutputLayerSetIdx(olsIdx)) - 1) ? std::find( m_listOfOutputLayers[olsIdx].begin(), m_listOfOutputLayers[olsIdx].end(), vps->getLayerSetLayerIdList(vps->getOutputLayerSetIdx(olsIdx), layer)) != m_listOfOutputLayers[olsIdx].end()
1264        : m_listOfOutputLayers[olsIdx][m_listOfOutputLayers[olsIdx].size()-1] == vps->getLayerSetLayerIdList(vps->getOutputLayerSetIdx(olsIdx), layer) );
1265    }
1266  }
1267
1268  vps->deriveNecessaryLayerFlag();
1269  vps->checkNecessaryLayerFlagCondition();
1270  vps->calculateMaxSLInLayerSets();
1271
1272  // Initialize dpb_size_table() for all ouput layer sets in the VPS extension
1273  for( i = 1; i < vps->getNumOutputLayerSets(); i++ )
1274  {
1275    Int layerSetIdxForOutputLayerSet = vps->getOutputLayerSetIdx( i );
1276    Int layerSetId = vps->getOutputLayerSetIdx(i);
1277
1278    for(Int j = 0; j < vps->getMaxTLayers(); j++)
1279    {
1280
1281      Int maxNumReorderPics = -1;
1282      for(Int k = 0; k < vps->getNumSubDpbs(layerSetIdxForOutputLayerSet); k++)
1283      {
1284        Int layerId = vps->getLayerSetLayerIdList(layerSetId, k); // k-th layer in the output layer set
1285        vps->setMaxVpsDecPicBufferingMinus1( i, k, j,  m_apcTEncTop[vps->getLayerIdxInVps(layerId)]->getMaxDecPicBuffering(j) - 1 );
1286        maxNumReorderPics       = std::max( maxNumReorderPics, m_apcTEncTop[vps->getLayerIdxInVps(layerId)]->getNumReorderPics(j));
1287      }
1288      vps->setMaxVpsNumReorderPics(i, j, maxNumReorderPics);
1289      vps->determineSubDpbInfoFlags();
1290    }
1291  }
1292
1293  vps->setMaxOneActiveRefLayerFlag(maxDirectRefLayers > 1 ? false : true);
1294
1295  // POC LSB not present flag
1296  for( i = 1; i< vps->getMaxLayers(); i++ )
1297  {
1298    if( vps->getNumDirectRefLayers( vps->getLayerIdInNuh(i) ) == 0  )
1299    {
1300      // make independedent layers base-layer compliant
1301      vps->setPocLsbNotPresentFlag(i, true); 
1302    }
1303  }
1304
1305  vps->setCrossLayerPictureTypeAlignFlag( m_crossLayerPictureTypeAlignFlag ); 
1306  vps->setCrossLayerAlignedIdrOnlyFlag( m_crossLayerAlignedIdrOnlyFlag );
1307  vps->setCrossLayerIrapAlignFlag( m_crossLayerIrapAlignFlag );
1308
1309  if( vps->getCrossLayerPictureTypeAlignFlag() )
1310  {
1311    // When not present, the value of cross_layer_irap_aligned_flag is inferred to be equal to vps_vui_present_flag,   
1312    assert( m_crossLayerIrapAlignFlag == true );
1313    vps->setCrossLayerIrapAlignFlag( true ); 
1314  }
1315
1316  for(UInt layerCtr = 1;layerCtr < vps->getMaxLayers(); layerCtr++)
1317  {
1318    for(Int refLayerCtr = 0; refLayerCtr < layerCtr; refLayerCtr++)
1319    {
1320      if (vps->getDirectDependencyFlag( layerCtr, refLayerCtr))
1321      {
1322        assert( layerCtr < MAX_LAYERS );
1323
1324        if(m_apcTEncTop[layerCtr]->getIntraPeriod() !=  m_apcTEncTop[refLayerCtr]->getIntraPeriod())
1325        {
1326          vps->setCrossLayerIrapAlignFlag(false);
1327          break;
1328        }
1329      }
1330    }
1331  }
1332  vps->setSingleLayerForNonIrapFlag(m_adaptiveResolutionChange > 0 ? true : false);
1333  vps->setHigherLayerIrapSkipFlag(m_skipPictureAtArcSwitch);
1334
1335  for( Int k = 0; k < MAX_VPS_LAYER_SETS_PLUS1; k++ )
1336  {
1337    vps->setAltOuputLayerFlag( k, m_altOutputLayerFlag );
1338  }
1339
1340  // VPS VUI BSP HRD parameters
1341  vps->setVpsVuiBspHrdPresentFlag(false);
1342  TEncTop *pcCfg = m_apcTEncTop[0];
1343  if( pcCfg->getBufferingPeriodSEIEnabled() )
1344  {
1345    Int j;
1346    vps->setVpsVuiBspHrdPresentFlag(true);
1347    vps->setVpsNumAddHrdParams( vps->getMaxLayers() );
1348    vps->createBspHrdParamBuffer(vps->getVpsNumAddHrdParams() + 1);
1349    for( i = vps->getNumHrdParameters(), j = 0; i < vps->getNumHrdParameters() + vps->getVpsNumAddHrdParams(); i++, j++ )
1350    {
1351      vps->setCprmsAddPresentFlag( j, true );
1352      vps->setNumSubLayerHrdMinus1( j, vps->getMaxTLayers() - 1 );
1353
1354      UInt layerIdx = j;
1355      TEncTop *pcCfgLayer = m_apcTEncTop[layerIdx];
1356
1357      Int iPicWidth         = pcCfgLayer->getSourceWidth();
1358      Int iPicHeight        = pcCfgLayer->getSourceHeight();
1359
1360      UInt uiWidthInCU      = ( iPicWidth  % m_apcLayerCfg[layerIdx]->m_uiMaxCUWidth  ) ? iPicWidth  / m_apcLayerCfg[layerIdx]->m_uiMaxCUWidth  + 1 : iPicWidth  / m_apcLayerCfg[layerIdx]->m_uiMaxCUWidth;
1361      UInt uiHeightInCU     = ( iPicHeight % m_apcLayerCfg[layerIdx]->m_uiMaxCUHeight ) ? iPicHeight / m_apcLayerCfg[layerIdx]->m_uiMaxCUHeight + 1 : iPicHeight / m_apcLayerCfg[layerIdx]->m_uiMaxCUHeight;
1362      UInt maxCU = pcCfgLayer->getSliceArgument() >> ( m_apcLayerCfg[layerIdx]->m_uiMaxCUDepth << 1);
1363
1364      UInt uiNumCUsInFrame   = uiWidthInCU * uiHeightInCU;
1365
1366      UInt numDU = ( pcCfgLayer->getSliceMode() == 1 ) ? ( uiNumCUsInFrame / maxCU ) : ( 0 );
1367      if( uiNumCUsInFrame % maxCU != 0 || numDU == 0 )
1368      {
1369        numDU ++;
1370      }
1371      //vps->getBspHrd(i)->setNumDU( numDU );
1372      vps->setBspHrdParameters( i, pcCfgLayer->getFrameRate(), numDU, pcCfgLayer->getTargetBitrate(), ( pcCfgLayer->getIntraPeriod() > 0 ) );
1373    }
1374
1375    // Signalling of additional partitioning schemes
1376    for( Int h = 1; h < vps->getNumOutputLayerSets(); h++ )
1377    {
1378      Int lsIdx = vps->getOutputLayerSetIdx( h );
1379      vps->setNumSignalledPartitioningSchemes(h, 1);  // Only the default per-layer partitioning scheme
1380      for( j = 1; j < vps->getNumSignalledPartitioningSchemes(h); j++ )
1381      {
1382        // ToDo: Add code for additional partitioning schemes here
1383        // ToDo: Initialize num_partitions_in_scheme_minus1 and layer_included_in_partition_flag
1384      }
1385
1386      for( i = 0; i < vps->getNumSignalledPartitioningSchemes(h); i++ )
1387      {
1388        if( i == 0 )
1389        {
1390          for(Int t = 0; t <= vps->getMaxSLayersInLayerSetMinus1( lsIdx ); t++)
1391          {
1392            vps->setNumBspSchedulesMinus1( h, i, t, 0 );
1393            for( j = 0; j <= vps->getNumBspSchedulesMinus1(h, i, t); j++ )
1394            {
1395              for( Int k = 0; k <= vps->getNumPartitionsInSchemeMinus1(h, i); k++ )
1396              {
1397                // Only for the default partition
1398                Int nuhlayerId = vps->getLayerSetLayerIdList( lsIdx, k);
1399                Int layerIdxInVps = vps->getLayerIdxInVps( nuhlayerId );
1400                vps->setBspHrdIdx(h, i, t, j, k, layerIdxInVps + vps->getNumHrdParameters());
1401
1402                vps->setBspSchedIdx(h, i, t, j, k, 0);
1403              }
1404            }
1405          }
1406        }
1407        else
1408        {
1409          assert(0);    // Need to add support for additional partitioning schemes.
1410        }
1411      }
1412    }
1413  }
1414#else //SVC_EXTENSION
1415  m_cTEncTop.init(isFieldCoding);
1416#endif //SVC_EXTENSION
1417}
1418
1419// ====================================================================================================================
1420// Public member functions
1421// ====================================================================================================================
1422
1423/**
1424 - create internal class
1425 - initialize internal variable
1426 - until the end of input YUV file, call encoding function in TEncTop class
1427 - delete allocated buffers
1428 - destroy internal class
1429 .
1430 */
1431#if SVC_EXTENSION
1432Void TAppEncTop::encode()
1433{
1434  fstream bitstreamFile(m_bitstreamFileName.c_str(), fstream::binary | fstream::out);
1435  if (!bitstreamFile)
1436  {
1437    fprintf(stderr, "\nfailed to open bitstream file `%s' for writing\n", m_bitstreamFileName.c_str());
1438    exit(EXIT_FAILURE);
1439  }
1440
1441  // allocated memory
1442  for( Int layer = 0; layer < m_numLayers; layer++ )
1443  {
1444    m_apcTVideoIOYuvInputFile[layer] = new TVideoIOYuv;   
1445    m_apcTVideoIOYuvReconFile[layer] = new TVideoIOYuv;
1446    m_apcTEncTop[layer] = new TEncTop;
1447  }
1448
1449  TComPicYuv*       pcPicYuvOrg [MAX_LAYERS];
1450  TComPicYuv*       pcPicYuvRec = NULL;
1451
1452  // initialize internal class & member variables
1453  xInitLibCfg();
1454  xCreateLib();
1455  xInitLib(m_isField);
1456
1457  // main encoder loop
1458  Int   iNumEncoded = 0, iTotalNumEncoded = 0;
1459  Bool  bEos = false;
1460
1461  const InputColourSpaceConversion ipCSC  =  m_inputColourSpaceConvert;
1462  const InputColourSpaceConversion snrCSC = (!m_snrInternalColourSpace) ? m_inputColourSpaceConvert : IPCOLOURSPACE_UNCHANGED;
1463
1464  list<AccessUnit> outputAccessUnits; ///< list of access units to write out.  is populated by the encoding process
1465
1466  TComPicYuv acPicYuvTrueOrg[MAX_LAYERS];
1467
1468  for(UInt layer=0; layer<m_numLayers; layer++)
1469  {
1470    //5
1471    // allocate original YUV buffer
1472    pcPicYuvOrg[layer] = new TComPicYuv;
1473    if( m_isField )
1474    {
1475      pcPicYuvOrg[layer]->create( m_apcLayerCfg[layer]->m_iSourceWidth, m_apcLayerCfg[layer]->m_iSourceHeightOrg, m_apcLayerCfg[layer]->m_chromaFormatIDC, m_apcLayerCfg[layer]->m_uiMaxCUWidth, m_apcLayerCfg[layer]->m_uiMaxCUHeight, m_apcLayerCfg[layer]->m_uiMaxTotalCUDepth, true, NULL );
1476      acPicYuvTrueOrg[layer].create( m_apcLayerCfg[layer]->m_iSourceWidth, m_apcLayerCfg[layer]->m_iSourceHeightOrg, m_apcLayerCfg[layer]->m_chromaFormatIDC, m_apcLayerCfg[layer]->m_uiMaxCUWidth, m_apcLayerCfg[layer]->m_uiMaxCUHeight, m_apcLayerCfg[layer]->m_uiMaxTotalCUDepth, true, NULL );
1477    }
1478    else
1479    {
1480      pcPicYuvOrg[layer]->create( m_apcLayerCfg[layer]->m_iSourceWidth, m_apcLayerCfg[layer]->m_iSourceHeight, m_apcLayerCfg[layer]->m_chromaFormatIDC, m_apcLayerCfg[layer]->m_uiMaxCUWidth, m_apcLayerCfg[layer]->m_uiMaxCUHeight, m_apcLayerCfg[layer]->m_uiMaxTotalCUDepth, true, NULL );
1481      acPicYuvTrueOrg[layer].create( m_apcLayerCfg[layer]->m_iSourceWidth, m_apcLayerCfg[layer]->m_iSourceHeight, m_apcLayerCfg[layer]->m_chromaFormatIDC, m_apcLayerCfg[layer]->m_uiMaxCUWidth, m_apcLayerCfg[layer]->m_uiMaxCUHeight, m_apcLayerCfg[layer]->m_uiMaxTotalCUDepth, true, NULL );
1482    }
1483  }
1484
1485  Bool bFirstFrame = true;
1486  while ( !bEos )
1487  {
1488    // Read enough frames
1489    Bool bFramesReadyToCode = false;
1490    while(!bFramesReadyToCode)
1491    {
1492      for(UInt layer=0; layer<m_numLayers; layer++)
1493      {
1494        //6
1495        // get buffers
1496        xGetBuffer(pcPicYuvRec, layer);
1497
1498        // read input YUV file
1499        m_apcTVideoIOYuvInputFile[layer]->read( pcPicYuvOrg[layer], &acPicYuvTrueOrg[layer], ipCSC, m_apcLayerCfg[layer]->m_aiPad, m_apcLayerCfg[layer]->m_InputChromaFormatIDC, m_bClipInputVideoToRec709Range );
1500
1501#if AUXILIARY_PICTURES
1502        if( m_apcLayerCfg[layer]->m_chromaFormatIDC == CHROMA_400 || (m_apcTEncTop[0]->getVPS()->getScalabilityMask(AUX_ID) && (m_apcLayerCfg[layer]->m_auxId == AUX_ALPHA || m_apcLayerCfg[layer]->m_auxId == AUX_DEPTH)) )
1503        {
1504          pcPicYuvOrg[layer]->convertToMonochrome(m_apcLayerCfg[layer]->m_internalBitDepth[CHANNEL_TYPE_CHROMA]);
1505        }
1506#endif
1507
1508        if(layer == m_numLayers-1)
1509        {
1510          // increase number of received frames
1511          m_iFrameRcvd++;
1512          // check end of file
1513          bEos = (m_isField && (m_iFrameRcvd == (m_framesToBeEncoded >> 1) )) || ( !m_isField && (m_iFrameRcvd == m_framesToBeEncoded) );
1514        }
1515
1516        if ( m_isField )
1517        {
1518          m_apcTEncTop[layer]->encodePrep( pcPicYuvOrg[layer], &acPicYuvTrueOrg[layer], m_isTopFieldFirst );
1519        }
1520        else
1521        {
1522          m_apcTEncTop[layer]->encodePrep( pcPicYuvOrg[layer], &acPicYuvTrueOrg[layer] );
1523        }
1524      }
1525
1526      bFramesReadyToCode = !(!bFirstFrame && ( m_apcTEncTop[m_numLayers-1]->getNumPicRcvd() != m_iGOPSize && m_iGOPSize ) && !bEos );
1527    }
1528    Bool flush = 0;
1529    // if end of file (which is only detected on a read failure) flush the encoder of any queued pictures
1530    if (m_apcTVideoIOYuvInputFile[m_numLayers-1]->isEof())
1531    {
1532      flush = true;
1533      bEos = true;
1534      m_iFrameRcvd--;
1535      m_apcTEncTop[m_numLayers-1]->setFramesToBeEncoded(m_iFrameRcvd);
1536    }
1537
1538#if RC_SHVC_HARMONIZATION
1539    for( UInt layer=0; layer<m_numLayers; layer++ )
1540    {
1541      if( m_apcTEncTop[layer]->getUseRateCtrl() )
1542      {
1543        m_apcTEncTop[layer]->getRateCtrl()->initRCGOP(m_apcTEncTop[layer]->getNumPicRcvd());
1544      }
1545    }
1546#endif
1547
1548    if( m_adaptiveResolutionChange )
1549    {
1550      for(UInt layer = 0; layer < m_numLayers; layer++)
1551      {
1552        TComList<TComPicYuv*>::iterator iterPicYuvRec;
1553        for (iterPicYuvRec = m_acListPicYuvRec[layer].begin(); iterPicYuvRec != m_acListPicYuvRec[layer].end(); iterPicYuvRec++)
1554        {
1555          TComPicYuv* recPic = *(iterPicYuvRec);
1556          recPic->setReconstructed(false);
1557        }
1558      }
1559    }
1560
1561    // loop through frames in one GOP
1562    for( UInt iPicIdInGOP=0; iPicIdInGOP < (bFirstFrame? 1:m_iGOPSize); iPicIdInGOP++ )
1563    {
1564      // layer by layer for each frame
1565      for( UInt layer=0; layer<m_numLayers; layer++ )
1566      {
1567        //7
1568#if LAYER_CTB
1569        memcpy( g_auiZscanToRaster, g_auiLayerZscanToRaster[layer], sizeof( g_auiZscanToRaster ) );
1570        memcpy( g_auiRasterToZscan, g_auiLayerRasterToZscan[layer], sizeof( g_auiRasterToZscan ) );
1571        memcpy( g_auiRasterToPelX,  g_auiLayerRasterToPelX[layer],  sizeof( g_auiRasterToPelX ) );
1572        memcpy( g_auiRasterToPelY,  g_auiLayerRasterToPelY[layer],  sizeof( g_auiRasterToPelY ) );
1573#endif
1574        // call encoding function for one frame
1575        if ( m_isField )
1576        {
1577          m_apcTEncTop[layer]->encode( flush ? 0 : pcPicYuvOrg[layer], snrCSC, m_acListPicYuvRec[layer], outputAccessUnits, iPicIdInGOP, m_isTopFieldFirst );
1578        }
1579        else
1580        {
1581          m_apcTEncTop[layer]->encode( flush ? 0 : pcPicYuvOrg[layer], snrCSC, m_acListPicYuvRec[layer], outputAccessUnits, iPicIdInGOP );
1582        }
1583      }
1584    }
1585#if R0247_SEI_ACTIVE
1586    if(bFirstFrame)
1587    {
1588      list<AccessUnit>::iterator first_au = outputAccessUnits.begin();
1589      if( m_nonHEVCBaseLayerFlag )
1590      {
1591        first_au++;
1592      }
1593      AccessUnit::iterator it_sps;
1594      for (it_sps = first_au->begin(); it_sps != first_au->end(); it_sps++)
1595      {
1596        if( (*it_sps)->m_nalUnitType == NAL_UNIT_SPS )
1597        {
1598          break;
1599        }
1600      }
1601
1602      for (list<AccessUnit>::iterator it_au = ++outputAccessUnits.begin(); it_au != outputAccessUnits.end(); it_au++)
1603      {
1604        for (AccessUnit::iterator it_nalu = it_au->begin(); it_nalu != it_au->end(); it_nalu++)
1605        {
1606          if( (*it_nalu)->m_nalUnitType == NAL_UNIT_SPS )
1607          {
1608            it_sps = first_au->insert(++it_sps, *it_nalu);
1609            it_nalu = it_au->erase(it_nalu);
1610          }
1611        }
1612      }
1613    }
1614#endif
1615
1616#if RC_SHVC_HARMONIZATION
1617    for( UInt layer = 0; layer < m_numLayers; layer++ )
1618    {
1619      if( m_apcTEncTop[layer]->getUseRateCtrl() )
1620      {
1621        m_apcTEncTop[layer]->getRateCtrl()->destroyRCGOP();
1622      }
1623    }
1624#endif
1625
1626    iTotalNumEncoded = 0;
1627    for( UInt layer=0; layer<m_numLayers; layer++ )
1628    {
1629      //8
1630      // write bistream to file if necessary
1631      iNumEncoded = m_apcTEncTop[layer]->getNumPicRcvd();
1632      if ( iNumEncoded > 0 )
1633      {
1634        xWriteRecon(layer, iNumEncoded);
1635        iTotalNumEncoded += iNumEncoded;
1636      }
1637      m_apcTEncTop[layer]->setNumPicRcvd( 0 );
1638    }
1639
1640    // write bitstream out
1641    if( iTotalNumEncoded )
1642    {
1643      if( bEos )
1644      {
1645        OutputNALUnit nalu(NAL_UNIT_EOB);
1646        nalu.m_nuhLayerId = 0;
1647
1648        AccessUnit& accessUnit = outputAccessUnits.back();
1649        nalu.m_temporalId = 0;
1650        accessUnit.push_back(new NALUnitEBSP(nalu));
1651      }
1652
1653      xWriteStream(bitstreamFile, iTotalNumEncoded, outputAccessUnits);
1654      outputAccessUnits.clear();
1655    }
1656
1657    // print out summary
1658    if (bEos)
1659    {
1660      printOutSummary(m_isTopFieldFirst, m_printMSEBasedSequencePSNR, m_printSequenceMSE);
1661    }
1662
1663    bFirstFrame = false;
1664  }
1665  // delete original YUV buffer
1666  for(UInt layer=0; layer<m_numLayers; layer++)
1667  {
1668    pcPicYuvOrg[layer]->destroy();
1669    delete pcPicYuvOrg[layer];
1670    pcPicYuvOrg[layer] = NULL;
1671
1672    // delete used buffers in encoder class
1673    m_apcTEncTop[layer]->deletePicBuffer();
1674    acPicYuvTrueOrg[layer].destroy();
1675  }
1676
1677  // delete buffers & classes
1678  xDeleteBuffer();
1679  xDestroyLib();
1680
1681  printRateSummary();
1682
1683  return;
1684}
1685
1686Void TAppEncTop::printOutSummary(Bool isField, const Bool printMSEBasedSNR, const Bool printSequenceMSE)
1687{
1688  UInt layer;
1689  const Int rateMultiplier = isField ? 2 : 1;
1690
1691  // set frame rate
1692  for(layer = 0; layer < m_numLayers; layer++)
1693  {
1694    m_apcTEncTop[layer]->getAnalyzeAll()->setFrmRate( m_apcLayerCfg[layer]->m_iFrameRate * rateMultiplier );
1695    m_apcTEncTop[layer]->getAnalyzeI()->setFrmRate( m_apcLayerCfg[layer]->m_iFrameRate * rateMultiplier );
1696    m_apcTEncTop[layer]->getAnalyzeP()->setFrmRate( m_apcLayerCfg[layer]->m_iFrameRate * rateMultiplier );
1697    m_apcTEncTop[layer]->getAnalyzeB()->setFrmRate( m_apcLayerCfg[layer]->m_iFrameRate * rateMultiplier );
1698  }
1699
1700  //-- all
1701  printf( "\n\nSUMMARY --------------------------------------------------------\n" );
1702  for(layer = 0; layer < m_numLayers; layer++)
1703  {
1704    const UInt layerId = m_apcTEncTop[layer]->getVPS()->getLayerIdInNuh(layer);
1705    const BitDepths bitDepths(m_apcLayerCfg[layer]->m_internalBitDepth[CHANNEL_TYPE_LUMA], m_apcLayerCfg[layer]->m_internalBitDepth[CHANNEL_TYPE_CHROMA]);   
1706    m_apcTEncTop[layer]->getAnalyzeAll()->printOut('a', m_apcLayerCfg[layer]->m_chromaFormatIDC, printMSEBasedSNR, printSequenceMSE, bitDepths, layerId);
1707  }
1708
1709  printf( "\n\nI Slices--------------------------------------------------------\n" );
1710  for(layer = 0; layer < m_numLayers; layer++)
1711  {
1712    const UInt layerId = m_apcTEncTop[layer]->getVPS()->getLayerIdInNuh(layer);
1713    const BitDepths bitDepths(m_apcLayerCfg[layer]->m_internalBitDepth[CHANNEL_TYPE_LUMA], m_apcLayerCfg[layer]->m_internalBitDepth[CHANNEL_TYPE_CHROMA]);
1714    m_apcTEncTop[layer]->getAnalyzeI()->printOut('i', m_apcLayerCfg[layer]->m_chromaFormatIDC, printMSEBasedSNR, printSequenceMSE, bitDepths, layerId);
1715  }
1716
1717  printf( "\n\nP Slices--------------------------------------------------------\n" );
1718  for(layer = 0; layer < m_numLayers; layer++)
1719  {
1720    const UInt layerId = m_apcTEncTop[layer]->getVPS()->getLayerIdInNuh(layer);
1721    const BitDepths bitDepths(m_apcLayerCfg[layer]->m_internalBitDepth[CHANNEL_TYPE_LUMA], m_apcLayerCfg[layer]->m_internalBitDepth[CHANNEL_TYPE_CHROMA]);
1722    m_apcTEncTop[layer]->getAnalyzeP()->printOut('p', m_apcLayerCfg[layer]->m_chromaFormatIDC, printMSEBasedSNR, printSequenceMSE, bitDepths, layerId);
1723  }
1724
1725  printf( "\n\nB Slices--------------------------------------------------------\n" );
1726  for(layer = 0; layer < m_numLayers; layer++)
1727  {
1728    const UInt layerId = m_apcTEncTop[layer]->getVPS()->getLayerIdInNuh(layer);
1729    const BitDepths bitDepths(m_apcLayerCfg[layer]->m_internalBitDepth[CHANNEL_TYPE_LUMA], m_apcLayerCfg[layer]->m_internalBitDepth[CHANNEL_TYPE_CHROMA]);
1730    m_apcTEncTop[layer]->getAnalyzeB()->printOut('b', m_apcLayerCfg[layer]->m_chromaFormatIDC, printMSEBasedSNR, printSequenceMSE, bitDepths, layerId);
1731  }
1732
1733  for( layer = 0; layer < m_numLayers; layer++ )
1734  {
1735    if (!m_apcTEncTop[layer]->getSummaryOutFilename().empty())
1736    {
1737      const BitDepths bitDepths(m_apcLayerCfg[layer]->m_internalBitDepth[CHANNEL_TYPE_LUMA], m_apcLayerCfg[layer]->m_internalBitDepth[CHANNEL_TYPE_CHROMA]);
1738
1739      m_apcTEncTop[layer]->getAnalyzeAll()->printSummary(m_apcLayerCfg[layer]->m_chromaFormatIDC, printSequenceMSE, bitDepths, m_apcTEncTop[layer]->getSummaryOutFilename());
1740    }
1741  }
1742
1743  for( layer = 0; layer < m_numLayers; layer++ )
1744  {
1745    if (!m_apcTEncTop[layer]->getSummaryPicFilenameBase().empty())
1746    {
1747      const BitDepths bitDepths(m_apcLayerCfg[layer]->m_internalBitDepth[CHANNEL_TYPE_LUMA], m_apcLayerCfg[layer]->m_internalBitDepth[CHANNEL_TYPE_CHROMA]);
1748
1749      m_apcTEncTop[layer]->getAnalyzeI()->printSummary(m_apcLayerCfg[layer]->m_chromaFormatIDC, printSequenceMSE, bitDepths, m_apcTEncTop[layer]->getSummaryPicFilenameBase()+"I.txt");
1750      m_apcTEncTop[layer]->getAnalyzeP()->printSummary(m_apcLayerCfg[layer]->m_chromaFormatIDC, printSequenceMSE, bitDepths, m_apcTEncTop[layer]->getSummaryPicFilenameBase()+"P.txt");
1751      m_apcTEncTop[layer]->getAnalyzeB()->printSummary(m_apcLayerCfg[layer]->m_chromaFormatIDC, printSequenceMSE, bitDepths, m_apcTEncTop[layer]->getSummaryPicFilenameBase()+"B.txt");
1752    }
1753  }
1754
1755  if(isField)
1756  {
1757    for(layer = 0; layer < m_numLayers; layer++)
1758    {
1759      const UInt layerId = m_apcTEncTop[layer]->getVPS()->getLayerIdInNuh(layer);
1760      const BitDepths bitDepths(m_apcLayerCfg[layer]->m_internalBitDepth[CHANNEL_TYPE_LUMA], m_apcLayerCfg[layer]->m_internalBitDepth[CHANNEL_TYPE_CHROMA]);
1761      TEncAnalyze *analyze = m_apcTEncTop[layer]->getAnalyzeAllin();
1762
1763      //-- interlaced summary
1764      analyze->setFrmRate( m_apcLayerCfg[layer]->m_iFrameRate);
1765      analyze->setBits(m_apcTEncTop[layer]->getAnalyzeB()->getBits());
1766      // prior to the above statement, the interlace analyser does not contain the correct total number of bits.
1767
1768      printf( "\n\nSUMMARY INTERLACED ---------------------------------------------\n" );
1769      analyze->printOut('a', m_apcLayerCfg[layer]->m_chromaFormatIDC, printMSEBasedSNR, printSequenceMSE, bitDepths, layerId);
1770
1771      if (!m_apcTEncTop[layer]->getSummaryOutFilename().empty())
1772      {
1773        analyze->printSummary(m_apcLayerCfg[layer]->m_chromaFormatIDC, printSequenceMSE, bitDepths, m_apcTEncTop[layer]->getSummaryOutFilename());
1774      }
1775    }
1776  }   
1777
1778  printf("\n");
1779  for( layer = 0; layer < m_numLayers; layer++ )
1780  {
1781    const UInt layerId = m_apcTEncTop[layer]->getVPS()->getLayerIdInNuh(layer);
1782    printf("RVM[L%d]: %.3lf\n", layerId, m_apcTEncTop[layer]->calculateRVM());
1783  }
1784  printf("\n");
1785}
1786#else
1787// ====================================================================================================================
1788// Public member functions
1789// ====================================================================================================================
1790
1791/**
1792 - create internal class
1793 - initialize internal variable
1794 - until the end of input YUV file, call encoding function in TEncTop class
1795 - delete allocated buffers
1796 - destroy internal class
1797 .
1798 */
1799Void TAppEncTop::encode()
1800{
1801  fstream bitstreamFile(m_bitstreamFileName.c_str(), fstream::binary | fstream::out);
1802  if (!bitstreamFile)
1803  {
1804    fprintf(stderr, "\nfailed to open bitstream file `%s' for writing\n", m_bitstreamFileName.c_str());
1805    exit(EXIT_FAILURE);
1806  }
1807
1808  TComPicYuv*       pcPicYuvOrg = new TComPicYuv;
1809  TComPicYuv*       pcPicYuvRec = NULL;
1810
1811  // initialize internal class & member variables
1812  xInitLibCfg();
1813  xCreateLib();
1814  xInitLib(m_isField);
1815
1816  printChromaFormat();
1817
1818  // main encoder loop
1819  Int   iNumEncoded = 0;
1820  Bool  bEos = false;
1821
1822  const InputColourSpaceConversion ipCSC  =  m_inputColourSpaceConvert;
1823  const InputColourSpaceConversion snrCSC = (!m_snrInternalColourSpace) ? m_inputColourSpaceConvert : IPCOLOURSPACE_UNCHANGED;
1824
1825  list<AccessUnit> outputAccessUnits; ///< list of access units to write out.  is populated by the encoding process
1826
1827  TComPicYuv cPicYuvTrueOrg;
1828
1829  // allocate original YUV buffer
1830  if( m_isField )
1831  {
1832    pcPicYuvOrg->create  ( m_iSourceWidth, m_iSourceHeightOrg, m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
1833    cPicYuvTrueOrg.create(m_iSourceWidth, m_iSourceHeightOrg, m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true);
1834  }
1835  else
1836  {
1837    pcPicYuvOrg->create  ( m_iSourceWidth, m_iSourceHeight, m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
1838    cPicYuvTrueOrg.create(m_iSourceWidth, m_iSourceHeight, m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
1839  }
1840
1841  while ( !bEos )
1842  {
1843    // get buffers
1844    xGetBuffer(pcPicYuvRec);
1845
1846    // read input YUV file
1847    m_cTVideoIOYuvInputFile.read( pcPicYuvOrg, &cPicYuvTrueOrg, ipCSC, m_aiPad, m_InputChromaFormatIDC, m_bClipInputVideoToRec709Range );
1848
1849    // increase number of received frames
1850    m_iFrameRcvd++;
1851
1852    bEos = (m_isField && (m_iFrameRcvd == (m_framesToBeEncoded >> 1) )) || ( !m_isField && (m_iFrameRcvd == m_framesToBeEncoded) );
1853
1854    Bool flush = 0;
1855    // if end of file (which is only detected on a read failure) flush the encoder of any queued pictures
1856    if (m_cTVideoIOYuvInputFile.isEof())
1857    {
1858      flush = true;
1859      bEos = true;
1860      m_iFrameRcvd--;
1861      m_cTEncTop.setFramesToBeEncoded(m_iFrameRcvd);
1862    }
1863
1864    // call encoding function for one frame
1865    if ( m_isField )
1866    {
1867      m_cTEncTop.encode( bEos, flush ? 0 : pcPicYuvOrg, flush ? 0 : &cPicYuvTrueOrg, snrCSC, m_cListPicYuvRec, outputAccessUnits, iNumEncoded, m_isTopFieldFirst );
1868    }
1869    else
1870    {
1871      m_cTEncTop.encode( bEos, flush ? 0 : pcPicYuvOrg, flush ? 0 : &cPicYuvTrueOrg, snrCSC, m_cListPicYuvRec, outputAccessUnits, iNumEncoded );
1872    }
1873
1874    // write bistream to file if necessary
1875    if ( iNumEncoded > 0 )
1876    {
1877      xWriteOutput(bitstreamFile, iNumEncoded, outputAccessUnits);
1878      outputAccessUnits.clear();
1879    }
1880  }
1881
1882  m_cTEncTop.printSummary(m_isField);
1883
1884  // delete original YUV buffer
1885  pcPicYuvOrg->destroy();
1886  delete pcPicYuvOrg;
1887  pcPicYuvOrg = NULL;
1888
1889  // delete used buffers in encoder class
1890  m_cTEncTop.deletePicBuffer();
1891  cPicYuvTrueOrg.destroy();
1892
1893  // delete buffers & classes
1894  xDeleteBuffer();
1895  xDestroyLib();
1896
1897  printRateSummary();
1898
1899  return;
1900}
1901#endif //SVC_EXTENSION
1902
1903// ====================================================================================================================
1904// Protected member functions
1905// ====================================================================================================================
1906
1907/**
1908 - application has picture buffer list with size of GOP
1909 - picture buffer list acts as ring buffer
1910 - end of the list has the latest picture
1911 .
1912 */
1913#if SVC_EXTENSION
1914Void TAppEncTop::xGetBuffer( TComPicYuv*& rpcPicYuvRec, UInt layer)
1915{
1916  assert( m_iGOPSize > 0 );
1917
1918  // org. buffer
1919  if ( m_acListPicYuvRec[layer].size() >= (UInt)m_iGOPSize ) // buffer will be 1 element longer when using field coding, to maintain first field whilst processing second.
1920  {
1921    rpcPicYuvRec = m_acListPicYuvRec[layer].popFront();
1922  }
1923  else
1924  {
1925    rpcPicYuvRec = new TComPicYuv;
1926
1927    rpcPicYuvRec->create( m_apcLayerCfg[layer]->m_iSourceWidth, m_apcLayerCfg[layer]->m_iSourceHeight, m_apcLayerCfg[layer]->m_chromaFormatIDC, m_apcLayerCfg[layer]->m_uiMaxCUWidth, m_apcLayerCfg[layer]->m_uiMaxCUHeight, m_apcLayerCfg[layer]->m_uiMaxTotalCUDepth, true, NULL );
1928  }
1929  m_acListPicYuvRec[layer].pushBack( rpcPicYuvRec );
1930}
1931
1932Void TAppEncTop::xDeleteBuffer( )
1933{
1934  for(UInt layer=0; layer<m_numLayers; layer++)
1935  {
1936    TComList<TComPicYuv*>::iterator iterPicYuvRec  = m_acListPicYuvRec[layer].begin();
1937
1938    Int iSize = Int( m_acListPicYuvRec[layer].size() );
1939
1940    for ( Int i = 0; i < iSize; i++ )
1941    {
1942      TComPicYuv*  pcPicYuvRec  = *(iterPicYuvRec++);
1943      pcPicYuvRec->destroy();
1944      delete pcPicYuvRec; pcPicYuvRec = NULL;
1945    }
1946  }
1947}
1948
1949Void TAppEncTop::xWriteRecon(UInt layer, Int iNumEncoded)
1950{
1951  ChromaFormat& chromaFormatIdc = m_apcLayerCfg[layer]->m_chromaFormatIDC;
1952  Int xScal = TComSPS::getWinUnitX( chromaFormatIdc );
1953  Int yScal = TComSPS::getWinUnitY( chromaFormatIdc );
1954
1955  const InputColourSpaceConversion ipCSC = (!m_outputInternalColourSpace) ? m_inputColourSpaceConvert : IPCOLOURSPACE_UNCHANGED;
1956
1957  if (m_isField)
1958  {
1959    //Reinterlace fields
1960    Int i;
1961    TComList<TComPicYuv*>::iterator iterPicYuvRec = m_acListPicYuvRec[layer].end();
1962
1963    for ( i = 0; i < iNumEncoded; i++ )
1964    {
1965      --iterPicYuvRec;
1966    }
1967
1968    for ( i = 0; i < iNumEncoded/2; i++ )
1969    {
1970      TComPicYuv*  pcPicYuvRecTop  = *(iterPicYuvRec++);
1971      TComPicYuv*  pcPicYuvRecBottom  = *(iterPicYuvRec++);
1972
1973      if( !m_apcLayerCfg[layer]->getReconFileName().empty() && pcPicYuvRecTop->isReconstructed() && pcPicYuvRecBottom->isReconstructed() )
1974      {
1975        m_apcTVideoIOYuvReconFile[layer]->write( pcPicYuvRecTop, pcPicYuvRecBottom, ipCSC, m_apcLayerCfg[layer]->getConfWinLeft() * xScal, m_apcLayerCfg[layer]->getConfWinRight() * xScal, 
1976        m_apcLayerCfg[layer]->getConfWinTop() * yScal, m_apcLayerCfg[layer]->getConfWinBottom() * yScal, NUM_CHROMA_FORMAT, m_isTopFieldFirst );
1977      }
1978    }
1979  }
1980  else
1981  {
1982    Int i;
1983
1984    TComList<TComPicYuv*>::iterator iterPicYuvRec = m_acListPicYuvRec[layer].end();
1985
1986    for ( i = 0; i < iNumEncoded; i++ )
1987    {
1988      --iterPicYuvRec;
1989    }
1990
1991    for ( i = 0; i < iNumEncoded; i++ )
1992    {
1993      TComPicYuv*  pcPicYuvRec  = *(iterPicYuvRec++);
1994      if( !m_apcLayerCfg[layer]->getReconFileName().empty() && pcPicYuvRec->isReconstructed() )
1995      {
1996        m_apcTVideoIOYuvReconFile[layer]->write( pcPicYuvRec, ipCSC, m_apcLayerCfg[layer]->getConfWinLeft() * xScal, m_apcLayerCfg[layer]->getConfWinRight() * xScal,
1997          m_apcLayerCfg[layer]->getConfWinTop() * yScal, m_apcLayerCfg[layer]->getConfWinBottom() * yScal,
1998          NUM_CHROMA_FORMAT, m_bClipOutputVideoToRec709Range  );
1999      }
2000    }
2001  }
2002}
2003
2004Void TAppEncTop::xWriteStream(std::ostream& bitstreamFile, Int iNumEncoded, const std::list<AccessUnit>& accessUnits)
2005{
2006  if (m_isField)
2007  {
2008    //Reinterlace fields
2009    Int i;
2010    list<AccessUnit>::const_iterator iterBitstream = accessUnits.begin();
2011
2012    for( i = 0; i < iNumEncoded/2 && iterBitstream != accessUnits.end(); i++ )
2013    {
2014      const AccessUnit& auTop = *(iterBitstream++);
2015      const vector<UInt>& statsTop = writeAnnexB(bitstreamFile, auTop);
2016      rateStatsAccum(auTop, statsTop);
2017
2018      const AccessUnit& auBottom = *(iterBitstream++);
2019      const vector<UInt>& statsBottom = writeAnnexB(bitstreamFile, auBottom);
2020      rateStatsAccum(auBottom, statsBottom);
2021    }
2022  }
2023  else
2024  {
2025    Int i;
2026
2027    list<AccessUnit>::const_iterator iterBitstream = accessUnits.begin();
2028
2029    for( i = 0; i < iNumEncoded && iterBitstream != accessUnits.end(); i++ )
2030    {
2031      const AccessUnit& au = *(iterBitstream++);
2032      const vector<UInt>& stats = writeAnnexB(bitstreamFile, au);
2033      rateStatsAccum(au, stats);
2034    }
2035  }
2036}
2037
2038#else // SVC_EXTENSION
2039Void TAppEncTop::xGetBuffer( TComPicYuv*& rpcPicYuvRec)
2040{
2041  assert( m_iGOPSize > 0 );
2042
2043  // org. buffer
2044  if ( m_cListPicYuvRec.size() >= (UInt)m_iGOPSize ) // buffer will be 1 element longer when using field coding, to maintain first field whilst processing second.
2045  {
2046    rpcPicYuvRec = m_cListPicYuvRec.popFront();
2047
2048  }
2049  else
2050  {
2051    rpcPicYuvRec = new TComPicYuv;
2052
2053    rpcPicYuvRec->create( m_iSourceWidth, m_iSourceHeight, m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
2054
2055  }
2056  m_cListPicYuvRec.pushBack( rpcPicYuvRec );
2057}
2058
2059Void TAppEncTop::xDeleteBuffer( )
2060{
2061  TComList<TComPicYuv*>::iterator iterPicYuvRec  = m_cListPicYuvRec.begin();
2062
2063  Int iSize = Int( m_cListPicYuvRec.size() );
2064
2065  for ( Int i = 0; i < iSize; i++ )
2066  {
2067    TComPicYuv*  pcPicYuvRec  = *(iterPicYuvRec++);
2068    pcPicYuvRec->destroy();
2069    delete pcPicYuvRec; pcPicYuvRec = NULL;
2070  }
2071
2072}
2073
2074/**
2075  Write access units to output file.
2076  \param bitstreamFile  target bitstream file
2077  \param iNumEncoded    number of encoded frames
2078  \param accessUnits    list of access units to be written
2079 */
2080Void TAppEncTop::xWriteOutput(std::ostream& bitstreamFile, Int iNumEncoded, const std::list<AccessUnit>& accessUnits)
2081{
2082  const InputColourSpaceConversion ipCSC = (!m_outputInternalColourSpace) ? m_inputColourSpaceConvert : IPCOLOURSPACE_UNCHANGED;
2083
2084  if (m_isField)
2085  {
2086    //Reinterlace fields
2087    Int i;
2088    TComList<TComPicYuv*>::iterator iterPicYuvRec = m_cListPicYuvRec.end();
2089    list<AccessUnit>::const_iterator iterBitstream = accessUnits.begin();
2090
2091    for ( i = 0; i < iNumEncoded; i++ )
2092    {
2093      --iterPicYuvRec;
2094    }
2095
2096    for ( i = 0; i < iNumEncoded/2; i++ )
2097    {
2098      TComPicYuv*  pcPicYuvRecTop  = *(iterPicYuvRec++);
2099      TComPicYuv*  pcPicYuvRecBottom  = *(iterPicYuvRec++);
2100
2101      if (!m_reconFileName.empty())
2102      {
2103        m_cTVideoIOYuvReconFile.write( pcPicYuvRecTop, pcPicYuvRecBottom, ipCSC, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom, NUM_CHROMA_FORMAT, m_isTopFieldFirst );
2104      }
2105
2106      const AccessUnit& auTop = *(iterBitstream++);
2107      const vector<UInt>& statsTop = writeAnnexB(bitstreamFile, auTop);
2108      rateStatsAccum(auTop, statsTop);
2109
2110      const AccessUnit& auBottom = *(iterBitstream++);
2111      const vector<UInt>& statsBottom = writeAnnexB(bitstreamFile, auBottom);
2112      rateStatsAccum(auBottom, statsBottom);
2113    }
2114  }
2115  else
2116  {
2117    Int i;
2118
2119    TComList<TComPicYuv*>::iterator iterPicYuvRec = m_cListPicYuvRec.end();
2120    list<AccessUnit>::const_iterator iterBitstream = accessUnits.begin();
2121
2122    for ( i = 0; i < iNumEncoded; i++ )
2123    {
2124      --iterPicYuvRec;
2125    }
2126
2127    for ( i = 0; i < iNumEncoded; i++ )
2128    {
2129      TComPicYuv*  pcPicYuvRec  = *(iterPicYuvRec++);
2130      if (!m_reconFileName.empty())
2131      {
2132        m_cTVideoIOYuvReconFile.write( pcPicYuvRec, ipCSC, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom,
2133            NUM_CHROMA_FORMAT, m_bClipOutputVideoToRec709Range  );
2134      }
2135
2136      const AccessUnit& au = *(iterBitstream++);
2137      const vector<UInt>& stats = writeAnnexB(bitstreamFile, au);
2138      rateStatsAccum(au, stats);
2139    }
2140  }
2141}
2142#endif
2143
2144/**
2145 *
2146 */
2147Void TAppEncTop::rateStatsAccum(const AccessUnit& au, const std::vector<UInt>& annexBsizes)
2148{
2149  AccessUnit::const_iterator it_au = au.begin();
2150  vector<UInt>::const_iterator it_stats = annexBsizes.begin();
2151
2152  for (; it_au != au.end(); it_au++, it_stats++)
2153  {
2154    switch ((*it_au)->m_nalUnitType)
2155    {
2156    case NAL_UNIT_CODED_SLICE_TRAIL_R:
2157    case NAL_UNIT_CODED_SLICE_TRAIL_N:
2158    case NAL_UNIT_CODED_SLICE_TSA_R:
2159    case NAL_UNIT_CODED_SLICE_TSA_N:
2160    case NAL_UNIT_CODED_SLICE_STSA_R:
2161    case NAL_UNIT_CODED_SLICE_STSA_N:
2162    case NAL_UNIT_CODED_SLICE_BLA_W_LP:
2163    case NAL_UNIT_CODED_SLICE_BLA_W_RADL:
2164    case NAL_UNIT_CODED_SLICE_BLA_N_LP:
2165    case NAL_UNIT_CODED_SLICE_IDR_W_RADL:
2166    case NAL_UNIT_CODED_SLICE_IDR_N_LP:
2167    case NAL_UNIT_CODED_SLICE_CRA:
2168    case NAL_UNIT_CODED_SLICE_RADL_N:
2169    case NAL_UNIT_CODED_SLICE_RADL_R:
2170    case NAL_UNIT_CODED_SLICE_RASL_N:
2171    case NAL_UNIT_CODED_SLICE_RASL_R:
2172    case NAL_UNIT_VPS:
2173    case NAL_UNIT_SPS:
2174    case NAL_UNIT_PPS:
2175      m_essentialBytes += *it_stats;
2176      break;
2177    default:
2178      break;
2179    }
2180
2181    m_totalBytes += *it_stats;
2182  }
2183}
2184
2185Void TAppEncTop::printRateSummary()
2186{
2187#if SVC_EXTENSION
2188  Double time = (Double) m_iFrameRcvd / m_apcLayerCfg[m_numLayers-1]->m_iFrameRate;
2189#else
2190  Double time = (Double) m_iFrameRcvd / m_iFrameRate;
2191#endif
2192  printf("Bytes written to file: %u (%.3f kbps)\n", m_totalBytes, 0.008 * m_totalBytes / time);
2193  if (m_summaryVerboseness > 0)
2194  {
2195    printf("Bytes for SPS/PPS/Slice (Incl. Annex B): %u (%.3f kbps)\n", m_essentialBytes, 0.008 * m_essentialBytes / time);
2196  }
2197}
2198
2199#if !SVC_EXTENSION
2200Void TAppEncTop::printChromaFormat()
2201{
2202  std::cout << std::setw(43) << "Input ChromaFormatIDC = ";
2203  switch (m_InputChromaFormatIDC)
2204  {
2205  case CHROMA_400:  std::cout << "  4:0:0"; break;
2206  case CHROMA_420:  std::cout << "  4:2:0"; break;
2207  case CHROMA_422:  std::cout << "  4:2:2"; break;
2208  case CHROMA_444:  std::cout << "  4:4:4"; break;
2209  default:
2210    std::cerr << "Invalid";
2211    exit(1);
2212  }
2213  std::cout << std::endl;
2214
2215  std::cout << std::setw(43) << "Output (internal) ChromaFormatIDC = ";
2216  switch (m_cTEncTop.getChromaFormatIdc())
2217  {
2218  case CHROMA_400:  std::cout << "  4:0:0"; break;
2219  case CHROMA_420:  std::cout << "  4:2:0"; break;
2220  case CHROMA_422:  std::cout << "  4:2:2"; break;
2221  case CHROMA_444:  std::cout << "  4:4:4"; break;
2222  default:
2223    std::cerr << "Invalid";
2224    exit(1);
2225  }
2226  std::cout << "\n" << std::endl;
2227}
2228#endif
2229
2230//! \}
Note: See TracBrowser for help on using the repository browser.