Context navigation

source: SHVCSoftware/branches/SHM-upgrade/source/App/TAppEncoder/TAppEncTop.cpp @ 915

Visit:

Last change on this file since 915 was 912, checked in by seregin, 10 years ago
Overlay SEI with macro Q0096_OVERLAY_SEI, patch was provided by Nikolce Stefanoski <stefanos@…>
Property svn:eol-style set to `native`
File size: 113.3 KB

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

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

Download in other formats: