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

Last change on this file since 288 was 288, checked in by qualcomm, 12 years ago

Changes made to signaling of scaled reference layer offsets.

Patch incorporating changes made to signaling of scaled reference layer offsets during SHVC editing. The number of sets of scaled reference layer offsets is signaled. Changes to configuration files also included.

From: Adarsh K. Ramasubramonian <aramasub@…>
File size: 60.2 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-2013, ITU/ISO/IEC
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 *  * Redistributions of source code must retain the above copyright notice,
13 *    this list of conditions and the following disclaimer.
14 *  * Redistributions in binary form must reproduce the above copyright notice,
15 *    this list of conditions and the following disclaimer in the documentation
16 *    and/or other materials provided with the distribution.
17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18 *    be used to endorse or promote products derived from this software without
19 *    specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31 * THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34/** \file     TAppEncTop.cpp
35    \brief    Encoder application class
36*/
37
38#include <list>
39#include <fstream>
40#include <stdlib.h>
41#include <stdio.h>
42#include <fcntl.h>
43#include <assert.h>
44
45#include "TAppEncTop.h"
46#include "TLibEncoder/AnnexBwrite.h"
47
48using namespace std;
49
50//! \ingroup TAppEncoder
51//! \{
52
53// ====================================================================================================================
54// Constructor / destructor / initialization / destroy
55// ====================================================================================================================
56
57TAppEncTop::TAppEncTop()
58{
59  m_iFrameRcvd = 0;
60  m_totalBytes = 0;
61  m_essentialBytes = 0;
62#if SVC_EXTENSION
63  for(UInt layer=0; layer < MAX_LAYERS; layer++)
64  {
65    m_apcTEncTop[layer] = &m_acTEncTop[layer];
66  }
67#endif
68}
69
70TAppEncTop::~TAppEncTop()
71{
72}
73
74#if SVC_EXTENSION
75Void TAppEncTop::xInitLibCfg()
76{
77  TComVPS* vps = m_acTEncTop[0].getVPS();
78
79  vps->setMaxTLayers                       ( m_maxTempLayer );
80  if (m_maxTempLayer == 1)
81  {
82    vps->setTemporalNestingFlag(true);
83  }
84#if !VPS_RENAME
85  vps.setMaxLayers                        ( 1 );
86#endif
87  for(Int i = 0; i < MAX_TLAYER; i++)
88  {
89    vps->setNumReorderPics                 ( m_numReorderPics[i], i );
90    vps->setMaxDecPicBuffering             ( m_maxDecPicBuffering[i], i );
91  }
92
93  for(UInt layer=0; layer<m_numLayers; layer++)
94  {
95    //m_acTEncTop[layer].setVPS(&vps);
96    m_acTEncTop[layer].setFrameRate                    ( m_acLayerCfg[layer].getFrameRate() );
97    m_acTEncTop[layer].setFrameSkip                    ( m_FrameSkip );
98    m_acTEncTop[layer].setSourceWidth                  ( m_acLayerCfg[layer].getSourceWidth() );
99    m_acTEncTop[layer].setSourceHeight                 ( m_acLayerCfg[layer].getSourceHeight() );
100    m_acTEncTop[layer].setConformanceMode              ( m_acLayerCfg[layer].getConformanceMode() );
101    m_acTEncTop[layer].setConformanceWindow            ( m_acLayerCfg[layer].m_confLeft, m_acLayerCfg[layer].m_confRight, m_acLayerCfg[layer].m_confTop, m_acLayerCfg[layer].m_confBottom );
102    m_acTEncTop[layer].setFramesToBeEncoded            ( m_framesToBeEncoded );
103
104    m_acTEncTop[layer].setProfile(m_profile);
105    m_acTEncTop[layer].setLevel(m_levelTier, m_level);
106#if L0046_CONSTRAINT_FLAGS
107    m_acTEncTop[layer].setProgressiveSourceFlag(m_progressiveSourceFlag);
108    m_acTEncTop[layer].setInterlacedSourceFlag(m_interlacedSourceFlag);
109    m_acTEncTop[layer].setNonPackedConstraintFlag(m_nonPackedConstraintFlag);
110    m_acTEncTop[layer].setFrameOnlyConstraintFlag(m_frameOnlyConstraintFlag);
111#endif
112
113#if REF_IDX_MFM
114#if AVC_BASE
115    m_acTEncTop[layer].setMFMEnabledFlag(layer == 0 ? false : ( m_avcBaseLayerFlag ? AVC_SYNTAX : true ));
116#else
117    m_acTEncTop[layer].setMFMEnabledFlag(layer == 0 ? false : true);
118#endif
119#endif
120    // set layer ID
121    m_acTEncTop[layer].setLayerId ( layer ); 
122    m_acTEncTop[layer].setNumLayer ( m_numLayers );
123    m_acTEncTop[layer].setLayerEnc(m_apcTEncTop);
124
125    //====== Coding Structure ========
126    m_acTEncTop[layer].setIntraPeriod                  ( m_acLayerCfg[layer].m_iIntraPeriod );
127    m_acTEncTop[layer].setDecodingRefreshType          ( m_iDecodingRefreshType );
128    m_acTEncTop[layer].setGOPSize                      ( m_iGOPSize );
129    m_acTEncTop[layer].setGopList                      ( m_GOPList );
130    m_acTEncTop[layer].setExtraRPSs                    ( m_extraRPSs );
131    for(Int i = 0; i < MAX_TLAYER; i++)
132    {
133      m_acTEncTop[layer].setNumReorderPics             ( m_numReorderPics[i], i );
134      m_acTEncTop[layer].setMaxDecPicBuffering         ( m_maxDecPicBuffering[i], i );
135    }
136    for( UInt uiLoop = 0; uiLoop < MAX_TLAYER; ++uiLoop )
137    {
138      m_acTEncTop[layer].setLambdaModifier( uiLoop, m_adLambdaModifier[ uiLoop ] );
139    }
140    m_acTEncTop[layer].setQP                           ( m_acLayerCfg[layer].getIntQP() );
141
142    m_acTEncTop[layer].setPad                          ( m_acLayerCfg[layer].getPad() );
143
144    m_acTEncTop[layer].setMaxTempLayer                 ( m_maxTempLayer );
145    m_acTEncTop[layer].setUseAMP( m_enableAMP );
146#if VPS_EXTN_DIRECT_REF_LAYERS
147    if(layer)
148    {
149      if(m_acLayerCfg[layer].getNumDirectRefLayers() == -1)
150      {
151        // Not included in the configuration file; assume that each layer depends on previous layer
152        m_acTEncTop[layer].setNumDirectRefLayers       (1);      // One ref. layer
153        m_acTEncTop[layer].setRefLayerId               (0, layer - 1);   // Previous layer
154      }
155      else
156      {
157        m_acTEncTop[layer].setNumDirectRefLayers       ( m_acLayerCfg[layer].getNumDirectRefLayers() );     
158        for(Int i = 0; i < m_acTEncTop[layer].getNumDirectRefLayers(); i++)
159        {
160          m_acTEncTop[layer].setRefLayerId             ( i, m_acLayerCfg[layer].getRefLayerId(i));
161        }
162      }
163
164      if(m_acLayerCfg[layer].getNumActiveRefLayers() == -1)
165      {
166        m_acTEncTop[layer].setNumActiveRefLayers( m_acLayerCfg[layer].getNumDirectRefLayers() );
167        for( Int i = 0; i < m_acTEncTop[layer].getNumActiveRefLayers(); i++ )
168        {
169          m_acTEncTop[layer].setPredLayerId(i, i);
170        }
171      }
172      else
173      {
174        m_acTEncTop[layer].setNumActiveRefLayers       ( m_acLayerCfg[layer].getNumActiveRefLayers() );     
175        for(Int i = 0; i < m_acTEncTop[layer].getNumActiveRefLayers(); i++)
176        {
177          m_acTEncTop[layer].setPredLayerId             ( i, m_acLayerCfg[layer].getPredLayerId(i));
178        }
179      }
180    }
181#endif
182    //===== Slice ========
183
184    //====== Loop/Deblock Filter ========
185    m_acTEncTop[layer].setLoopFilterDisable            ( m_bLoopFilterDisable       );
186    m_acTEncTop[layer].setLoopFilterOffsetInPPS        ( m_loopFilterOffsetInPPS );
187    m_acTEncTop[layer].setLoopFilterBetaOffset         ( m_loopFilterBetaOffsetDiv2  );
188    m_acTEncTop[layer].setLoopFilterTcOffset           ( m_loopFilterTcOffsetDiv2    );
189    m_acTEncTop[layer].setDeblockingFilterControlPresent( m_DeblockingFilterControlPresent);
190#if L0386_DB_METRIC
191    m_acTEncTop[layer].setDeblockingFilterMetric       ( m_DeblockingFilterMetric );
192#endif
193
194    //====== Motion search ========
195    m_acTEncTop[layer].setFastSearch                   ( m_iFastSearch  );
196    m_acTEncTop[layer].setSearchRange                  ( m_iSearchRange );
197    m_acTEncTop[layer].setBipredSearchRange            ( m_bipredSearchRange );
198
199    //====== Quality control ========
200    m_acTEncTop[layer].setMaxDeltaQP                   ( m_iMaxDeltaQP  );
201    m_acTEncTop[layer].setMaxCuDQPDepth                ( m_iMaxCuDQPDepth  );
202
203    m_acTEncTop[layer].setChromaCbQpOffset             ( m_cbQpOffset     );
204    m_acTEncTop[layer].setChromaCrQpOffset             ( m_crQpOffset  );
205
206#if ADAPTIVE_QP_SELECTION
207    m_acTEncTop[layer].setUseAdaptQpSelect             ( m_bUseAdaptQpSelect   );
208#endif
209
210    Int lowestQP;
211    lowestQP =  - 6*(g_bitDepthY - 8); // XXX: check
212
213    if ((m_iMaxDeltaQP == 0 ) && (m_acLayerCfg[layer].getIntQP() == lowestQP) && (m_useLossless == true))
214    {
215      m_bUseAdaptiveQP = false;
216    }
217    m_acTEncTop[layer].setUseAdaptiveQP                ( m_bUseAdaptiveQP  );
218    m_acTEncTop[layer].setQPAdaptationRange            ( m_iQPAdaptationRange );
219
220    //====== Tool list ========
221    m_acTEncTop[layer].setUseSBACRD                    ( m_bUseSBACRD   );
222    m_acTEncTop[layer].setDeltaQpRD                    ( m_uiDeltaQpRD  );
223    m_acTEncTop[layer].setUseASR                       ( m_bUseASR      );
224    m_acTEncTop[layer].setUseHADME                     ( m_bUseHADME    );
225    m_acTEncTop[layer].setUseLossless                  ( m_useLossless );
226#if !L0034_COMBINED_LIST_CLEANUP
227    m_cTEncTop.setUseLComb                             ( m_bUseLComb    );
228#endif
229    m_acTEncTop[layer].setdQPs                         ( m_acLayerCfg[layer].getdQPs() );
230    m_acTEncTop[layer].setUseRDOQ                      ( m_useRDOQ     );
231    m_acTEncTop[layer].setUseRDOQTS                    ( m_useRDOQTS   );
232#if L0232_RD_PENALTY
233    m_acTEncTop[layer].setRDpenalty                    ( m_rdPenalty );
234#endif
235    m_acTEncTop[layer].setQuadtreeTULog2MaxSize        ( m_uiQuadtreeTULog2MaxSize );
236    m_acTEncTop[layer].setQuadtreeTULog2MinSize        ( m_uiQuadtreeTULog2MinSize );
237    m_acTEncTop[layer].setQuadtreeTUMaxDepthInter      ( m_uiQuadtreeTUMaxDepthInter );
238    m_acTEncTop[layer].setQuadtreeTUMaxDepthIntra      ( m_uiQuadtreeTUMaxDepthIntra );
239    m_acTEncTop[layer].setUseFastEnc                   ( m_bUseFastEnc  );
240    m_acTEncTop[layer].setUseEarlyCU                   ( m_bUseEarlyCU  ); 
241    m_acTEncTop[layer].setUseFastDecisionForMerge      ( m_useFastDecisionForMerge  );
242    m_acTEncTop[layer].setUseCbfFastMode               ( m_bUseCbfFastMode  );
243    m_acTEncTop[layer].setUseEarlySkipDetection        ( m_useEarlySkipDetection );
244#if FAST_INTRA_SHVC
245    m_acTEncTop[layer].setUseFastIntraScalable         ( m_useFastIntraScalable );
246#endif
247
248    m_acTEncTop[layer].setUseTransformSkip             ( m_useTransformSkip      );
249    m_acTEncTop[layer].setUseTransformSkipFast         ( m_useTransformSkipFast  );
250    m_acTEncTop[layer].setUseConstrainedIntraPred      ( m_bUseConstrainedIntraPred );
251    m_acTEncTop[layer].setPCMLog2MinSize               ( m_uiPCMLog2MinSize);
252    m_acTEncTop[layer].setUsePCM                       ( m_usePCM );
253    m_acTEncTop[layer].setPCMLog2MaxSize               ( m_pcmLog2MaxSize);
254    m_acTEncTop[layer].setMaxNumMergeCand              ( m_maxNumMergeCand );
255
256
257    //====== Weighted Prediction ========
258    m_acTEncTop[layer].setUseWP                   ( m_useWeightedPred      );
259    m_acTEncTop[layer].setWPBiPred                ( m_useWeightedBiPred   );
260    //====== Parallel Merge Estimation ========
261    m_acTEncTop[layer].setLog2ParallelMergeLevelMinus2 ( m_log2ParallelMergeLevel - 2 );
262
263    //====== Slice ========
264    m_acTEncTop[layer].setSliceMode               ( m_sliceMode                );
265    m_acTEncTop[layer].setSliceArgument           ( m_sliceArgument            );
266
267    //====== Dependent Slice ========
268    m_acTEncTop[layer].setSliceSegmentMode        ( m_sliceSegmentMode         );
269    m_acTEncTop[layer].setSliceSegmentArgument    ( m_sliceSegmentArgument     );
270    Int iNumPartInCU = 1<<(m_uiMaxCUDepth<<1);
271    if(m_sliceSegmentMode==FIXED_NUMBER_OF_LCU)
272    {
273      m_acTEncTop[layer].setSliceSegmentArgument ( m_sliceSegmentArgument * iNumPartInCU );
274    }
275    if(m_sliceMode==FIXED_NUMBER_OF_LCU)
276    {
277      m_acTEncTop[layer].setSliceArgument ( m_sliceArgument * iNumPartInCU );
278    }
279    if(m_sliceMode==FIXED_NUMBER_OF_TILES)
280    {
281      m_acTEncTop[layer].setSliceArgument ( m_sliceArgument );
282    }
283
284    if(m_sliceMode == 0 )
285    {
286      m_bLFCrossSliceBoundaryFlag = true;
287    }
288    m_acTEncTop[layer].setLFCrossSliceBoundaryFlag( m_bLFCrossSliceBoundaryFlag );
289    m_acTEncTop[layer].setUseSAO ( m_bUseSAO );
290    m_acTEncTop[layer].setMaxNumOffsetsPerPic (m_maxNumOffsetsPerPic);
291
292    m_acTEncTop[layer].setSaoLcuBoundary (m_saoLcuBoundary);
293    m_acTEncTop[layer].setSaoLcuBasedOptimization (m_saoLcuBasedOptimization);
294    m_acTEncTop[layer].setPCMInputBitDepthFlag  ( m_bPCMInputBitDepthFlag); 
295    m_acTEncTop[layer].setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag); 
296
297    m_acTEncTop[layer].setDecodedPictureHashSEIEnabled(m_decodedPictureHashSEIEnabled);
298    m_acTEncTop[layer].setRecoveryPointSEIEnabled( m_recoveryPointSEIEnabled );
299    m_acTEncTop[layer].setBufferingPeriodSEIEnabled( m_bufferingPeriodSEIEnabled );
300    m_acTEncTop[layer].setPictureTimingSEIEnabled( m_pictureTimingSEIEnabled );
301#if J0149_TONE_MAPPING_SEI
302    m_acTEncTop[layer].setToneMappingInfoSEIEnabled                 ( m_toneMappingInfoSEIEnabled );
303    m_acTEncTop[layer].setTMISEIToneMapId                           ( m_toneMapId );
304    m_acTEncTop[layer].setTMISEIToneMapCancelFlag                   ( m_toneMapCancelFlag );
305    m_acTEncTop[layer].setTMISEIToneMapPersistenceFlag              ( m_toneMapPersistenceFlag );
306    m_acTEncTop[layer].setTMISEICodedDataBitDepth                   ( m_toneMapCodedDataBitDepth );
307    m_acTEncTop[layer].setTMISEITargetBitDepth                      ( m_toneMapTargetBitDepth );
308    m_acTEncTop[layer].setTMISEIModelID                             ( m_toneMapModelId );
309    m_acTEncTop[layer].setTMISEIMinValue                            ( m_toneMapMinValue );
310    m_acTEncTop[layer].setTMISEIMaxValue                            ( m_toneMapMaxValue );
311    m_acTEncTop[layer].setTMISEISigmoidMidpoint                     ( m_sigmoidMidpoint );
312    m_acTEncTop[layer].setTMISEISigmoidWidth                        ( m_sigmoidWidth );
313    m_acTEncTop[layer].setTMISEIStartOfCodedInterva                 ( m_startOfCodedInterval );
314    m_acTEncTop[layer].setTMISEINumPivots                           ( m_numPivots );
315    m_acTEncTop[layer].setTMISEICodedPivotValue                     ( m_codedPivotValue );
316    m_acTEncTop[layer].setTMISEITargetPivotValue                    ( m_targetPivotValue );
317    m_acTEncTop[layer].setTMISEICameraIsoSpeedIdc                   ( m_cameraIsoSpeedIdc );
318    m_acTEncTop[layer].setTMISEICameraIsoSpeedValue                 ( m_cameraIsoSpeedValue );
319    m_acTEncTop[layer].setTMISEIExposureCompensationValueSignFlag   ( m_exposureCompensationValueSignFlag );
320    m_acTEncTop[layer].setTMISEIExposureCompensationValueNumerator  ( m_exposureCompensationValueNumerator );
321    m_acTEncTop[layer].setTMISEIExposureCompensationValueDenomIdc   ( m_exposureCompensationValueDenomIdc );
322    m_acTEncTop[layer].setTMISEIRefScreenLuminanceWhite             ( m_refScreenLuminanceWhite );
323    m_acTEncTop[layer].setTMISEIExtendedRangeWhiteLevel             ( m_extendedRangeWhiteLevel );
324    m_acTEncTop[layer].setTMISEINominalBlackLevelLumaCodeValue      ( m_nominalBlackLevelLumaCodeValue );
325    m_acTEncTop[layer].setTMISEINominalWhiteLevelLumaCodeValue      ( m_nominalWhiteLevelLumaCodeValue );
326    m_acTEncTop[layer].setTMISEIExtendedWhiteLevelLumaCodeValue     ( m_extendedWhiteLevelLumaCodeValue );
327#endif
328    m_acTEncTop[layer].setFramePackingArrangementSEIEnabled( m_framePackingSEIEnabled );
329    m_acTEncTop[layer].setFramePackingArrangementSEIType( m_framePackingSEIType );
330    m_acTEncTop[layer].setFramePackingArrangementSEIId( m_framePackingSEIId );
331    m_acTEncTop[layer].setFramePackingArrangementSEIQuincunx( m_framePackingSEIQuincunx );
332    m_acTEncTop[layer].setFramePackingArrangementSEIInterpretation( m_framePackingSEIInterpretation );
333    m_acTEncTop[layer].setDisplayOrientationSEIAngle( m_displayOrientationSEIAngle );
334    m_acTEncTop[layer].setTemporalLevel0IndexSEIEnabled( m_temporalLevel0IndexSEIEnabled );
335    m_acTEncTop[layer].setGradualDecodingRefreshInfoEnabled( m_gradualDecodingRefreshInfoEnabled );
336    m_acTEncTop[layer].setDecodingUnitInfoSEIEnabled( m_decodingUnitInfoSEIEnabled );
337#if L0208_SOP_DESCRIPTION_SEI
338    m_acTEncTop[layer].setSOPDescriptionSEIEnabled( m_SOPDescriptionSEIEnabled );
339#endif
340#if K0180_SCALABLE_NESTING_SEI
341    m_acTEncTop[layer].setScalableNestingSEIEnabled( m_scalableNestingSEIEnabled );
342#endif
343    m_acTEncTop[layer].setUniformSpacingIdr          ( m_iUniformSpacingIdr );
344    m_acTEncTop[layer].setNumColumnsMinus1           ( m_iNumColumnsMinus1 );
345    m_acTEncTop[layer].setNumRowsMinus1              ( m_iNumRowsMinus1 );
346    if(m_iUniformSpacingIdr==0)
347    {
348      m_acTEncTop[layer].setColumnWidth              ( m_pColumnWidth );
349      m_acTEncTop[layer].setRowHeight                ( m_pRowHeight );
350    }
351    m_acTEncTop[layer].xCheckGSParameters();
352    Int uiTilesCount          = (m_iNumRowsMinus1+1) * (m_iNumColumnsMinus1+1);
353    if(uiTilesCount == 1)
354    {
355      m_bLFCrossTileBoundaryFlag = true; 
356    }
357    m_acTEncTop[layer].setLFCrossTileBoundaryFlag( m_bLFCrossTileBoundaryFlag );
358    m_acTEncTop[layer].setWaveFrontSynchro           ( m_iWaveFrontSynchro );
359    m_acTEncTop[layer].setWaveFrontSubstreams        ( m_acLayerCfg[layer].m_iWaveFrontSubstreams );
360    m_acTEncTop[layer].setTMVPModeId ( m_TMVPModeId );
361    m_acTEncTop[layer].setUseScalingListId           ( m_useScalingListId  );
362    m_acTEncTop[layer].setScalingListFile            ( m_scalingListFile   );
363    m_acTEncTop[layer].setSignHideFlag(m_signHideFlag);
364#if RATE_CONTROL_LAMBDA_DOMAIN
365#if RC_SHVC_HARMONIZATION
366    m_acTEncTop[layer].setUseRateCtrl     (m_acLayerCfg[layer].getRCEnableRateControl());
367    m_acTEncTop[layer].setTargetBitrate   (m_acLayerCfg[layer].getRCTargetBitrate());
368    m_acTEncTop[layer].setKeepHierBit     (m_acLayerCfg[layer].getRCKeepHierarchicalBit());
369    m_acTEncTop[layer].setLCULevelRC      (m_acLayerCfg[layer].getRCLCULevelRC());
370    m_acTEncTop[layer].setUseLCUSeparateModel (m_acLayerCfg[layer].getRCUseLCUSeparateModel());
371    m_acTEncTop[layer].setInitialQP           (m_acLayerCfg[layer].getRCInitialQP());
372    m_acTEncTop[layer].setForceIntraQP        (m_acLayerCfg[layer].getRCForceIntraQP());
373#else
374    m_acTEncTop[layer].setUseRateCtrl         ( m_RCEnableRateControl );
375    m_acTEncTop[layer].setTargetBitrate       ( m_RCTargetBitrate );
376    m_acTEncTop[layer].setKeepHierBit         ( m_RCKeepHierarchicalBit );
377    m_acTEncTop[layer].setLCULevelRC          ( m_RCLCULevelRC );
378    m_acTEncTop[layer].setUseLCUSeparateModel ( m_RCUseLCUSeparateModel );
379    m_acTEncTop[layer].setInitialQP           ( m_RCInitialQP );
380    m_acTEncTop[layer].setForceIntraQP        ( m_RCForceIntraQP );
381#endif
382#else
383    m_acTEncTop[layer].setUseRateCtrl     ( m_enableRateCtrl);
384    m_acTEncTop[layer].setTargetBitrate   ( m_targetBitrate);
385    m_acTEncTop[layer].setNumLCUInUnit    ( m_numLCUInUnit);
386#endif
387    m_acTEncTop[layer].setTransquantBypassEnableFlag(m_TransquantBypassEnableFlag);
388    m_acTEncTop[layer].setCUTransquantBypassFlagValue(m_CUTransquantBypassFlagValue);
389    m_acTEncTop[layer].setUseRecalculateQPAccordingToLambda( m_recalculateQPAccordingToLambda );
390    m_acTEncTop[layer].setUseStrongIntraSmoothing( m_useStrongIntraSmoothing );
391    m_acTEncTop[layer].setActiveParameterSetsSEIEnabled ( m_activeParameterSetsSEIEnabled ); 
392    m_acTEncTop[layer].setVuiParametersPresentFlag( m_vuiParametersPresentFlag );
393    m_acTEncTop[layer].setAspectRatioIdc( m_aspectRatioIdc );
394    m_acTEncTop[layer].setSarWidth( m_sarWidth );
395    m_acTEncTop[layer].setSarHeight( m_sarHeight );
396    m_acTEncTop[layer].setOverscanInfoPresentFlag( m_overscanInfoPresentFlag );
397    m_acTEncTop[layer].setOverscanAppropriateFlag( m_overscanAppropriateFlag );
398    m_acTEncTop[layer].setVideoSignalTypePresentFlag( m_videoSignalTypePresentFlag );
399    m_acTEncTop[layer].setVideoFormat( m_videoFormat );
400    m_acTEncTop[layer].setVideoFullRangeFlag( m_videoFullRangeFlag );
401    m_acTEncTop[layer].setColourDescriptionPresentFlag( m_colourDescriptionPresentFlag );
402    m_acTEncTop[layer].setColourPrimaries( m_colourPrimaries );
403    m_acTEncTop[layer].setTransferCharacteristics( m_transferCharacteristics );
404    m_acTEncTop[layer].setMatrixCoefficients( m_matrixCoefficients );
405    m_acTEncTop[layer].setChromaLocInfoPresentFlag( m_chromaLocInfoPresentFlag );
406    m_acTEncTop[layer].setChromaSampleLocTypeTopField( m_chromaSampleLocTypeTopField );
407    m_acTEncTop[layer].setChromaSampleLocTypeBottomField( m_chromaSampleLocTypeBottomField );
408    m_acTEncTop[layer].setNeutralChromaIndicationFlag( m_neutralChromaIndicationFlag );
409    m_acTEncTop[layer].setDefaultDisplayWindow( m_defDispWinLeftOffset, m_defDispWinRightOffset, m_defDispWinTopOffset, m_defDispWinBottomOffset );
410    m_acTEncTop[layer].setFrameFieldInfoPresentFlag( m_frameFieldInfoPresentFlag );
411    m_acTEncTop[layer].setPocProportionalToTimingFlag( m_pocProportionalToTimingFlag );
412    m_acTEncTop[layer].setNumTicksPocDiffOneMinus1   ( m_numTicksPocDiffOneMinus1    );
413    m_acTEncTop[layer].setBitstreamRestrictionFlag( m_bitstreamRestrictionFlag );
414    m_acTEncTop[layer].setTilesFixedStructureFlag( m_tilesFixedStructureFlag );
415    m_acTEncTop[layer].setMotionVectorsOverPicBoundariesFlag( m_motionVectorsOverPicBoundariesFlag );
416    m_acTEncTop[layer].setMinSpatialSegmentationIdc( m_minSpatialSegmentationIdc );
417    m_acTEncTop[layer].setMaxBytesPerPicDenom( m_maxBytesPerPicDenom );
418    m_acTEncTop[layer].setMaxBitsPerMinCuDenom( m_maxBitsPerMinCuDenom );
419    m_acTEncTop[layer].setLog2MaxMvLengthHorizontal( m_log2MaxMvLengthHorizontal );
420    m_acTEncTop[layer].setLog2MaxMvLengthVertical( m_log2MaxMvLengthVertical );
421#if SIGNAL_BITRATE_PICRATE_IN_VPS
422    TComBitRatePicRateInfo *bitRatePicRateInfo = m_cTEncTop[layer].getVPS()->getBitratePicrateInfo();
423    // The number of bit rate/pic rate have to equal to number of sub-layers.
424    if(m_bitRatePicRateMaxTLayers)
425    {
426      assert(m_bitRatePicRateMaxTLayers == m_cTEncTop[layer].getVPS()->getMaxTLayers());
427    }
428    for(Int i = 0; i < m_bitRatePicRateMaxTLayers; i++)
429    {
430      bitRatePicRateInfo->setBitRateInfoPresentFlag( i, m_bitRateInfoPresentFlag[i] );
431      if( bitRatePicRateInfo->getBitRateInfoPresentFlag(i) )
432      {
433        bitRatePicRateInfo->setAvgBitRate(i, m_avgBitRate[i]);
434        bitRatePicRateInfo->setMaxBitRate(i, m_maxBitRate[i]);
435      }
436    }
437    for(Int i = 0; i < m_bitRatePicRateMaxTLayers; i++)
438    {
439      bitRatePicRateInfo->setPicRateInfoPresentFlag( i, m_picRateInfoPresentFlag[i] );
440      if( bitRatePicRateInfo->getPicRateInfoPresentFlag(i) )
441      {
442        bitRatePicRateInfo->setAvgPicRate     (i, m_avgPicRate[i]);
443        bitRatePicRateInfo->setConstantPicRateIdc(i, m_constantPicRateIdc[i]);
444      }
445    }
446#endif
447#if REF_IDX_FRAMEWORK
448    m_acTEncTop[layer].setElRapSliceTypeB(layer == 0? 0 : m_elRapSliceBEnabled);
449#endif
450#if SCALED_REF_LAYER_OFFSETS
451    if( layer > 0 )
452    {
453      m_acTEncTop[layer].setNumScaledRefLayerOffsets( m_acLayerCfg[layer].m_numScaledRefLayerOffsets );
454      for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
455      {
456        m_acTEncTop[layer].getScaledRefLayerWindow(i).setWindow( 2*m_acLayerCfg[layer].m_scaledRefLayerLeftOffset[i], 2*m_acLayerCfg[layer].m_scaledRefLayerRightOffset[i],
457                                                  2*m_acLayerCfg[layer].m_scaledRefLayerTopOffset[i], 2*m_acLayerCfg[layer].m_scaledRefLayerBottomOffset[i]); 
458      }
459    }
460#endif
461  }
462}
463#else
464Void TAppEncTop::xInitLibCfg()
465{
466  TComVPS vps;
467
468  vps.setMaxTLayers                       ( m_maxTempLayer );
469  if (m_maxTempLayer == 1)
470  {
471    vps.setTemporalNestingFlag(true);
472  }
473  vps.setMaxLayers                        ( 1 );
474  for(Int i = 0; i < MAX_TLAYER; i++)
475  {
476    vps.setNumReorderPics                 ( m_numReorderPics[i], i );
477    vps.setMaxDecPicBuffering             ( m_maxDecPicBuffering[i], i );
478  }
479  m_cTEncTop.setVPS(&vps);
480
481  m_cTEncTop.setProfile(m_profile);
482  m_cTEncTop.setLevel(m_levelTier, m_level);
483#if L0046_CONSTRAINT_FLAGS
484  m_cTEncTop.setProgressiveSourceFlag(m_progressiveSourceFlag);
485  m_cTEncTop.setInterlacedSourceFlag(m_interlacedSourceFlag);
486  m_cTEncTop.setNonPackedConstraintFlag(m_nonPackedConstraintFlag);
487  m_cTEncTop.setFrameOnlyConstraintFlag(m_frameOnlyConstraintFlag);
488#endif
489
490  m_cTEncTop.setFrameRate                    ( m_iFrameRate );
491  m_cTEncTop.setFrameSkip                    ( m_FrameSkip );
492  m_cTEncTop.setSourceWidth                  ( m_iSourceWidth );
493  m_cTEncTop.setSourceHeight                 ( m_iSourceHeight );
494  m_cTEncTop.setConformanceWindow            ( m_confLeft, m_confRight, m_confTop, m_confBottom );
495  m_cTEncTop.setFramesToBeEncoded            ( m_framesToBeEncoded );
496
497  //====== Coding Structure ========
498  m_cTEncTop.setIntraPeriod                  ( m_iIntraPeriod );
499  m_cTEncTop.setDecodingRefreshType          ( m_iDecodingRefreshType );
500  m_cTEncTop.setGOPSize                      ( m_iGOPSize );
501  m_cTEncTop.setGopList                      ( m_GOPList );
502  m_cTEncTop.setExtraRPSs                    ( m_extraRPSs );
503  for(Int i = 0; i < MAX_TLAYER; i++)
504  {
505    m_cTEncTop.setNumReorderPics             ( m_numReorderPics[i], i );
506    m_cTEncTop.setMaxDecPicBuffering         ( m_maxDecPicBuffering[i], i );
507  }
508  for( UInt uiLoop = 0; uiLoop < MAX_TLAYER; ++uiLoop )
509  {
510    m_cTEncTop.setLambdaModifier( uiLoop, m_adLambdaModifier[ uiLoop ] );
511  }
512  m_cTEncTop.setQP                           ( m_iQP );
513
514  m_cTEncTop.setPad                          ( m_aiPad );
515
516  m_cTEncTop.setMaxTempLayer                 ( m_maxTempLayer );
517  m_cTEncTop.setUseAMP( m_enableAMP );
518
519  //===== Slice ========
520
521  //====== Loop/Deblock Filter ========
522  m_cTEncTop.setLoopFilterDisable            ( m_bLoopFilterDisable       );
523  m_cTEncTop.setLoopFilterOffsetInPPS        ( m_loopFilterOffsetInPPS );
524  m_cTEncTop.setLoopFilterBetaOffset         ( m_loopFilterBetaOffsetDiv2  );
525  m_cTEncTop.setLoopFilterTcOffset           ( m_loopFilterTcOffsetDiv2    );
526  m_cTEncTop.setDeblockingFilterControlPresent( m_DeblockingFilterControlPresent);
527#if L0386_DB_METRIC
528  m_cTEncTop.setDeblockingFilterMetric       ( m_DeblockingFilterMetric );
529#endif
530
531  //====== Motion search ========
532  m_cTEncTop.setFastSearch                   ( m_iFastSearch  );
533  m_cTEncTop.setSearchRange                  ( m_iSearchRange );
534  m_cTEncTop.setBipredSearchRange            ( m_bipredSearchRange );
535
536  //====== Quality control ========
537  m_cTEncTop.setMaxDeltaQP                   ( m_iMaxDeltaQP  );
538  m_cTEncTop.setMaxCuDQPDepth                ( m_iMaxCuDQPDepth  );
539
540  m_cTEncTop.setChromaCbQpOffset               ( m_cbQpOffset     );
541  m_cTEncTop.setChromaCrQpOffset            ( m_crQpOffset  );
542
543#if ADAPTIVE_QP_SELECTION
544  m_cTEncTop.setUseAdaptQpSelect             ( m_bUseAdaptQpSelect   );
545#endif
546
547  Int lowestQP;
548  lowestQP =  - 6*(g_bitDepthY - 8); // XXX: check
549
550  if ((m_iMaxDeltaQP == 0 ) && (m_iQP == lowestQP) && (m_useLossless == true))
551  {
552    m_bUseAdaptiveQP = false;
553  }
554  m_cTEncTop.setUseAdaptiveQP                ( m_bUseAdaptiveQP  );
555  m_cTEncTop.setQPAdaptationRange            ( m_iQPAdaptationRange );
556
557  //====== Tool list ========
558  m_cTEncTop.setUseSBACRD                    ( m_bUseSBACRD   );
559  m_cTEncTop.setDeltaQpRD                    ( m_uiDeltaQpRD  );
560  m_cTEncTop.setUseASR                       ( m_bUseASR      );
561  m_cTEncTop.setUseHADME                     ( m_bUseHADME    );
562  m_cTEncTop.setUseLossless                  ( m_useLossless );
563#if !L0034_COMBINED_LIST_CLEANUP
564  m_cTEncTop.setUseLComb                     ( m_bUseLComb    );
565#endif
566  m_cTEncTop.setdQPs                         ( m_aidQP        );
567  m_cTEncTop.setUseRDOQ                      ( m_useRDOQ     );
568  m_cTEncTop.setUseRDOQTS                    ( m_useRDOQTS   );
569#if L0232_RD_PENALTY
570  m_cTEncTop.setRDpenalty                 ( m_rdPenalty );
571#endif
572  m_cTEncTop.setQuadtreeTULog2MaxSize        ( m_uiQuadtreeTULog2MaxSize );
573  m_cTEncTop.setQuadtreeTULog2MinSize        ( m_uiQuadtreeTULog2MinSize );
574  m_cTEncTop.setQuadtreeTUMaxDepthInter      ( m_uiQuadtreeTUMaxDepthInter );
575  m_cTEncTop.setQuadtreeTUMaxDepthIntra      ( m_uiQuadtreeTUMaxDepthIntra );
576  m_cTEncTop.setUseFastEnc                   ( m_bUseFastEnc  );
577  m_cTEncTop.setUseEarlyCU                   ( m_bUseEarlyCU  ); 
578  m_cTEncTop.setUseFastDecisionForMerge      ( m_useFastDecisionForMerge  );
579  m_cTEncTop.setUseCbfFastMode            ( m_bUseCbfFastMode  );
580  m_cTEncTop.setUseEarlySkipDetection            ( m_useEarlySkipDetection );
581#if FAST_INTRA_SHVC
582  m_cTEncTop.setUseFastIntraScalable            ( m_useFastIntraScalable );
583#endif
584
585  m_cTEncTop.setUseTransformSkip             ( m_useTransformSkip      );
586  m_cTEncTop.setUseTransformSkipFast         ( m_useTransformSkipFast  );
587  m_cTEncTop.setUseConstrainedIntraPred      ( m_bUseConstrainedIntraPred );
588  m_cTEncTop.setPCMLog2MinSize          ( m_uiPCMLog2MinSize);
589  m_cTEncTop.setUsePCM                       ( m_usePCM );
590  m_cTEncTop.setPCMLog2MaxSize               ( m_pcmLog2MaxSize);
591  m_cTEncTop.setMaxNumMergeCand              ( m_maxNumMergeCand );
592
593
594  //====== Weighted Prediction ========
595  m_cTEncTop.setUseWP                   ( m_useWeightedPred      );
596  m_cTEncTop.setWPBiPred                ( m_useWeightedBiPred   );
597  //====== Parallel Merge Estimation ========
598  m_cTEncTop.setLog2ParallelMergeLevelMinus2 ( m_log2ParallelMergeLevel - 2 );
599
600  //====== Slice ========
601  m_cTEncTop.setSliceMode               ( m_sliceMode                );
602  m_cTEncTop.setSliceArgument           ( m_sliceArgument            );
603
604  //====== Dependent Slice ========
605  m_cTEncTop.setSliceSegmentMode        ( m_sliceSegmentMode         );
606  m_cTEncTop.setSliceSegmentArgument    ( m_sliceSegmentArgument     );
607  Int iNumPartInCU = 1<<(m_uiMaxCUDepth<<1);
608  if(m_sliceSegmentMode==FIXED_NUMBER_OF_LCU)
609  {
610    m_cTEncTop.setSliceSegmentArgument ( m_sliceSegmentArgument * iNumPartInCU );
611  }
612  if(m_sliceMode==FIXED_NUMBER_OF_LCU)
613  {
614    m_cTEncTop.setSliceArgument ( m_sliceArgument * iNumPartInCU );
615  }
616  if(m_sliceMode==FIXED_NUMBER_OF_TILES)
617  {
618    m_cTEncTop.setSliceArgument ( m_sliceArgument );
619  }
620
621  if(m_sliceMode == 0 )
622  {
623    m_bLFCrossSliceBoundaryFlag = true;
624  }
625  m_cTEncTop.setLFCrossSliceBoundaryFlag( m_bLFCrossSliceBoundaryFlag );
626  m_cTEncTop.setUseSAO ( m_bUseSAO );
627  m_cTEncTop.setMaxNumOffsetsPerPic (m_maxNumOffsetsPerPic);
628
629  m_cTEncTop.setSaoLcuBoundary (m_saoLcuBoundary);
630  m_cTEncTop.setSaoLcuBasedOptimization (m_saoLcuBasedOptimization);
631  m_cTEncTop.setPCMInputBitDepthFlag  ( m_bPCMInputBitDepthFlag); 
632  m_cTEncTop.setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag); 
633
634  m_cTEncTop.setDecodedPictureHashSEIEnabled(m_decodedPictureHashSEIEnabled);
635  m_cTEncTop.setRecoveryPointSEIEnabled( m_recoveryPointSEIEnabled );
636  m_cTEncTop.setBufferingPeriodSEIEnabled( m_bufferingPeriodSEIEnabled );
637  m_cTEncTop.setPictureTimingSEIEnabled( m_pictureTimingSEIEnabled );
638#if J0149_TONE_MAPPING_SEI
639  m_cTEncTop.setToneMappingInfoSEIEnabled                 ( m_toneMappingInfoSEIEnabled );
640  m_cTEncTop.setTMISEIToneMapId                           ( m_toneMapId );
641  m_cTEncTop.setTMISEIToneMapCancelFlag                   ( m_toneMapCancelFlag );
642  m_cTEncTop.setTMISEIToneMapPersistenceFlag              ( m_toneMapPersistenceFlag );
643  m_cTEncTop.setTMISEICodedDataBitDepth                   ( m_toneMapCodedDataBitDepth );
644  m_cTEncTop.setTMISEITargetBitDepth                      ( m_toneMapTargetBitDepth );
645  m_cTEncTop.setTMISEIModelID                             ( m_toneMapModelId );
646  m_cTEncTop.setTMISEIMinValue                            ( m_toneMapMinValue );
647  m_cTEncTop.setTMISEIMaxValue                            ( m_toneMapMaxValue );
648  m_cTEncTop.setTMISEISigmoidMidpoint                     ( m_sigmoidMidpoint );
649  m_cTEncTop.setTMISEISigmoidWidth                        ( m_sigmoidWidth );
650  m_cTEncTop.setTMISEIStartOfCodedInterva                 ( m_startOfCodedInterval );
651  m_cTEncTop.setTMISEINumPivots                           ( m_numPivots );
652  m_cTEncTop.setTMISEICodedPivotValue                     ( m_codedPivotValue );
653  m_cTEncTop.setTMISEITargetPivotValue                    ( m_targetPivotValue );
654  m_cTEncTop.setTMISEICameraIsoSpeedIdc                   ( m_cameraIsoSpeedIdc );
655  m_cTEncTop.setTMISEICameraIsoSpeedValue                 ( m_cameraIsoSpeedValue );
656  m_cTEncTop.setTMISEIExposureCompensationValueSignFlag   ( m_exposureCompensationValueSignFlag );
657  m_cTEncTop.setTMISEIExposureCompensationValueNumerator  ( m_exposureCompensationValueNumerator );
658  m_cTEncTop.setTMISEIExposureCompensationValueDenomIdc   ( m_exposureCompensationValueDenomIdc );
659  m_cTEncTop.setTMISEIRefScreenLuminanceWhite             ( m_refScreenLuminanceWhite );
660  m_cTEncTop.setTMISEIExtendedRangeWhiteLevel             ( m_extendedRangeWhiteLevel );
661  m_cTEncTop.setTMISEINominalBlackLevelLumaCodeValue      ( m_nominalBlackLevelLumaCodeValue );
662  m_cTEncTop.setTMISEINominalWhiteLevelLumaCodeValue      ( m_nominalWhiteLevelLumaCodeValue );
663  m_cTEncTop.setTMISEIExtendedWhiteLevelLumaCodeValue     ( m_extendedWhiteLevelLumaCodeValue );
664#endif
665  m_cTEncTop.setFramePackingArrangementSEIEnabled( m_framePackingSEIEnabled );
666  m_cTEncTop.setFramePackingArrangementSEIType( m_framePackingSEIType );
667  m_cTEncTop.setFramePackingArrangementSEIId( m_framePackingSEIId );
668  m_cTEncTop.setFramePackingArrangementSEIQuincunx( m_framePackingSEIQuincunx );
669  m_cTEncTop.setFramePackingArrangementSEIInterpretation( m_framePackingSEIInterpretation );
670  m_cTEncTop.setDisplayOrientationSEIAngle( m_displayOrientationSEIAngle );
671  m_cTEncTop.setTemporalLevel0IndexSEIEnabled( m_temporalLevel0IndexSEIEnabled );
672  m_cTEncTop.setGradualDecodingRefreshInfoEnabled( m_gradualDecodingRefreshInfoEnabled );
673  m_cTEncTop.setDecodingUnitInfoSEIEnabled( m_decodingUnitInfoSEIEnabled );
674#if L0208_SOP_DESCRIPTION_SEI
675  m_cTEncTop.setSOPDescriptionSEIEnabled( m_SOPDescriptionSEIEnabled );
676#endif
677#if K0180_SCALABLE_NESTING_SEI
678  m_cTEncTop.setScalableNestingSEIEnabled( m_scalableNestingSEIEnabled );
679#endif
680  m_cTEncTop.setUniformSpacingIdr          ( m_iUniformSpacingIdr );
681  m_cTEncTop.setNumColumnsMinus1           ( m_iNumColumnsMinus1 );
682  m_cTEncTop.setNumRowsMinus1              ( m_iNumRowsMinus1 );
683  if(m_iUniformSpacingIdr==0)
684  {
685    m_cTEncTop.setColumnWidth              ( m_pColumnWidth );
686    m_cTEncTop.setRowHeight                ( m_pRowHeight );
687  }
688  m_cTEncTop.xCheckGSParameters();
689  Int uiTilesCount          = (m_iNumRowsMinus1+1) * (m_iNumColumnsMinus1+1);
690  if(uiTilesCount == 1)
691  {
692    m_bLFCrossTileBoundaryFlag = true; 
693  }
694  m_cTEncTop.setLFCrossTileBoundaryFlag( m_bLFCrossTileBoundaryFlag );
695  m_cTEncTop.setWaveFrontSynchro           ( m_iWaveFrontSynchro );
696  m_cTEncTop.setWaveFrontSubstreams        ( m_iWaveFrontSubstreams );
697  m_cTEncTop.setTMVPModeId ( m_TMVPModeId );
698  m_cTEncTop.setUseScalingListId           ( m_useScalingListId  );
699  m_cTEncTop.setScalingListFile            ( m_scalingListFile   );
700  m_cTEncTop.setSignHideFlag(m_signHideFlag);
701#if RATE_CONTROL_LAMBDA_DOMAIN
702  m_cTEncTop.setUseRateCtrl         ( m_RCEnableRateControl );
703  m_cTEncTop.setTargetBitrate       ( m_RCTargetBitrate );
704  m_cTEncTop.setKeepHierBit         ( m_RCKeepHierarchicalBit );
705  m_cTEncTop.setLCULevelRC          ( m_RCLCULevelRC );
706  m_cTEncTop.setUseLCUSeparateModel ( m_RCUseLCUSeparateModel );
707  m_cTEncTop.setInitialQP           ( m_RCInitialQP );
708  m_cTEncTop.setForceIntraQP        ( m_RCForceIntraQP );
709#else
710  m_cTEncTop.setUseRateCtrl     ( m_enableRateCtrl);
711  m_cTEncTop.setTargetBitrate   ( m_targetBitrate);
712  m_cTEncTop.setNumLCUInUnit    ( m_numLCUInUnit);
713#endif
714  m_cTEncTop.setTransquantBypassEnableFlag(m_TransquantBypassEnableFlag);
715  m_cTEncTop.setCUTransquantBypassFlagValue(m_CUTransquantBypassFlagValue);
716  m_cTEncTop.setUseRecalculateQPAccordingToLambda( m_recalculateQPAccordingToLambda );
717  m_cTEncTop.setUseStrongIntraSmoothing( m_useStrongIntraSmoothing );
718  m_cTEncTop.setActiveParameterSetsSEIEnabled ( m_activeParameterSetsSEIEnabled ); 
719  m_cTEncTop.setVuiParametersPresentFlag( m_vuiParametersPresentFlag );
720  m_cTEncTop.setAspectRatioIdc( m_aspectRatioIdc );
721  m_cTEncTop.setSarWidth( m_sarWidth );
722  m_cTEncTop.setSarHeight( m_sarHeight );
723  m_cTEncTop.setOverscanInfoPresentFlag( m_overscanInfoPresentFlag );
724  m_cTEncTop.setOverscanAppropriateFlag( m_overscanAppropriateFlag );
725  m_cTEncTop.setVideoSignalTypePresentFlag( m_videoSignalTypePresentFlag );
726  m_cTEncTop.setVideoFormat( m_videoFormat );
727  m_cTEncTop.setVideoFullRangeFlag( m_videoFullRangeFlag );
728  m_cTEncTop.setColourDescriptionPresentFlag( m_colourDescriptionPresentFlag );
729  m_cTEncTop.setColourPrimaries( m_colourPrimaries );
730  m_cTEncTop.setTransferCharacteristics( m_transferCharacteristics );
731  m_cTEncTop.setMatrixCoefficients( m_matrixCoefficients );
732  m_cTEncTop.setChromaLocInfoPresentFlag( m_chromaLocInfoPresentFlag );
733  m_cTEncTop.setChromaSampleLocTypeTopField( m_chromaSampleLocTypeTopField );
734  m_cTEncTop.setChromaSampleLocTypeBottomField( m_chromaSampleLocTypeBottomField );
735  m_cTEncTop.setNeutralChromaIndicationFlag( m_neutralChromaIndicationFlag );
736  m_cTEncTop.setDefaultDisplayWindow( m_defDispWinLeftOffset, m_defDispWinRightOffset, m_defDispWinTopOffset, m_defDispWinBottomOffset );
737  m_cTEncTop.setFrameFieldInfoPresentFlag( m_frameFieldInfoPresentFlag );
738  m_cTEncTop.setPocProportionalToTimingFlag( m_pocProportionalToTimingFlag );
739  m_cTEncTop.setNumTicksPocDiffOneMinus1   ( m_numTicksPocDiffOneMinus1    );
740  m_cTEncTop.setBitstreamRestrictionFlag( m_bitstreamRestrictionFlag );
741  m_cTEncTop.setTilesFixedStructureFlag( m_tilesFixedStructureFlag );
742  m_cTEncTop.setMotionVectorsOverPicBoundariesFlag( m_motionVectorsOverPicBoundariesFlag );
743  m_cTEncTop.setMinSpatialSegmentationIdc( m_minSpatialSegmentationIdc );
744  m_cTEncTop.setMaxBytesPerPicDenom( m_maxBytesPerPicDenom );
745  m_cTEncTop.setMaxBitsPerMinCuDenom( m_maxBitsPerMinCuDenom );
746  m_cTEncTop.setLog2MaxMvLengthHorizontal( m_log2MaxMvLengthHorizontal );
747  m_cTEncTop.setLog2MaxMvLengthVertical( m_log2MaxMvLengthVertical );
748#if SIGNAL_BITRATE_PICRATE_IN_VPS
749  TComBitRatePicRateInfo *bitRatePicRateInfo = m_cTEncTop.getVPS()->getBitratePicrateInfo();
750  // The number of bit rate/pic rate have to equal to number of sub-layers.
751  if(m_bitRatePicRateMaxTLayers)
752  {
753    assert(m_bitRatePicRateMaxTLayers == m_cTEncTop.getVPS()->getMaxTLayers());
754  }
755  for(Int i = 0; i < m_bitRatePicRateMaxTLayers; i++)
756  {
757    bitRatePicRateInfo->setBitRateInfoPresentFlag( i, m_bitRateInfoPresentFlag[i] );
758    if( bitRatePicRateInfo->getBitRateInfoPresentFlag(i) )
759    {
760      bitRatePicRateInfo->setAvgBitRate(i, m_avgBitRate[i]);
761      bitRatePicRateInfo->setMaxBitRate(i, m_maxBitRate[i]);
762    }
763  }
764  for(Int i = 0; i < m_bitRatePicRateMaxTLayers; i++)
765  {
766    bitRatePicRateInfo->setPicRateInfoPresentFlag( i, m_picRateInfoPresentFlag[i] );
767    if( bitRatePicRateInfo->getPicRateInfoPresentFlag(i) )
768    {
769      bitRatePicRateInfo->setAvgPicRate     (i, m_avgPicRate[i]);
770      bitRatePicRateInfo->setConstantPicRateIdc(i, m_constantPicRateIdc[i]);
771    }
772  }
773#endif
774}
775#endif
776
777Void TAppEncTop::xCreateLib()
778{
779  // Video I/O
780#if SVC_EXTENSION
781  // initialize global variables
782  initROM();
783
784  for(UInt layer=0; layer<m_numLayers; layer++)
785  {
786    m_acTVideoIOYuvInputFile[layer].open( (Char *)m_acLayerCfg[layer].getInputFile().c_str(),  false, m_inputBitDepthY, m_inputBitDepthC, m_internalBitDepthY, m_internalBitDepthC );  // read  mode
787    m_acTVideoIOYuvInputFile[layer].skipFrames(m_FrameSkip, m_acLayerCfg[layer].getSourceWidth() - m_acLayerCfg[layer].getPad()[0], m_acLayerCfg[layer].getSourceHeight() - m_acLayerCfg[layer].getPad()[1]);
788
789    if (!m_acLayerCfg[layer].getReconFile().empty())
790    {
791      m_acTVideoIOYuvReconFile[layer].open((Char *)m_acLayerCfg[layer].getReconFile().c_str(), true, m_outputBitDepthY, m_outputBitDepthC, m_internalBitDepthY, m_internalBitDepthC );  // write mode
792    }
793
794    m_acTEncTop[layer].create();
795  }
796#else
797  m_cTVideoIOYuvInputFile.open( m_pchInputFile,     false, m_inputBitDepthY, m_inputBitDepthC, m_internalBitDepthY, m_internalBitDepthC );  // read  mode
798  m_cTVideoIOYuvInputFile.skipFrames(m_FrameSkip, m_iSourceWidth - m_aiPad[0], m_iSourceHeight - m_aiPad[1]);
799
800  if (m_pchReconFile)
801    m_cTVideoIOYuvReconFile.open(m_pchReconFile, true, m_outputBitDepthY, m_outputBitDepthC, m_internalBitDepthY, m_internalBitDepthC);  // write mode
802
803  // Neo Decoder
804  m_cTEncTop.create();
805#endif
806}
807
808Void TAppEncTop::xDestroyLib()
809{
810  // Video I/O
811#if SVC_EXTENSION
812  // destroy ROM
813  destroyROM();
814
815  for(UInt layer=0; layer<m_numLayers; layer++)
816  {
817    m_acTVideoIOYuvInputFile[layer].close();
818    m_acTVideoIOYuvReconFile[layer].close();
819
820    m_acTEncTop[layer].destroy();
821  }
822#else
823  m_cTVideoIOYuvInputFile.close();
824  m_cTVideoIOYuvReconFile.close();
825
826  // Neo Decoder
827  m_cTEncTop.destroy();
828#endif
829}
830
831Void TAppEncTop::xInitLib()
832{
833#if SVC_EXTENSION
834  for(UInt layer=0; layer<m_numLayers; layer++)
835  {
836    m_acTEncTop[layer].init();
837  }
838#if VPS_RENAME
839  m_acTEncTop[0].getVPS()->setMaxLayers( m_numLayers );
840#endif
841#if VPS_EXTN_OP_LAYER_SETS
842  TComVPS* vps = m_acTEncTop[0].getVPS();
843  vps->setMaxLayerId(m_numLayers - 1);    // Set max-layer ID
844
845  vps->setNumLayerSets(m_numLayers);
846  for(Int setId = 1; setId < vps->getNumLayerSets(); setId++)
847  {
848    for(Int layerId = 0; layerId <= vps->getMaxLayerId(); layerId++)
849    {
850      vps->setLayerIdIncludedFlag(true, setId, layerId);
851    }
852  }
853#if VPS_EXTN_MASK_AND_DIM_INFO
854  UInt i = 0, dimIdLen = 0;
855#if AVC_BASE
856  vps->setAvcBaseLayerFlag(m_avcBaseLayerFlag);
857#else
858  vps->setAvcBaseLayerFlag(false);
859#endif
860  vps->setSplittingFlag(false);
861  for(i = 0; i < MAX_VPS_NUM_SCALABILITY_TYPES; i++)
862  {
863    vps->setScalabilityMask(i, false);
864  }
865  if(m_numLayers > 1) 
866  {
867    Int scalabilityTypes = 0;
868    for(i = 0; i < MAX_VPS_NUM_SCALABILITY_TYPES; i++)
869    {
870      vps->setScalabilityMask(i, m_scalabilityMask[i]);
871      scalabilityTypes += m_scalabilityMask[i];
872    }
873    assert( scalabilityTypes == 1 );
874    vps->setNumScalabilityTypes(scalabilityTypes);
875  }
876  else
877  {
878    vps->setNumScalabilityTypes(0);
879  }
880  while((1 << dimIdLen) < m_numLayers)
881  {
882    dimIdLen++;
883  }
884  vps->setDimensionIdLen(0, dimIdLen);
885  vps->setNuhLayerIdPresentFlag(false);
886  vps->setLayerIdInNuh(0, 0);
887  vps->setLayerIdInVps(0, 0);
888  for(i = 1; i < vps->getMaxLayers(); i++)
889  {
890    vps->setLayerIdInNuh(i, i);
891    vps->setLayerIdInVps(vps->getLayerIdInNuh(i), i);
892    vps->setDimensionId(i, 0, i);
893  }
894#endif
895#if VPS_EXTN_PROFILE_INFO
896  vps->getPTLForExtnPtr()->resize(vps->getNumLayerSets());
897  for(Int setId = 1; setId < vps->getNumLayerSets(); setId++)
898  {
899    vps->setProfilePresentFlag(setId, true);
900    // Note - may need to be changed for other layer structures.
901    *(vps->getPTLForExtn(setId)) = *(m_acTEncTop[setId].getSPS()->getPTL());
902  }
903#endif
904  // Target output layer
905#if VPS_PROFILE_OUTPUT_LAYERS
906  vps->setNumOutputLayerSets(vps->getNumLayerSets());   
907  vps->setNumProfileTierLevel(vps->getNumLayerSets());   
908  vps->setDefaultOneTargetOutputLayerFlag(true);
909  for(i = 1; i < vps->getNumLayerSets(); i++)
910  {
911    vps->setProfileLevelTierIdx(i, i);
912    vps->setOutputLayerSetIdx(i, i); 
913  }
914#else
915  vps->setNumOutputLayerSets(1);
916  Int lsIdx = 1;
917  vps->setOutputLayerSetIdx(0, lsIdx); // Because only one layer set
918#endif
919  for(Int lsIdx = 1; lsIdx < vps->getNumLayerSets(); lsIdx++)
920  {
921    // Include the highest layer as output layer
922    for(UInt layer=0; layer <= vps->getMaxLayerId() ; layer++)
923    {
924      if(vps->getLayerIdIncludedFlag(lsIdx, layer))
925      {
926        vps->setOutputLayerFlag(lsIdx, layer, layer == (vps->getMaxLayerId()));
927      }
928    }
929  }
930#endif
931#if VPS_EXTN_DIRECT_REF_LAYERS
932  // Direct reference layers
933  UInt maxDirectRefLayers = 0;
934  for(UInt layerCtr = 1;layerCtr <= vps->getMaxLayers() - 1; layerCtr++)
935  {
936    vps->setNumDirectRefLayers( layerCtr, m_acTEncTop[layerCtr].getNumDirectRefLayers() );
937    maxDirectRefLayers = max<UInt>( maxDirectRefLayers, vps->getNumDirectRefLayers( layerCtr ) );
938
939    for(i = 0; i < vps->getNumDirectRefLayers(layerCtr); i++)
940    {
941      vps->setRefLayerId( layerCtr, i, m_acTEncTop[layerCtr].getRefLayerId(i) );
942    }
943    // Set direct dependency flag
944    // Initialize flag to 0
945    for(Int refLayerCtr = 0; refLayerCtr < layerCtr; refLayerCtr++)
946    {
947      vps->setDirectDependencyFlag( layerCtr, refLayerCtr, false );
948    }
949    for(i = 0; i < vps->getNumDirectRefLayers(layerCtr); i++)
950    {
951      vps->setDirectDependencyFlag( layerCtr, vps->getLayerIdInVps(m_acTEncTop[layerCtr].getRefLayerId(i)), true);
952    }
953  }
954#endif
955#if JCTVC_M0458_INTERLAYER_RPS_SIG       
956    vps->setMaxOneActiveRefLayerFlag(maxDirectRefLayers > 1 ? false : true); 
957#endif
958#else
959  m_cTEncTop.init();
960#endif
961}
962
963// ====================================================================================================================
964// Public member functions
965// ====================================================================================================================
966
967/**
968 - create internal class
969 - initialize internal variable
970 - until the end of input YUV file, call encoding function in TEncTop class
971 - delete allocated buffers
972 - destroy internal class
973 .
974 */
975#if SVC_EXTENSION
976Void TAppEncTop::encode()
977{
978  fstream bitstreamFile(m_pBitstreamFile, fstream::binary | fstream::out);
979  if (!bitstreamFile)
980  {
981    fprintf(stderr, "\nfailed to open bitstream file `%s' for writing\n", m_pBitstreamFile);
982    exit(EXIT_FAILURE);
983  }
984
985  TComPicYuv*       pcPicYuvOrg [MAX_LAYERS];
986  TComPicYuv*       pcPicYuvRec = NULL;
987
988  // initialize internal class & member variables
989  xInitLibCfg();
990  xCreateLib();
991  xInitLib();
992
993  // main encoder loop
994  Int   iNumEncoded = 0, iTotalNumEncoded = 0;
995  Bool  bEos = false;
996
997  list<AccessUnit> outputAccessUnits; ///< list of access units to write out.  is populated by the encoding process
998
999  for(UInt layer=0; layer<m_numLayers; layer++)
1000  {
1001    // allocate original YUV buffer
1002    pcPicYuvOrg[layer] = new TComPicYuv;
1003#if SVC_UPSAMPLING
1004    pcPicYuvOrg[layer]->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeight(), m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth, NULL );
1005#else
1006    pcPicYuvOrg->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeight(), m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
1007#endif
1008  }
1009
1010#if AVC_SYNTAX
1011  fstream streamSyntaxFile;
1012  if( m_acTEncTop[0].getVPS()->getAvcBaseLayerFlag() )
1013  {
1014    if( !m_BLSyntaxFile )
1015    {
1016      printf( "Wrong base layer syntax input file\n" );
1017      exit(EXIT_FAILURE);
1018    }
1019    streamSyntaxFile.open( m_BLSyntaxFile, fstream::in | fstream::binary );
1020    if( !streamSyntaxFile.good() )
1021    {
1022      printf( "Base layer syntax input reading error\n" );
1023      exit(EXIT_FAILURE);
1024    }
1025    m_acTEncTop[0].setBLSyntaxFile( &streamSyntaxFile );
1026  }
1027#endif
1028
1029  Bool bFirstFrame = true;
1030  while ( !bEos )
1031  {
1032    // Read enough frames
1033    Bool bFramesReadyToCode = false;
1034    while(!bFramesReadyToCode)
1035    {
1036      for(UInt layer=0; layer<m_numLayers; layer++)
1037      {
1038        // get buffers
1039        xGetBuffer(pcPicYuvRec, layer);
1040
1041        // read input YUV file
1042        m_acTVideoIOYuvInputFile[layer].read( pcPicYuvOrg[layer], m_acLayerCfg[layer].getPad() );
1043
1044        if(layer == m_numLayers-1)
1045        {
1046          // increase number of received frames
1047          m_iFrameRcvd++;
1048          // check end of file
1049          bEos = (m_iFrameRcvd == m_framesToBeEncoded);
1050        }
1051
1052        m_acTEncTop[layer].encodePrep( pcPicYuvOrg[layer] );
1053      }
1054
1055      bFramesReadyToCode = !(!bFirstFrame && ( m_acTEncTop[m_numLayers-1].getNumPicRcvd() != m_iGOPSize && m_iGOPSize ) && !bEos );
1056    }
1057    Bool flush = 0;
1058    // if end of file (which is only detected on a read failure) flush the encoder of any queued pictures
1059    if (m_acTVideoIOYuvInputFile[m_numLayers-1].isEof())
1060    {
1061      flush = true;
1062      bEos = true;
1063      m_iFrameRcvd--;
1064      m_acTEncTop[m_numLayers-1].setFramesToBeEncoded(m_iFrameRcvd);
1065    }
1066
1067#if RC_SHVC_HARMONIZATION
1068    for(UInt layer=0; layer<m_numLayers; layer++)
1069    {
1070      if ( m_acTEncTop[layer].getUseRateCtrl() )
1071      {
1072        (m_acTEncTop[layer].getRateCtrl())->initRCGOP(m_acTEncTop[layer].getNumPicRcvd());
1073      }
1074    }
1075#endif
1076
1077    // loop through frames in one GOP
1078    for ( UInt iPicIdInGOP=0; iPicIdInGOP < (bFirstFrame? 1:m_iGOPSize); iPicIdInGOP++ )
1079    {
1080      // layer by layer for each frame
1081      for(UInt layer=0; layer<m_numLayers; layer++)
1082      {
1083        // call encoding function for one frame
1084        m_acTEncTop[layer].encode( flush ? 0 : pcPicYuvOrg[layer], m_acListPicYuvRec[layer], outputAccessUnits, iPicIdInGOP );
1085      }
1086    }
1087
1088#if RC_SHVC_HARMONIZATION
1089    for(UInt layer=0; layer<m_numLayers; layer++)
1090    {
1091      if ( m_acTEncTop[layer].getUseRateCtrl() )
1092      {
1093        (m_acTEncTop[layer].getRateCtrl())->destroyRCGOP();
1094      }
1095    }
1096#endif
1097
1098    iTotalNumEncoded = 0;
1099    for(UInt layer=0; layer<m_numLayers; layer++)
1100    {
1101      // write bistream to file if necessary
1102      iNumEncoded = m_acTEncTop[layer].getNumPicRcvd();
1103      if ( iNumEncoded > 0 )
1104      {
1105        xWriteRecon(layer, iNumEncoded);
1106        iTotalNumEncoded += iNumEncoded;
1107      }
1108      m_acTEncTop[layer].setNumPicRcvd( 0 );
1109    }
1110
1111    // write bitstream out
1112    if(iTotalNumEncoded)
1113    {
1114      xWriteStream(bitstreamFile, iTotalNumEncoded, outputAccessUnits);
1115      outputAccessUnits.clear();
1116    }
1117
1118    // print out summary
1119    if (bEos)
1120    {
1121      printOutSummary();
1122    }
1123
1124    bFirstFrame = false;
1125  }
1126  // delete original YUV buffer
1127  for(UInt layer=0; layer<m_numLayers; layer++)
1128  {
1129    pcPicYuvOrg[layer]->destroy();
1130    delete pcPicYuvOrg[layer];
1131    pcPicYuvOrg[layer] = NULL;
1132
1133    // delete used buffers in encoder class
1134    m_acTEncTop[layer].deletePicBuffer();
1135  }
1136
1137#if AVC_SYNTAX
1138  if( streamSyntaxFile.is_open() )
1139  {
1140    streamSyntaxFile.close();
1141  }
1142#endif
1143
1144  // delete buffers & classes
1145  xDeleteBuffer();
1146  xDestroyLib();
1147
1148  printRateSummary();
1149
1150  return;
1151}
1152
1153Void TAppEncTop::printOutSummary()
1154{
1155  UInt layer;
1156
1157  // set frame rate
1158  for(layer = 0; layer < m_numLayers; layer++)
1159  {
1160    m_gcAnalyzeAll[layer].setFrmRate( m_acLayerCfg[layer].getFrameRate());
1161    m_gcAnalyzeI[layer].setFrmRate( m_acLayerCfg[layer].getFrameRate() );
1162    m_gcAnalyzeP[layer].setFrmRate( m_acLayerCfg[layer].getFrameRate() );
1163    m_gcAnalyzeB[layer].setFrmRate( m_acLayerCfg[layer].getFrameRate() );
1164  }
1165
1166  //-- all
1167  printf( "\n\nSUMMARY --------------------------------------------------------\n" );
1168  printf( "\tTotal Frames |  "   "Bitrate    "  "Y-PSNR    "  "U-PSNR    "  "V-PSNR \n" );
1169  for(layer = 0; layer < m_numLayers; layer++)
1170  {
1171    m_gcAnalyzeAll[layer].printOut('a', layer);
1172  }
1173
1174  printf( "\n\nI Slices--------------------------------------------------------\n" );
1175  printf( "\tTotal Frames |  "   "Bitrate    "  "Y-PSNR    "  "U-PSNR    "  "V-PSNR \n" );
1176  for(layer = 0; layer < m_numLayers; layer++)
1177  {
1178    m_gcAnalyzeI[layer].printOut('i', layer);
1179  }
1180
1181  printf( "\n\nP Slices--------------------------------------------------------\n" );
1182  printf( "\tTotal Frames |  "   "Bitrate    "  "Y-PSNR    "  "U-PSNR    "  "V-PSNR \n" );
1183  for(layer = 0; layer < m_numLayers; layer++)
1184  {
1185    m_gcAnalyzeP[layer].printOut('p', layer);
1186  }
1187
1188  printf( "\n\nB Slices--------------------------------------------------------\n" );
1189  printf( "\tTotal Frames |  "   "Bitrate    "  "Y-PSNR    "  "U-PSNR    "  "V-PSNR \n" );
1190  for(layer = 0; layer < m_numLayers; layer++)
1191  {
1192    m_gcAnalyzeB[layer].printOut('b', layer);
1193  }
1194}
1195
1196#else
1197Void TAppEncTop::encode()
1198{
1199  fstream bitstreamFile(m_pchBitstreamFile, fstream::binary | fstream::out);
1200  if (!bitstreamFile)
1201  {
1202    fprintf(stderr, "\nfailed to open bitstream file `%s' for writing\n", m_pchBitstreamFile);
1203    exit(EXIT_FAILURE);
1204  }
1205
1206  TComPicYuv*       pcPicYuvOrg = new TComPicYuv;
1207  TComPicYuv*       pcPicYuvRec = NULL;
1208
1209  // initialize internal class & member variables
1210  xInitLibCfg();
1211  xCreateLib();
1212  xInitLib();
1213
1214  // main encoder loop
1215  Int   iNumEncoded = 0;
1216  Bool  bEos = false;
1217
1218  list<AccessUnit> outputAccessUnits; ///< list of access units to write out.  is populated by the encoding process
1219
1220  // allocate original YUV buffer
1221  pcPicYuvOrg->create( m_iSourceWidth, m_iSourceHeight, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
1222
1223  while ( !bEos )
1224  {
1225    // get buffers
1226    xGetBuffer(pcPicYuvRec);
1227
1228    // read input YUV file
1229    m_cTVideoIOYuvInputFile.read( pcPicYuvOrg, m_aiPad );
1230
1231    // increase number of received frames
1232    m_iFrameRcvd++;
1233
1234    bEos = (m_iFrameRcvd == m_framesToBeEncoded);
1235
1236    Bool flush = 0;
1237    // if end of file (which is only detected on a read failure) flush the encoder of any queued pictures
1238    if (m_cTVideoIOYuvInputFile.isEof())
1239    {
1240      flush = true;
1241      bEos = true;
1242      m_iFrameRcvd--;
1243      m_cTEncTop.setFramesToBeEncoded(m_iFrameRcvd);
1244    }
1245
1246    // call encoding function for one frame
1247    m_cTEncTop.encode( bEos, flush ? 0 : pcPicYuvOrg, m_cListPicYuvRec, outputAccessUnits, iNumEncoded );
1248
1249    // write bistream to file if necessary
1250    if ( iNumEncoded > 0 )
1251    {
1252      xWriteOutput(bitstreamFile, iNumEncoded, outputAccessUnits);
1253      outputAccessUnits.clear();
1254    }
1255  }
1256
1257  m_cTEncTop.printSummary();
1258
1259  // delete original YUV buffer
1260  pcPicYuvOrg->destroy();
1261  delete pcPicYuvOrg;
1262  pcPicYuvOrg = NULL;
1263
1264  // delete used buffers in encoder class
1265  m_cTEncTop.deletePicBuffer();
1266
1267  // delete buffers & classes
1268  xDeleteBuffer();
1269  xDestroyLib();
1270
1271  printRateSummary();
1272
1273  return;
1274}
1275#endif
1276
1277// ====================================================================================================================
1278// Protected member functions
1279// ====================================================================================================================
1280
1281/**
1282 - application has picture buffer list with size of GOP
1283 - picture buffer list acts as ring buffer
1284 - end of the list has the latest picture
1285 .
1286 */
1287#if SVC_EXTENSION
1288Void TAppEncTop::xGetBuffer( TComPicYuv*& rpcPicYuvRec, UInt layer)
1289{
1290  assert( m_iGOPSize > 0 );
1291
1292  // org. buffer
1293  if ( m_acListPicYuvRec[layer].size() == (UInt)m_iGOPSize )
1294  {
1295    rpcPicYuvRec = m_acListPicYuvRec[layer].popFront();
1296
1297  }
1298  else
1299  {
1300    rpcPicYuvRec = new TComPicYuv;
1301
1302#if SVC_UPSAMPLING
1303    rpcPicYuvRec->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeight(), m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth, NULL );
1304#else
1305    rpcPicYuvRec->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeight(), m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
1306#endif
1307
1308  }
1309  m_acListPicYuvRec[layer].pushBack( rpcPicYuvRec );
1310}
1311
1312Void TAppEncTop::xDeleteBuffer( )
1313{
1314  for(UInt layer=0; layer<m_numLayers; layer++)
1315  {
1316    TComList<TComPicYuv*>::iterator iterPicYuvRec  = m_acListPicYuvRec[layer].begin();
1317
1318    Int iSize = Int( m_acListPicYuvRec[layer].size() );
1319
1320    for ( Int i = 0; i < iSize; i++ )
1321    {
1322      TComPicYuv*  pcPicYuvRec  = *(iterPicYuvRec++);
1323      pcPicYuvRec->destroy();
1324      delete pcPicYuvRec; pcPicYuvRec = NULL;
1325    }
1326  } 
1327}
1328
1329Void TAppEncTop::xWriteRecon(UInt layer, Int iNumEncoded)
1330{
1331  Int i;
1332
1333  TComList<TComPicYuv*>::iterator iterPicYuvRec = m_acListPicYuvRec[layer].end();
1334
1335  for ( i = 0; i < iNumEncoded; i++ )
1336  {
1337    --iterPicYuvRec;
1338  }
1339
1340  for ( i = 0; i < iNumEncoded; i++ )
1341  {
1342    TComPicYuv*  pcPicYuvRec  = *(iterPicYuvRec++);
1343    if (!m_acLayerCfg[layer].getReconFile().empty())
1344    {
1345      m_acTVideoIOYuvReconFile[layer].write( pcPicYuvRec, m_acLayerCfg[layer].getConfLeft(), m_acLayerCfg[layer].getConfRight(), 
1346        m_acLayerCfg[layer].getConfTop(), m_acLayerCfg[layer].getConfBottom() );
1347    }
1348  }
1349}
1350
1351Void TAppEncTop::xWriteStream(std::ostream& bitstreamFile, Int iNumEncoded, const std::list<AccessUnit>& accessUnits)
1352{
1353  Int i;
1354
1355  list<AccessUnit>::const_iterator iterBitstream = accessUnits.begin();
1356
1357  for ( i = 0; i < iNumEncoded; i++ )
1358  {
1359    const AccessUnit& au = *(iterBitstream++);
1360    const vector<UInt>& stats = writeAnnexB(bitstreamFile, au);
1361    rateStatsAccum(au, stats);
1362  }
1363}
1364
1365#else // SVC_EXTENSION
1366Void TAppEncTop::xGetBuffer( TComPicYuv*& rpcPicYuvRec)
1367{
1368  assert( m_iGOPSize > 0 );
1369
1370  // org. buffer
1371  if ( m_cListPicYuvRec.size() == (UInt)m_iGOPSize )
1372  {
1373    rpcPicYuvRec = m_cListPicYuvRec.popFront();
1374
1375  }
1376  else
1377  {
1378    rpcPicYuvRec = new TComPicYuv;
1379
1380    rpcPicYuvRec->create( m_iSourceWidth, m_iSourceHeight, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
1381
1382  }
1383  m_cListPicYuvRec.pushBack( rpcPicYuvRec );
1384}
1385
1386Void TAppEncTop::xDeleteBuffer( )
1387{
1388  TComList<TComPicYuv*>::iterator iterPicYuvRec  = m_cListPicYuvRec.begin();
1389
1390  Int iSize = Int( m_cListPicYuvRec.size() );
1391
1392  for ( Int i = 0; i < iSize; i++ )
1393  {
1394    TComPicYuv*  pcPicYuvRec  = *(iterPicYuvRec++);
1395    pcPicYuvRec->destroy();
1396    delete pcPicYuvRec; pcPicYuvRec = NULL;
1397  }
1398
1399}
1400
1401/** \param iNumEncoded  number of encoded frames
1402 */
1403Void TAppEncTop::xWriteOutput(std::ostream& bitstreamFile, Int iNumEncoded, const std::list<AccessUnit>& accessUnits)
1404{
1405  Int i;
1406
1407  TComList<TComPicYuv*>::iterator iterPicYuvRec = m_cListPicYuvRec.end();
1408  list<AccessUnit>::const_iterator iterBitstream = accessUnits.begin();
1409
1410  for ( i = 0; i < iNumEncoded; i++ )
1411  {
1412    --iterPicYuvRec;
1413  }
1414
1415  for ( i = 0; i < iNumEncoded; i++ )
1416  {
1417    TComPicYuv*  pcPicYuvRec  = *(iterPicYuvRec++);
1418    if (m_pchReconFile)
1419    {
1420#if SYNTAX_OUTPUT && ILP_DECODED_PICTURE
1421      m_cTVideoIOYuvReconFile.write( pcPicYuvRec );
1422#else
1423      m_cTVideoIOYuvReconFile.write( pcPicYuvRec, m_confLeft, m_confRight, m_confTop, m_confBottom );
1424#endif
1425    }
1426
1427    const AccessUnit& au = *(iterBitstream++);
1428    const vector<UInt>& stats = writeAnnexB(bitstreamFile, au);
1429    rateStatsAccum(au, stats);
1430  }
1431}
1432#endif
1433
1434/**
1435 *
1436 */
1437void TAppEncTop::rateStatsAccum(const AccessUnit& au, const std::vector<UInt>& annexBsizes)
1438{
1439  AccessUnit::const_iterator it_au = au.begin();
1440  vector<UInt>::const_iterator it_stats = annexBsizes.begin();
1441
1442  for (; it_au != au.end(); it_au++, it_stats++)
1443  {
1444    switch ((*it_au)->m_nalUnitType)
1445    {
1446    case NAL_UNIT_CODED_SLICE_TRAIL_R:
1447    case NAL_UNIT_CODED_SLICE_TRAIL_N:
1448    case NAL_UNIT_CODED_SLICE_TLA_R:
1449    case NAL_UNIT_CODED_SLICE_TSA_N:
1450    case NAL_UNIT_CODED_SLICE_STSA_R:
1451    case NAL_UNIT_CODED_SLICE_STSA_N:
1452    case NAL_UNIT_CODED_SLICE_BLA_W_LP:
1453    case NAL_UNIT_CODED_SLICE_BLA_W_RADL:
1454    case NAL_UNIT_CODED_SLICE_BLA_N_LP:
1455    case NAL_UNIT_CODED_SLICE_IDR_W_RADL:
1456    case NAL_UNIT_CODED_SLICE_IDR_N_LP:
1457    case NAL_UNIT_CODED_SLICE_CRA:
1458    case NAL_UNIT_CODED_SLICE_RADL_N:
1459    case NAL_UNIT_CODED_SLICE_RADL_R:
1460    case NAL_UNIT_CODED_SLICE_RASL_N:
1461    case NAL_UNIT_CODED_SLICE_RASL_R:
1462    case NAL_UNIT_VPS:
1463    case NAL_UNIT_SPS:
1464    case NAL_UNIT_PPS:
1465      m_essentialBytes += *it_stats;
1466      break;
1467    default:
1468      break;
1469    }
1470
1471    m_totalBytes += *it_stats;
1472  }
1473}
1474
1475void TAppEncTop::printRateSummary()
1476{
1477#if SVC_EXTENSION
1478  Double time = (Double) m_iFrameRcvd / m_acLayerCfg[m_numLayers-1].getFrameRate();
1479#else
1480  Double time = (Double) m_iFrameRcvd / m_iFrameRate;
1481#endif
1482  printf("Bytes written to file: %u (%.3f kbps)\n", m_totalBytes, 0.008 * m_totalBytes / time);
1483#if VERBOSE_RATE
1484  printf("Bytes for SPS/PPS/Slice (Incl. Annex B): %u (%.3f kbps)\n", m_essentialBytes, 0.008 * m_essentialBytes / time);
1485#endif
1486}
1487
1488//! \}
Note: See TracBrowser for help on using the repository browser.