Context navigation

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

Visit:

Last change on this file since 1365 was 1356, checked in by seregin, 10 years ago
port rev 4434
Property svn:eol-style set to `native`
File size: 120.0 KB

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

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

Download in other formats: