Context navigation

source: SHVCSoftware/trunk/source/App/TAppEncoder/TAppEncTop.cpp @ 28

Visit:

Last change on this file since 28 was 28, checked in by seregin, 13 years ago
Reintegrate SHM-1.0-dev branch
File size: 42.9 KB

Line
1	/* The copyright in this software is being made available under the BSD
2	* License, included below. This software may be subject to other third party
3	* and contributor rights, including patent rights, and no such rights are
4	* granted under this license.
5	*
6	* Copyright (c) 2010-2012, ITU/ISO/IEC
7	* All rights reserved.
8	*
9	* Redistribution and use in source and binary forms, with or without
10	* modification, are permitted provided that the following conditions are met:
11	*
12	* * Redistributions of source code must retain the above copyright notice,
13	* this list of conditions and the following disclaimer.
14	* * Redistributions in binary form must reproduce the above copyright notice,
15	* this list of conditions and the following disclaimer in the documentation
16	* and/or other materials provided with the distribution.
17	* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18	* be used to endorse or promote products derived from this software without
19	* specific prior written permission.
20	*
21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31	* THE POSSIBILITY OF SUCH DAMAGE.
32	*/
33
34	/** \file 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
48	using namespace std;
49
50	//! \ingroup TAppEncoder
51	//! \{
52
53	// ====================================================================================================================
54	// Constructor / destructor / initialization / destroy
55	// ====================================================================================================================
56
57	TAppEncTop::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
70	TAppEncTop::~TAppEncTop()
71	{
72	}
73
74	#if SVC_EXTENSION
75	Void TAppEncTop::xInitLibCfg()
76	{
77	for(UInt layer=0; layer<m_numLayers; layer++)
78	{
79	TComVPS vps;
80
81	vps.setMaxTLayers ( m_maxTempLayer );
82	vps.setMaxLayers ( 1 );
83	for(Int i = 0; i < MAX_TLAYER; i++)
84	{
85	vps.setNumReorderPics ( m_numReorderPics[i], i );
86	vps.setMaxDecPicBuffering ( m_maxDecPicBuffering[i], i );
87	}
88	m_acTEncTop[layer].setVPS(&vps);
89	m_acTEncTop[layer].setFrameRate ( m_acLayerCfg[layer].getFrameRate() );
90	m_acTEncTop[layer].setFrameSkip ( m_FrameSkip );
91	m_acTEncTop[layer].setSourceWidth ( m_acLayerCfg[layer].getSourceWidth() );
92	m_acTEncTop[layer].setSourceHeight ( m_acLayerCfg[layer].getSourceHeight() );
93	m_acTEncTop[layer].setCroppingMode ( m_acLayerCfg[layer].getCroppingMode() );
94	m_acTEncTop[layer].setCropLeft ( m_acLayerCfg[layer].getCropLeft() );
95	m_acTEncTop[layer].setCropRight ( m_acLayerCfg[layer].getCropRight() );
96	m_acTEncTop[layer].setCropTop ( m_acLayerCfg[layer].getCropTop() );
97	m_acTEncTop[layer].setCropBottom ( m_acLayerCfg[layer].getCropBottom() );
98	m_acTEncTop[layer].setFrameToBeEncoded ( m_iFrameToBeEncoded );
99
100	#if REF_IDX_MFM
101	if(layer == 0)
102	m_acTEncTop[layer].setMFMEnabledFlag(false);
103	else
104	m_acTEncTop[layer].setMFMEnabledFlag(true);
105	#endif
106	// set layer ID
107	m_acTEncTop[layer].setLayerId ( layer );
108	m_acTEncTop[layer].setNumLayer ( m_numLayers );
109	m_acTEncTop[layer].setLayerEnc(m_apcTEncTop);
110
111
112	//====== Coding Structure ========
113	m_acTEncTop[layer].setIntraPeriod ( m_acLayerCfg[layer].m_iIntraPeriod );
114	m_acTEncTop[layer].setDecodingRefreshType ( m_iDecodingRefreshType );
115	m_acTEncTop[layer].setGOPSize ( m_iGOPSize );
116	m_acTEncTop[layer].setGopList ( m_GOPList );
117	m_acTEncTop[layer].setExtraRPSs ( m_extraRPSs );
118	for(Int i = 0; i < MAX_TLAYER; i++)
119	{
120	m_acTEncTop[layer].setNumReorderPics ( m_numReorderPics[i], i );
121	m_acTEncTop[layer].setMaxDecPicBuffering ( m_maxDecPicBuffering[i], i );
122	}
123	for( UInt uiLoop = 0; uiLoop < MAX_TLAYER; ++uiLoop )
124	{
125	m_acTEncTop[layer].setLambdaModifier( uiLoop, m_adLambdaModifier[ uiLoop ] );
126	}
127	m_acTEncTop[layer].setQP ( m_acLayerCfg[layer].getIntQP() );
128
129	m_acTEncTop[layer].setPad ( m_acLayerCfg[layer].getPad() );
130
131	m_acTEncTop[layer].setMaxTempLayer ( m_maxTempLayer );
132	#if !REMOVE_NSQT
133	m_acTEncTop[layer].setUseNSQT( m_enableNSQT );
134	#endif
135	m_acTEncTop[layer].setUseAMP( m_enableAMP );
136
137	//===== Slice ========
138
139	//====== Loop/Deblock Filter ========
140	m_acTEncTop[layer].setLoopFilterDisable ( m_bLoopFilterDisable );
141	m_acTEncTop[layer].setLoopFilterOffsetInPPS ( m_loopFilterOffsetInPPS );
142	m_acTEncTop[layer].setLoopFilterBetaOffset ( m_loopFilterBetaOffsetDiv2 );
143	m_acTEncTop[layer].setLoopFilterTcOffset ( m_loopFilterTcOffsetDiv2 );
144	m_acTEncTop[layer].setDeblockingFilterControlPresent( m_DeblockingFilterControlPresent);
145
146	//====== Motion search ========
147	m_acTEncTop[layer].setFastSearch ( m_iFastSearch );
148	m_acTEncTop[layer].setSearchRange ( m_iSearchRange );
149	m_acTEncTop[layer].setBipredSearchRange ( m_bipredSearchRange );
150
151	//====== Quality control ========
152	m_acTEncTop[layer].setMaxDeltaQP ( m_iMaxDeltaQP );
153	m_acTEncTop[layer].setMaxCuDQPDepth ( m_iMaxCuDQPDepth );
154
155	m_acTEncTop[layer].setChromaCbQpOffset ( m_cbQpOffset );
156	m_acTEncTop[layer].setChromaCrQpOffset ( m_crQpOffset );
157
158	#if ADAPTIVE_QP_SELECTION
159	m_acTEncTop[layer].setUseAdaptQpSelect ( m_bUseAdaptQpSelect );
160	#endif
161
162	Int lowestQP;
163	lowestQP = - ( (Int)(6*(g_uiBitDepth + g_uiBitIncrement - 8)) );
164
165	if ((m_iMaxDeltaQP == 0 ) && (m_acLayerCfg[layer].getIntQP() == lowestQP) && (m_useLossless == true))
166	{
167	m_bUseAdaptiveQP = false;
168	}
169	m_acTEncTop[layer].setUseAdaptiveQP ( m_bUseAdaptiveQP );
170	m_acTEncTop[layer].setQPAdaptationRange ( m_iQPAdaptationRange );
171
172	//====== Tool list ========
173	m_acTEncTop[layer].setUseSBACRD ( m_bUseSBACRD );
174	m_acTEncTop[layer].setDeltaQpRD ( m_uiDeltaQpRD );
175	m_acTEncTop[layer].setUseASR ( m_bUseASR );
176	m_acTEncTop[layer].setUseHADME ( m_bUseHADME );
177	#if !REMOVE_ALF
178	m_acTEncTop[layer].setUseALF ( m_bUseALF );
179	#endif
180	m_acTEncTop[layer].setUseLossless ( m_useLossless );
181	m_acTEncTop[layer].setUseLComb ( m_bUseLComb );
182	m_acTEncTop[layer].setdQPs ( m_acLayerCfg[layer].getdQPs() );
183	m_acTEncTop[layer].setUseRDOQ ( m_bUseRDOQ );
184	m_acTEncTop[layer].setQuadtreeTULog2MaxSize ( m_uiQuadtreeTULog2MaxSize );
185	m_acTEncTop[layer].setQuadtreeTULog2MinSize ( m_uiQuadtreeTULog2MinSize );
186	m_acTEncTop[layer].setQuadtreeTUMaxDepthInter ( m_uiQuadtreeTUMaxDepthInter );
187	m_acTEncTop[layer].setQuadtreeTUMaxDepthIntra ( m_uiQuadtreeTUMaxDepthIntra );
188	m_acTEncTop[layer].setUseFastEnc ( m_bUseFastEnc );
189	m_acTEncTop[layer].setUseEarlyCU ( m_bUseEarlyCU );
190	m_acTEncTop[layer].setUseFastDecisionForMerge ( m_useFastDecisionForMerge );
191	m_acTEncTop[layer].setUseCbfFastMode ( m_bUseCbfFastMode );
192	m_acTEncTop[layer].setUseEarlySkipDetection ( m_useEarlySkipDetection );
193
194	#if !REMOVE_LMCHROMA
195	m_acTEncTop[layer].setUseLMChroma ( m_bUseLMChroma );
196	#endif
197	m_acTEncTop[layer].setUseTransformSkip ( m_useTransformSkip );
198	m_acTEncTop[layer].setUseTransformSkipFast ( m_useTransformSkipFast );
199	m_acTEncTop[layer].setUseConstrainedIntraPred ( m_bUseConstrainedIntraPred );
200	m_acTEncTop[layer].setPCMLog2MinSize ( m_uiPCMLog2MinSize);
201	m_acTEncTop[layer].setUsePCM ( m_usePCM );
202	m_acTEncTop[layer].setPCMLog2MaxSize ( m_pcmLog2MaxSize);
203	m_acTEncTop[layer].setMaxNumMergeCand ( m_maxNumMergeCand );
204
205
206	//====== Weighted Prediction ========
207	m_acTEncTop[layer].setUseWP ( m_bUseWeightPred );
208	m_acTEncTop[layer].setWPBiPred ( m_useWeightedBiPred );
209	//====== Parallel Merge Estimation ========
210	m_acTEncTop[layer].setLog2ParallelMergeLevelMinus2 ( m_log2ParallelMergeLevel - 2 );
211
212	//====== Slice ========
213	m_acTEncTop[layer].setSliceMode ( m_iSliceMode );
214	m_acTEncTop[layer].setSliceArgument ( m_iSliceArgument );
215
216	//====== Dependent Slice ========
217	m_acTEncTop[layer].setDependentSliceMode ( m_iDependentSliceMode );
218	m_acTEncTop[layer].setDependentSliceArgument ( m_iDependentSliceArgument );
219	#if DEPENDENT_SLICES
220	#if TILES_WPP_ENTROPYSLICES_FLAGS
221	m_acTEncTop[layer].setEntropySliceEnabledFlag ( m_entropySliceEnabledFlag );
222	#else
223	m_acTEncTop[layer].setCabacIndependentFlag ( m_bCabacIndependentFlag );
224	#endif
225	#endif
226	int iNumPartInCU = 1<<(m_uiMaxCUDepth<<1);
227	if(m_iDependentSliceMode==SHARP_FIXED_NUMBER_OF_LCU_IN_DEPENDENT_SLICE)
228	{
229	#if REMOVE_FGS
230	m_acTEncTop[layer].setDependentSliceArgument ( m_iDependentSliceArgument * iNumPartInCU );
231	#else
232	m_acTEncTop[layer].setDependentSliceArgument ( m_iDependentSliceArgument * ( iNumPartInCU >> ( m_iSliceGranularity << 1 ) ) );
233	#endif
234	}
235	if(m_iSliceMode==AD_HOC_SLICES_FIXED_NUMBER_OF_LCU_IN_SLICE)
236	{
237	#if REMOVE_FGS
238	m_acTEncTop[layer].setSliceArgument ( m_iSliceArgument * iNumPartInCU );
239	#else
240	m_acTEncTop[layer].setSliceArgument ( m_iSliceArgument * ( iNumPartInCU >> ( m_iSliceGranularity << 1 ) ) );
241	#endif
242	}
243	if(m_iSliceMode==AD_HOC_SLICES_FIXED_NUMBER_OF_TILES_IN_SLICE)
244	{
245	m_acTEncTop[layer].setSliceArgument ( m_iSliceArgument );
246	}
247
248	#if !REMOVE_FGS
249	m_acTEncTop[layer].setSliceGranularity ( m_iSliceGranularity );
250	#endif
251	if(m_iSliceMode == 0 )
252	{
253	m_bLFCrossSliceBoundaryFlag = true;
254	}
255	m_acTEncTop[layer].setLFCrossSliceBoundaryFlag( m_bLFCrossSliceBoundaryFlag );
256	m_acTEncTop[layer].setUseSAO ( m_bUseSAO );
257	m_acTEncTop[layer].setMaxNumOffsetsPerPic (m_maxNumOffsetsPerPic);
258
259	#if SAO_LCU_BOUNDARY
260	m_acTEncTop[layer].setSaoLcuBoundary (m_saoLcuBoundary);
261	#endif
262	m_acTEncTop[layer].setSaoLcuBasedOptimization (m_saoLcuBasedOptimization);
263	m_acTEncTop[layer].setPCMInputBitDepthFlag ( m_bPCMInputBitDepthFlag);
264	m_acTEncTop[layer].setPCMFilterDisableFlag ( m_bPCMFilterDisableFlag);
265
266	m_acTEncTop[layer].setDecodedPictureHashSEIEnabled(m_decodePictureHashSEIEnabled);
267	#if RECOVERY_POINT_SEI
268	m_acTEncTop[layer].setRecoveryPointSEIEnabled( m_recoveryPointSEIEnabled );
269	#endif
270	#if BUFFERING_PERIOD_AND_TIMING_SEI
271	m_acTEncTop[layer].setBufferingPeriodSEIEnabled( m_bufferingPeriodSEIEnabled );
272	m_acTEncTop[layer].setPictureTimingSEIEnabled( m_pictureTimingSEIEnabled );
273	#endif
274	m_acTEncTop[layer].setUniformSpacingIdr ( m_iUniformSpacingIdr );
275	m_acTEncTop[layer].setNumColumnsMinus1 ( m_iNumColumnsMinus1 );
276	m_acTEncTop[layer].setNumRowsMinus1 ( m_iNumRowsMinus1 );
277	if(m_iUniformSpacingIdr==0)
278	{
279	m_acTEncTop[layer].setColumnWidth ( m_pchColumnWidth );
280	m_acTEncTop[layer].setRowHeight ( m_pchRowHeight );
281	}
282	m_acTEncTop[layer].xCheckGSParameters();
283	Int uiTilesCount = (m_iNumRowsMinus1+1) * (m_iNumColumnsMinus1+1);
284	if(uiTilesCount == 1)
285	{
286	m_bLFCrossTileBoundaryFlag = true;
287	}
288	m_acTEncTop[layer].setLFCrossTileBoundaryFlag( m_bLFCrossTileBoundaryFlag );
289	m_acTEncTop[layer].setWaveFrontSynchro ( m_iWaveFrontSynchro );
290	m_acTEncTop[layer].setWaveFrontSubstreams ( m_acLayerCfg[layer].m_iWaveFrontSubstreams );
291	m_acTEncTop[layer].setTMVPModeId ( m_TMVPModeId );
292	m_acTEncTop[layer].setUseScalingListId ( m_useScalingListId );
293	m_acTEncTop[layer].setScalingListFile ( m_scalingListFile );
294	m_acTEncTop[layer].setSignHideFlag(m_signHideFlag);
295	#if !REMOVE_ALF
296	m_acTEncTop[layer].setALFLowLatencyEncoding( m_alfLowLatencyEncoding );
297	#endif
298	m_acTEncTop[layer].setUseRateCtrl ( m_enableRateCtrl);
299	m_acTEncTop[layer].setTargetBitrate ( m_targetBitrate);
300	m_acTEncTop[layer].setNumLCUInUnit ( m_numLCUInUnit);
301	m_acTEncTop[layer].setTransquantBypassEnableFlag(m_TransquantBypassEnableFlag);
302	m_acTEncTop[layer].setCUTransquantBypassFlagValue(m_CUTransquantBypassFlagValue);
303	#if RECALCULATE_QP_ACCORDING_LAMBDA
304	m_acTEncTop[layer].setUseRecalculateQPAccordingToLambda( m_recalculateQPAccordingToLambda );
305	#endif
306	#if ACTIVE_PARAMETER_SETS_SEI_MESSAGE
307	m_acTEncTop[layer].setActiveParameterSetsSEIEnabled ( m_activeParameterSetsSEIEnabled );
308	#endif
309	#if SUPPORT_FOR_VUI
310	m_acTEncTop[layer].setVuiParametersPresentFlag( m_vuiParametersPresentFlag );
311	m_acTEncTop[layer].setAspectRatioIdc( m_aspectRatioIdc );
312	m_acTEncTop[layer].setSarWidth( m_sarWidth );
313	m_acTEncTop[layer].setSarHeight( m_sarHeight );
314	m_acTEncTop[layer].setOverscanInfoPresentFlag( m_overscanInfoPresentFlag );
315	m_acTEncTop[layer].setOverscanAppropriateFlag( m_overscanAppropriateFlag );
316	m_acTEncTop[layer].setVideoSignalTypePresentFlag( m_videoSignalTypePresentFlag );
317	m_acTEncTop[layer].setVideoFormat( m_videoFormat );
318	m_acTEncTop[layer].setVideoFullRangeFlag( m_videoFullRangeFlag );
319	m_acTEncTop[layer].setColourDescriptionPresentFlag( m_colourDescriptionPresentFlag );
320	m_acTEncTop[layer].setColourPrimaries( m_colourPrimaries );
321	m_acTEncTop[layer].setTransferCharacteristics( m_transferCharacteristics );
322	m_acTEncTop[layer].setMatrixCoefficients( m_matrixCoefficients );
323	m_acTEncTop[layer].setChromaLocInfoPresentFlag( m_chromaLocInfoPresentFlag );
324	m_acTEncTop[layer].setChromaSampleLocTypeTopField( m_chromaSampleLocTypeTopField );
325	m_acTEncTop[layer].setChromaSampleLocTypeBottomField( m_chromaSampleLocTypeBottomField );
326	m_acTEncTop[layer].setNeutralChromaIndicationFlag( m_neutralChromaIndicationFlag );
327	m_acTEncTop[layer].setBitstreamRestrictionFlag( m_bitstreamRestrictionFlag );
328	m_acTEncTop[layer].setTilesFixedStructureFlag( m_tilesFixedStructureFlag );
329	m_acTEncTop[layer].setMotionVectorsOverPicBoundariesFlag( m_motionVectorsOverPicBoundariesFlag );
330	m_acTEncTop[layer].setMaxBytesPerPicDenom( m_maxBytesPerPicDenom );
331	m_acTEncTop[layer].setMaxBitsPerMinCuDenom( m_maxBitsPerMinCuDenom );
332	m_acTEncTop[layer].setLog2MaxMvLengthHorizontal( m_log2MaxMvLengthHorizontal );
333	m_acTEncTop[layer].setLog2MaxMvLengthVertical( m_log2MaxMvLengthVertical );
334	#endif
335	#if REF_IDX_FRAMEWORK
336	m_acTEncTop[layer].setElRapSliceTypeB(layer == 0? 0 : m_elRapSliceBEnabled);
337	#endif
338	}
339	}
340	#else
341	Void TAppEncTop::xInitLibCfg()
342	{
343	TComVPS vps;
344
345	vps.setMaxTLayers ( m_maxTempLayer );
346	vps.setMaxLayers ( 1 );
347	for(Int i = 0; i < MAX_TLAYER; i++)
348	{
349	vps.setNumReorderPics ( m_numReorderPics[i], i );
350	vps.setMaxDecPicBuffering ( m_maxDecPicBuffering[i], i );
351	}
352	m_cTEncTop.setVPS(&vps);
353	m_cTEncTop.setFrameRate ( m_iFrameRate );
354	m_cTEncTop.setFrameSkip ( m_FrameSkip );
355	m_cTEncTop.setSourceWidth ( m_iSourceWidth );
356	m_cTEncTop.setSourceHeight ( m_iSourceHeight );
357	m_cTEncTop.setCroppingMode ( m_croppingMode );
358	m_cTEncTop.setCropLeft ( m_cropLeft );
359	m_cTEncTop.setCropRight ( m_cropRight );
360	m_cTEncTop.setCropTop ( m_cropTop );
361	m_cTEncTop.setCropBottom ( m_cropBottom );
362	m_cTEncTop.setFrameToBeEncoded ( m_iFrameToBeEncoded );
363
364	//====== Coding Structure ========
365	m_cTEncTop.setIntraPeriod ( m_iIntraPeriod );
366	m_cTEncTop.setDecodingRefreshType ( m_iDecodingRefreshType );
367	m_cTEncTop.setGOPSize ( m_iGOPSize );
368	m_cTEncTop.setGopList ( m_GOPList );
369	m_cTEncTop.setExtraRPSs ( m_extraRPSs );
370	for(Int i = 0; i < MAX_TLAYER; i++)
371	{
372	m_cTEncTop.setNumReorderPics ( m_numReorderPics[i], i );
373	m_cTEncTop.setMaxDecPicBuffering ( m_maxDecPicBuffering[i], i );
374	}
375	for( UInt uiLoop = 0; uiLoop < MAX_TLAYER; ++uiLoop )
376	{
377	m_cTEncTop.setLambdaModifier( uiLoop, m_adLambdaModifier[ uiLoop ] );
378	}
379	m_cTEncTop.setQP ( m_iQP );
380
381	m_cTEncTop.setPad ( m_aiPad );
382
383	m_cTEncTop.setMaxTempLayer ( m_maxTempLayer );
384	#if !REMOVE_NSQT
385	m_cTEncTop.setUseNSQT( m_enableNSQT );
386	#endif
387	m_cTEncTop.setUseAMP( m_enableAMP );
388
389	//===== Slice ========
390
391	//====== Loop/Deblock Filter ========
392	m_cTEncTop.setLoopFilterDisable ( m_bLoopFilterDisable );
393	m_cTEncTop.setLoopFilterOffsetInPPS ( m_loopFilterOffsetInPPS );
394	m_cTEncTop.setLoopFilterBetaOffset ( m_loopFilterBetaOffsetDiv2 );
395	m_cTEncTop.setLoopFilterTcOffset ( m_loopFilterTcOffsetDiv2 );
396	m_cTEncTop.setDeblockingFilterControlPresent( m_DeblockingFilterControlPresent);
397
398	//====== Motion search ========
399	m_cTEncTop.setFastSearch ( m_iFastSearch );
400	m_cTEncTop.setSearchRange ( m_iSearchRange );
401	m_cTEncTop.setBipredSearchRange ( m_bipredSearchRange );
402
403	//====== Quality control ========
404	m_cTEncTop.setMaxDeltaQP ( m_iMaxDeltaQP );
405	m_cTEncTop.setMaxCuDQPDepth ( m_iMaxCuDQPDepth );
406
407	m_cTEncTop.setChromaCbQpOffset ( m_cbQpOffset );
408	m_cTEncTop.setChromaCrQpOffset ( m_crQpOffset );
409
410	#if ADAPTIVE_QP_SELECTION
411	m_cTEncTop.setUseAdaptQpSelect ( m_bUseAdaptQpSelect );
412	#endif
413
414	Int lowestQP;
415	lowestQP = - ( (Int)(6*(g_uiBitDepth + g_uiBitIncrement - 8)) );
416
417	if ((m_iMaxDeltaQP == 0 ) && (m_iQP == lowestQP) && (m_useLossless == true))
418	{
419	m_bUseAdaptiveQP = false;
420	}
421	m_cTEncTop.setUseAdaptiveQP ( m_bUseAdaptiveQP );
422	m_cTEncTop.setQPAdaptationRange ( m_iQPAdaptationRange );
423
424	//====== Tool list ========
425	m_cTEncTop.setUseSBACRD ( m_bUseSBACRD );
426	m_cTEncTop.setDeltaQpRD ( m_uiDeltaQpRD );
427	m_cTEncTop.setUseASR ( m_bUseASR );
428	m_cTEncTop.setUseHADME ( m_bUseHADME );
429	#if !REMOVE_ALF
430	m_cTEncTop.setUseALF ( m_bUseALF );
431	#endif
432	m_cTEncTop.setUseLossless ( m_useLossless );
433	m_cTEncTop.setUseLComb ( m_bUseLComb );
434	m_cTEncTop.setdQPs ( m_aidQP );
435	m_cTEncTop.setUseRDOQ ( m_bUseRDOQ );
436	m_cTEncTop.setQuadtreeTULog2MaxSize ( m_uiQuadtreeTULog2MaxSize );
437	m_cTEncTop.setQuadtreeTULog2MinSize ( m_uiQuadtreeTULog2MinSize );
438	m_cTEncTop.setQuadtreeTUMaxDepthInter ( m_uiQuadtreeTUMaxDepthInter );
439	m_cTEncTop.setQuadtreeTUMaxDepthIntra ( m_uiQuadtreeTUMaxDepthIntra );
440	m_cTEncTop.setUseFastEnc ( m_bUseFastEnc );
441	m_cTEncTop.setUseEarlyCU ( m_bUseEarlyCU );
442	m_cTEncTop.setUseFastDecisionForMerge ( m_useFastDecisionForMerge );
443	m_cTEncTop.setUseCbfFastMode ( m_bUseCbfFastMode );
444	m_cTEncTop.setUseEarlySkipDetection ( m_useEarlySkipDetection );
445
446	#if !REMOVE_LMCHROMA
447	m_cTEncTop.setUseLMChroma ( m_bUseLMChroma );
448	#endif
449	m_cTEncTop.setUseTransformSkip ( m_useTransformSkip );
450	m_cTEncTop.setUseTransformSkipFast ( m_useTransformSkipFast );
451	m_cTEncTop.setUseConstrainedIntraPred ( m_bUseConstrainedIntraPred );
452	m_cTEncTop.setPCMLog2MinSize ( m_uiPCMLog2MinSize);
453	m_cTEncTop.setUsePCM ( m_usePCM );
454	m_cTEncTop.setPCMLog2MaxSize ( m_pcmLog2MaxSize);
455	m_cTEncTop.setMaxNumMergeCand ( m_maxNumMergeCand );
456
457
458	//====== Weighted Prediction ========
459	m_cTEncTop.setUseWP ( m_bUseWeightPred );
460	m_cTEncTop.setWPBiPred ( m_useWeightedBiPred );
461	//====== Parallel Merge Estimation ========
462	m_cTEncTop.setLog2ParallelMergeLevelMinus2 ( m_log2ParallelMergeLevel - 2 );
463
464	//====== Slice ========
465	m_cTEncTop.setSliceMode ( m_iSliceMode );
466	m_cTEncTop.setSliceArgument ( m_iSliceArgument );
467
468	//====== Dependent Slice ========
469	m_cTEncTop.setDependentSliceMode ( m_iDependentSliceMode );
470	m_cTEncTop.setDependentSliceArgument ( m_iDependentSliceArgument );
471	#if DEPENDENT_SLICES
472	#if TILES_WPP_ENTROPYSLICES_FLAGS
473	m_cTEncTop.setEntropySliceEnabledFlag ( m_entropySliceEnabledFlag );
474	#else
475	m_cTEncTop.setCabacIndependentFlag ( m_bCabacIndependentFlag );
476	#endif
477	#endif
478	int iNumPartInCU = 1<<(m_uiMaxCUDepth<<1);
479	if(m_iDependentSliceMode==SHARP_FIXED_NUMBER_OF_LCU_IN_DEPENDENT_SLICE)
480	{
481	#if REMOVE_FGS
482	m_cTEncTop.setDependentSliceArgument ( m_iDependentSliceArgument * iNumPartInCU );
483	#else
484	m_cTEncTop.setDependentSliceArgument ( m_iDependentSliceArgument * ( iNumPartInCU >> ( m_iSliceGranularity << 1 ) ) );
485	#endif
486	}
487	if(m_iSliceMode==AD_HOC_SLICES_FIXED_NUMBER_OF_LCU_IN_SLICE)
488	{
489	#if REMOVE_FGS
490	m_cTEncTop.setSliceArgument ( m_iSliceArgument * iNumPartInCU );
491	#else
492	m_cTEncTop.setSliceArgument ( m_iSliceArgument * ( iNumPartInCU >> ( m_iSliceGranularity << 1 ) ) );
493	#endif
494	}
495	if(m_iSliceMode==AD_HOC_SLICES_FIXED_NUMBER_OF_TILES_IN_SLICE)
496	{
497	m_cTEncTop.setSliceArgument ( m_iSliceArgument );
498	}
499
500	#if !REMOVE_FGS
501	m_cTEncTop.setSliceGranularity ( m_iSliceGranularity );
502	#endif
503	if(m_iSliceMode == 0 )
504	{
505	m_bLFCrossSliceBoundaryFlag = true;
506	}
507	m_cTEncTop.setLFCrossSliceBoundaryFlag( m_bLFCrossSliceBoundaryFlag );
508	m_cTEncTop.setUseSAO ( m_bUseSAO );
509	m_cTEncTop.setMaxNumOffsetsPerPic (m_maxNumOffsetsPerPic);
510
511	#if SAO_LCU_BOUNDARY
512	m_cTEncTop.setSaoLcuBoundary (m_saoLcuBoundary);
513	#endif
514	m_cTEncTop.setSaoLcuBasedOptimization (m_saoLcuBasedOptimization);
515	m_cTEncTop.setPCMInputBitDepthFlag ( m_bPCMInputBitDepthFlag);
516	m_cTEncTop.setPCMFilterDisableFlag ( m_bPCMFilterDisableFlag);
517
518	m_cTEncTop.setDecodedPictureHashSEIEnabled(m_decodePictureHashSEIEnabled);
519	#if RECOVERY_POINT_SEI
520	m_cTEncTop.setRecoveryPointSEIEnabled( m_recoveryPointSEIEnabled );
521	#endif
522	#if BUFFERING_PERIOD_AND_TIMING_SEI
523	m_cTEncTop.setBufferingPeriodSEIEnabled( m_bufferingPeriodSEIEnabled );
524	m_cTEncTop.setPictureTimingSEIEnabled( m_pictureTimingSEIEnabled );
525	#endif
526	m_cTEncTop.setUniformSpacingIdr ( m_iUniformSpacingIdr );
527	m_cTEncTop.setNumColumnsMinus1 ( m_iNumColumnsMinus1 );
528	m_cTEncTop.setNumRowsMinus1 ( m_iNumRowsMinus1 );
529	if(m_iUniformSpacingIdr==0)
530	{
531	m_cTEncTop.setColumnWidth ( m_pchColumnWidth );
532	m_cTEncTop.setRowHeight ( m_pchRowHeight );
533	}
534	m_cTEncTop.xCheckGSParameters();
535	Int uiTilesCount = (m_iNumRowsMinus1+1) * (m_iNumColumnsMinus1+1);
536	if(uiTilesCount == 1)
537	{
538	m_bLFCrossTileBoundaryFlag = true;
539	}
540	m_cTEncTop.setLFCrossTileBoundaryFlag( m_bLFCrossTileBoundaryFlag );
541	m_cTEncTop.setWaveFrontSynchro ( m_iWaveFrontSynchro );
542	m_cTEncTop.setWaveFrontSubstreams ( m_iWaveFrontSubstreams );
543	m_cTEncTop.setTMVPModeId ( m_TMVPModeId );
544	m_cTEncTop.setUseScalingListId ( m_useScalingListId );
545	m_cTEncTop.setScalingListFile ( m_scalingListFile );
546	m_cTEncTop.setSignHideFlag(m_signHideFlag);
547	#if !REMOVE_ALF
548	m_cTEncTop.setALFLowLatencyEncoding( m_alfLowLatencyEncoding );
549	#endif
550	m_cTEncTop.setUseRateCtrl ( m_enableRateCtrl);
551	m_cTEncTop.setTargetBitrate ( m_targetBitrate);
552	m_cTEncTop.setNumLCUInUnit ( m_numLCUInUnit);
553	m_cTEncTop.setTransquantBypassEnableFlag(m_TransquantBypassEnableFlag);
554	m_cTEncTop.setCUTransquantBypassFlagValue(m_CUTransquantBypassFlagValue);
555	#if RECALCULATE_QP_ACCORDING_LAMBDA
556	m_cTEncTop.setUseRecalculateQPAccordingToLambda( m_recalculateQPAccordingToLambda );
557	#endif
558	#if ACTIVE_PARAMETER_SETS_SEI_MESSAGE
559	m_cTEncTop.setActiveParameterSetsSEIEnabled ( m_activeParameterSetsSEIEnabled );
560	#endif
561	#if SUPPORT_FOR_VUI
562	m_cTEncTop.setVuiParametersPresentFlag( m_vuiParametersPresentFlag );
563	m_cTEncTop.setAspectRatioIdc( m_aspectRatioIdc );
564	m_cTEncTop.setSarWidth( m_sarWidth );
565	m_cTEncTop.setSarHeight( m_sarHeight );
566	m_cTEncTop.setOverscanInfoPresentFlag( m_overscanInfoPresentFlag );
567	m_cTEncTop.setOverscanAppropriateFlag( m_overscanAppropriateFlag );
568	m_cTEncTop.setVideoSignalTypePresentFlag( m_videoSignalTypePresentFlag );
569	m_cTEncTop.setVideoFormat( m_videoFormat );
570	m_cTEncTop.setVideoFullRangeFlag( m_videoFullRangeFlag );
571	m_cTEncTop.setColourDescriptionPresentFlag( m_colourDescriptionPresentFlag );
572	m_cTEncTop.setColourPrimaries( m_colourPrimaries );
573	m_cTEncTop.setTransferCharacteristics( m_transferCharacteristics );
574	m_cTEncTop.setMatrixCoefficients( m_matrixCoefficients );
575	m_cTEncTop.setChromaLocInfoPresentFlag( m_chromaLocInfoPresentFlag );
576	m_cTEncTop.setChromaSampleLocTypeTopField( m_chromaSampleLocTypeTopField );
577	m_cTEncTop.setChromaSampleLocTypeBottomField( m_chromaSampleLocTypeBottomField );
578	m_cTEncTop.setNeutralChromaIndicationFlag( m_neutralChromaIndicationFlag );
579	m_cTEncTop.setBitstreamRestrictionFlag( m_bitstreamRestrictionFlag );
580	m_cTEncTop.setTilesFixedStructureFlag( m_tilesFixedStructureFlag );
581	m_cTEncTop.setMotionVectorsOverPicBoundariesFlag( m_motionVectorsOverPicBoundariesFlag );
582	m_cTEncTop.setMaxBytesPerPicDenom( m_maxBytesPerPicDenom );
583	m_cTEncTop.setMaxBitsPerMinCuDenom( m_maxBitsPerMinCuDenom );
584	m_cTEncTop.setLog2MaxMvLengthHorizontal( m_log2MaxMvLengthHorizontal );
585	m_cTEncTop.setLog2MaxMvLengthVertical( m_log2MaxMvLengthVertical );
586	#endif
587	}
588	#endif
589
590	Void TAppEncTop::xCreateLib()
591	{
592	// Video I/O
593	#if SVC_EXTENSION
594	// initialize global variables
595	initROM();
596
597	for(UInt layer=0; layer<m_numLayers; layer++)
598	{
599	m_acTVideoIOYuvInputFile[layer].open( (char *)m_acLayerCfg[layer].getInputFile().c_str(), false, m_uiInputBitDepth, m_uiInternalBitDepth ); // read mode
600	m_acTVideoIOYuvInputFile[layer].skipFrames(m_FrameSkip, m_acLayerCfg[layer].getSourceWidth() - m_acLayerCfg[layer].getPad()[0], m_acLayerCfg[layer].getSourceHeight() - m_acLayerCfg[layer].getPad()[1]);
601
602	if (!m_acLayerCfg[layer].getReconFile().empty())
603	{
604	m_acTVideoIOYuvReconFile[layer].open((char *)m_acLayerCfg[layer].getReconFile().c_str(), true, m_uiOutputBitDepth, m_uiInternalBitDepth); // write mode
605	}
606
607	m_acTEncTop[layer].create();
608	}
609	#else
610	m_cTVideoIOYuvInputFile.open( m_pchInputFile, false, m_uiInputBitDepth, m_uiInternalBitDepth ); // read mode
611	m_cTVideoIOYuvInputFile.skipFrames(m_FrameSkip, m_iSourceWidth - m_aiPad[0], m_iSourceHeight - m_aiPad[1]);
612
613	if (m_pchReconFile)
614	m_cTVideoIOYuvReconFile.open(m_pchReconFile, true, m_uiOutputBitDepth, m_uiInternalBitDepth); // write mode
615
616	// Neo Decoder
617	m_cTEncTop.create();
618	#endif
619	}
620
621	Void TAppEncTop::xDestroyLib()
622	{
623	// Video I/O
624	#if SVC_EXTENSION
625	// destroy ROM
626	destroyROM();
627
628	for(UInt layer=0; layer<m_numLayers; layer++)
629	{
630	m_acTVideoIOYuvInputFile[layer].close();
631	m_acTVideoIOYuvReconFile[layer].close();
632
633	m_acTEncTop[layer].destroy();
634	}
635	#else
636	m_cTVideoIOYuvInputFile.close();
637	m_cTVideoIOYuvReconFile.close();
638
639	// Neo Decoder
640	m_cTEncTop.destroy();
641	#endif
642	}
643
644	Void TAppEncTop::xInitLib()
645	{
646	#if SVC_EXTENSION
647	for(UInt layer=0; layer<m_numLayers; layer++)
648	{
649	m_acTEncTop[layer].init();
650	}
651	#else
652	m_cTEncTop.init();
653	#endif
654	}
655
656	// ====================================================================================================================
657	// Public member functions
658	// ====================================================================================================================
659
660	/**
661	- create internal class
662	- initialize internal variable
663	- until the end of input YUV file, call encoding function in TEncTop class
664	- delete allocated buffers
665	- destroy internal class
666	.
667	*/
668	#if SVC_EXTENSION
669	Void TAppEncTop::encode()
670	{
671	fstream bitstreamFile(m_pchBitstreamFile, fstream::binary \| fstream::out);
672	if (!bitstreamFile)
673	{
674	fprintf(stderr, "\nfailed to open bitstream file `%s' for writing\n", m_pchBitstreamFile);
675	exit(EXIT_FAILURE);
676	}
677
678	TComPicYuv* pcPicYuvOrg [MAX_LAYERS];
679	TComPicYuv* pcPicYuvRec = NULL;
680
681	// initialize internal class & member variables
682
683	xInitLibCfg();
684	xCreateLib();
685	xInitLib();
686
687	// main encoder loop
688	Int iNumEncoded, iTotalNumEncoded;
689	Bool bEos = false, bBaseEos = false;
690
691	list<AccessUnit> outputAccessUnits; ///< list of access units to write out. is populated by the encoding process
692
693	for(UInt layer=0; layer<m_numLayers; layer++)
694	{
695	// allocate original YUV buffer
696	pcPicYuvOrg[layer] = new TComPicYuv;
697	#if SVC_UPSAMPLING
698	pcPicYuvOrg[layer]->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeight(), m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth, NULL );
699	#else
700	pcPicYuvOrg[layer]->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeight(), m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
701	#endif
702	}
703
704	Bool bFirstFrame = true;
705	while ( !bEos )
706	{
707	// Read enough frames
708	Bool bFramesReadyToCode = false;
709	while(!bFramesReadyToCode)
710	{
711	for(UInt layer=0; layer<m_numLayers; layer++)
712	{
713	// get buffers
714	xGetBuffer(pcPicYuvRec, layer);
715
716	m_acTVideoIOYuvInputFile[layer].read( pcPicYuvOrg[layer], m_acLayerCfg[layer].getPad() );
717
718	if(layer == m_numLayers-1)
719	{
720	// increase number of received frames
721	m_iFrameRcvd++;
722	// check end of file
723	bEos = ( m_acTVideoIOYuvInputFile[layer].isEof() == 1 ? true : bBaseEos? true : bEos );
724	bEos = ( m_iFrameRcvd == m_iFrameToBeEncoded ? true : bEos );
725	}
726	else
727	{
728	// check end of file of base layers
729	bBaseEos = ( m_acTVideoIOYuvInputFile[layer].isEof() == 1 ? true : bBaseEos );
730	}
731	m_acTEncTop[layer].encodePrep( bEos, pcPicYuvOrg[layer] );
732	}
733
734	bFramesReadyToCode = !(!bFirstFrame && ( m_acTEncTop[m_numLayers-1].getNumPicRcvd() != m_iGOPSize && m_iGOPSize ) && !bEos );
735	}
736
737	// loop through frames in one GOP
738	for ( UInt iPicIdInGOP=0; iPicIdInGOP < (bFirstFrame? 1:m_iGOPSize); iPicIdInGOP++ )
739	{
740	// layer by layer for each frame
741	for(UInt layer=0; layer<m_numLayers; layer++)
742	{
743	// call encoding function for one frame
744	m_acTEncTop[layer].encode( pcPicYuvOrg[layer], m_acListPicYuvRec[layer],
745	outputAccessUnits, iPicIdInGOP );
746	}
747	}
748
749	iTotalNumEncoded = 0;
750	for(UInt layer=0; layer<m_numLayers; layer++)
751	{
752	// write bistream to file if necessary
753	iNumEncoded = m_acTEncTop[layer].getNumPicRcvd();
754	if ( iNumEncoded > 0 )
755	{
756	xWriteRecon(layer, iNumEncoded);
757	iTotalNumEncoded += iNumEncoded;
758	}
759	m_acTEncTop[layer].setNumPicRcvd( 0 );
760	}
761
762	// write bitstream out
763	if(iTotalNumEncoded)
764	{
765	xWriteStream(bitstreamFile, iTotalNumEncoded, outputAccessUnits);
766	outputAccessUnits.clear();
767	}
768
769	// print out summary
770	if (bEos)
771	{
772	printOutSummary();
773	}
774
775	bFirstFrame = false;
776	}
777
778	// delete original YUV buffer
779	for(UInt layer=0; layer<m_numLayers; layer++)
780	{
781	pcPicYuvOrg[layer]->destroy();
782	delete pcPicYuvOrg[layer];
783	pcPicYuvOrg[layer] = NULL;
784
785	// delete used buffers in encoder class
786	m_acTEncTop[layer].deletePicBuffer();
787	}
788
789	// delete buffers & classes
790	xDeleteBuffer();
791	xDestroyLib();
792
793	printRateSummary();
794
795	return;
796	}
797
798
799	Void TAppEncTop::printOutSummary()
800	{
801	UInt layer;
802
803	// set frame rate
804	for(layer = 0; layer < m_numLayers; layer++)
805	{
806	m_gcAnalyzeAll[layer].setFrmRate( m_acLayerCfg[layer].getFrameRate());
807	m_gcAnalyzeI[layer].setFrmRate( m_acLayerCfg[layer].getFrameRate() );
808	m_gcAnalyzeP[layer].setFrmRate( m_acLayerCfg[layer].getFrameRate() );
809	m_gcAnalyzeB[layer].setFrmRate( m_acLayerCfg[layer].getFrameRate() );
810	}
811
812	//-- all
813	printf( "\n\nSUMMARY --------------------------------------------------------\n" );
814	printf( "\tTotal Frames \| " "Bitrate " "Y-PSNR " "U-PSNR " "V-PSNR \n" );
815	for(layer = 0; layer < m_numLayers; layer++)
816	{
817	m_gcAnalyzeAll[layer].printOut('a', layer);
818	}
819
820	printf( "\n\nI Slices--------------------------------------------------------\n" );
821	printf( "\tTotal Frames \| " "Bitrate " "Y-PSNR " "U-PSNR " "V-PSNR \n" );
822	for(layer = 0; layer < m_numLayers; layer++)
823	{
824	m_gcAnalyzeI[layer].printOut('i', layer);
825	}
826
827	printf( "\n\nP Slices--------------------------------------------------------\n" );
828	printf( "\tTotal Frames \| " "Bitrate " "Y-PSNR " "U-PSNR " "V-PSNR \n" );
829	for(layer = 0; layer < m_numLayers; layer++)
830	{
831	m_gcAnalyzeP[layer].printOut('p', layer);
832	}
833
834	printf( "\n\nB Slices--------------------------------------------------------\n" );
835	printf( "\tTotal Frames \| " "Bitrate " "Y-PSNR " "U-PSNR " "V-PSNR \n" );
836	for(layer = 0; layer < m_numLayers; layer++)
837	{
838	m_gcAnalyzeB[layer].printOut('b', layer);
839	}
840	}
841
842	#else
843	Void TAppEncTop::encode()
844	{
845	fstream bitstreamFile(m_pchBitstreamFile, fstream::binary \| fstream::out);
846	if (!bitstreamFile)
847	{
848	fprintf(stderr, "\nfailed to open bitstream file `%s' for writing\n", m_pchBitstreamFile);
849	exit(EXIT_FAILURE);
850	}
851
852	TComPicYuv* pcPicYuvOrg = new TComPicYuv;
853	TComPicYuv* pcPicYuvRec = NULL;
854
855	// initialize internal class & member variables
856	xInitLibCfg();
857	xCreateLib();
858	xInitLib();
859
860	// main encoder loop
861	Int iNumEncoded = 0;
862	Bool bEos = false;
863
864	list<AccessUnit> outputAccessUnits; ///< list of access units to write out. is populated by the encoding process
865
866	// allocate original YUV buffer
867	pcPicYuvOrg->create( m_iSourceWidth, m_iSourceHeight, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
868
869	while ( !bEos )
870	{
871	// get buffers
872	xGetBuffer(pcPicYuvRec);
873
874	// read input YUV file
875	m_cTVideoIOYuvInputFile.read( pcPicYuvOrg, m_aiPad );
876
877	// increase number of received frames
878	m_iFrameRcvd++;
879
880	// check end of file
881	bEos = ( m_cTVideoIOYuvInputFile.isEof() == 1 ? true : false );
882	bEos = ( m_iFrameRcvd == m_iFrameToBeEncoded ? true : bEos );
883
884	// call encoding function for one frame
885	m_cTEncTop.encode( bEos, pcPicYuvOrg, m_cListPicYuvRec, outputAccessUnits, iNumEncoded );
886
887	// write bistream to file if necessary
888	if ( iNumEncoded > 0 )
889	{
890	xWriteOutput(bitstreamFile, iNumEncoded, outputAccessUnits);
891	outputAccessUnits.clear();
892	}
893	}
894	// delete original YUV buffer
895	pcPicYuvOrg->destroy();
896	delete pcPicYuvOrg;
897	pcPicYuvOrg = NULL;
898
899	// delete used buffers in encoder class
900	m_cTEncTop.deletePicBuffer();
901
902	// delete buffers & classes
903	xDeleteBuffer();
904	xDestroyLib();
905
906	printRateSummary();
907
908	return;
909	}
910	#endif
911
912	// ====================================================================================================================
913	// Protected member functions
914	// ====================================================================================================================
915
916	/**
917	- application has picture buffer list with size of GOP
918	- picture buffer list acts as ring buffer
919	- end of the list has the latest picture
920	.
921	*/
922	#if SVC_EXTENSION
923	Void TAppEncTop::xGetBuffer( TComPicYuv*& rpcPicYuvRec, UInt layer)
924	{
925	assert( m_iGOPSize > 0 );
926
927	// org. buffer
928	if ( m_acListPicYuvRec[layer].size() == (UInt)m_iGOPSize )
929	{
930	rpcPicYuvRec = m_acListPicYuvRec[layer].popFront();
931
932	}
933	else
934	{
935	rpcPicYuvRec = new TComPicYuv;
936
937	#if SVC_UPSAMPLING
938	rpcPicYuvRec->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeight(), m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth, NULL );
939	#else
940	rpcPicYuvRec->create( m_acLayerCfg[layer].getSourceWidth(), m_acLayerCfg[layer].getSourceHeight(), m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
941	#endif
942
943	}
944	m_acListPicYuvRec[layer].pushBack( rpcPicYuvRec );
945	}
946
947	Void TAppEncTop::xDeleteBuffer( )
948	{
949	for(UInt layer=0; layer<m_numLayers; layer++)
950	{
951	TComList<TComPicYuv*>::iterator iterPicYuvRec = m_acListPicYuvRec[layer].begin();
952
953	Int iSize = Int( m_acListPicYuvRec[layer].size() );
954
955	for ( Int i = 0; i < iSize; i++ )
956	{
957	TComPicYuv* pcPicYuvRec = *(iterPicYuvRec++);
958	pcPicYuvRec->destroy();
959	delete pcPicYuvRec; pcPicYuvRec = NULL;
960	}
961	}
962	}
963
964
965
966	Void TAppEncTop::xWriteRecon(UInt layer, Int iNumEncoded)
967	{
968	Int i;
969
970	TComList<TComPicYuv*>::iterator iterPicYuvRec = m_acListPicYuvRec[layer].end();
971
972	for ( i = 0; i < iNumEncoded; i++ )
973	{
974	--iterPicYuvRec;
975	}
976
977	for ( i = 0; i < iNumEncoded; i++ )
978	{
979	TComPicYuv* pcPicYuvRec = *(iterPicYuvRec++);
980	if (!m_acLayerCfg[layer].getReconFile().empty())
981	{
982	m_acTVideoIOYuvReconFile[layer].write( pcPicYuvRec, m_acLayerCfg[layer].getCropLeft(), m_acLayerCfg[layer].getCropRight(),
983	m_acLayerCfg[layer].getCropTop(), m_acLayerCfg[layer].getCropBottom() );
984	}
985	}
986	}
987
988
989	Void TAppEncTop::xWriteStream(std::ostream& bitstreamFile, Int iNumEncoded, const std::list<AccessUnit>& accessUnits)
990	{
991	Int i;
992
993	list<AccessUnit>::const_iterator iterBitstream = accessUnits.begin();
994
995	for ( i = 0; i < iNumEncoded; i++ )
996	{
997	const AccessUnit& au = *(iterBitstream++);
998	const vector<unsigned>& stats = writeAnnexB(bitstreamFile, au);
999	rateStatsAccum(au, stats);
1000	}
1001	}
1002
1003	#else // SVC_EXTENSION
1004	Void TAppEncTop::xGetBuffer( TComPicYuv*& rpcPicYuvRec)
1005	{
1006	assert( m_iGOPSize > 0 );
1007
1008	// org. buffer
1009	if ( m_cListPicYuvRec.size() == (UInt)m_iGOPSize )
1010	{
1011	rpcPicYuvRec = m_cListPicYuvRec.popFront();
1012
1013	}
1014	else
1015	{
1016	rpcPicYuvRec = new TComPicYuv;
1017
1018	rpcPicYuvRec->create( m_iSourceWidth, m_iSourceHeight, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
1019
1020	}
1021	m_cListPicYuvRec.pushBack( rpcPicYuvRec );
1022	}
1023
1024	Void TAppEncTop::xDeleteBuffer( )
1025	{
1026	TComList<TComPicYuv*>::iterator iterPicYuvRec = m_cListPicYuvRec.begin();
1027
1028	Int iSize = Int( m_cListPicYuvRec.size() );
1029
1030	for ( Int i = 0; i < iSize; i++ )
1031	{
1032	TComPicYuv* pcPicYuvRec = *(iterPicYuvRec++);
1033	pcPicYuvRec->destroy();
1034	delete pcPicYuvRec; pcPicYuvRec = NULL;
1035	}
1036
1037	}
1038
1039	/** \param iNumEncoded number of encoded frames
1040	*/
1041	Void TAppEncTop::xWriteOutput(std::ostream& bitstreamFile, Int iNumEncoded, const std::list<AccessUnit>& accessUnits)
1042	{
1043	Int i;
1044
1045	TComList<TComPicYuv*>::iterator iterPicYuvRec = m_cListPicYuvRec.end();
1046	list<AccessUnit>::const_iterator iterBitstream = accessUnits.begin();
1047
1048	for ( i = 0; i < iNumEncoded; i++ )
1049	{
1050	--iterPicYuvRec;
1051	}
1052
1053	for ( i = 0; i < iNumEncoded; i++ )
1054	{
1055	TComPicYuv* pcPicYuvRec = *(iterPicYuvRec++);
1056	if (m_pchReconFile)
1057	{
1058	m_cTVideoIOYuvReconFile.write( pcPicYuvRec, m_cropLeft, m_cropRight, m_cropTop, m_cropBottom );
1059	}
1060
1061	const AccessUnit& au = *(iterBitstream++);
1062	const vector<unsigned>& stats = writeAnnexB(bitstreamFile, au);
1063	rateStatsAccum(au, stats);
1064	}
1065	}
1066	#endif
1067
1068	/**
1069	*
1070	*/
1071	void TAppEncTop::rateStatsAccum(const AccessUnit& au, const std::vector<unsigned>& annexBsizes)
1072	{
1073	AccessUnit::const_iterator it_au = au.begin();
1074	vector<unsigned>::const_iterator it_stats = annexBsizes.begin();
1075
1076	for (; it_au != au.end(); it_au++, it_stats++)
1077	{
1078	switch ((*it_au)->m_nalUnitType)
1079	{
1080	#if NAL_UNIT_TYPES_J1003_D7
1081	case NAL_UNIT_CODED_SLICE_TRAIL_R:
1082	case NAL_UNIT_CODED_SLICE_TRAIL_N:
1083	case NAL_UNIT_CODED_SLICE_TLA:
1084	case NAL_UNIT_CODED_SLICE_TSA_N:
1085	case NAL_UNIT_CODED_SLICE_STSA_R:
1086	case NAL_UNIT_CODED_SLICE_STSA_N:
1087	case NAL_UNIT_CODED_SLICE_BLA:
1088	case NAL_UNIT_CODED_SLICE_BLANT:
1089	case NAL_UNIT_CODED_SLICE_BLA_N_LP:
1090	case NAL_UNIT_CODED_SLICE_IDR:
1091	case NAL_UNIT_CODED_SLICE_IDR_N_LP:
1092	case NAL_UNIT_CODED_SLICE_CRA:
1093	case NAL_UNIT_CODED_SLICE_DLP:
1094	case NAL_UNIT_CODED_SLICE_TFD:
1095	#else
1096	case NAL_UNIT_CODED_SLICE:
1097	case NAL_UNIT_CODED_SLICE_TFD:
1098	case NAL_UNIT_CODED_SLICE_TLA:
1099	case NAL_UNIT_CODED_SLICE_CRA:
1100	case NAL_UNIT_CODED_SLICE_CRANT:
1101	case NAL_UNIT_CODED_SLICE_BLA:
1102	case NAL_UNIT_CODED_SLICE_BLANT:
1103	case NAL_UNIT_CODED_SLICE_IDR:
1104	#endif
1105	case NAL_UNIT_VPS:
1106	case NAL_UNIT_SPS:
1107	case NAL_UNIT_PPS:
1108	m_essentialBytes += *it_stats;
1109	break;
1110	default:
1111	break;
1112	}
1113
1114	m_totalBytes += *it_stats;
1115	}
1116	}
1117
1118	void TAppEncTop::printRateSummary()
1119	{
1120	#if SVC_EXTENSION
1121	double time = (double) m_iFrameRcvd / m_acLayerCfg[m_numLayers-1].getFrameRate();
1122	#else
1123	double time = (double) m_iFrameRcvd / m_iFrameRate;
1124	#endif
1125	printf("Bytes written to file: %u (%.3f kbps)\n", m_totalBytes, 0.008 * m_totalBytes / time);
1126	#if VERBOSE_RATE
1127	printf("Bytes for SPS/PPS/Slice (Incl. Annex B): %u (%.3f kbps)\n", m_essentialBytes, 0.008 * m_essentialBytes / time);
1128	#endif
1129	}
1130
1131	//! \}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: