Context navigation

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

Visit:

Last change on this file since 1501 was 1501, checked in by seregin, 8 years ago
move rep format index check after auto rep format index derivation
Property svn:eol-style set to `native`
File size: 100.1 KB

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

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

Download in other formats: