Context navigation

TAppEncTop.cpp @ 1399

Visit:

Last change on this file since 1399 was 1305, checked in by tech, 10 years ago
Further fixes and alignments.
Property svn:eol-style set to `native`
File size: 98.5 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	#include <iomanip>
45
46	#include "TAppEncTop.h"
47	#include "TLibEncoder/AnnexBwrite.h"
48
49	using namespace std;
50
51	//! \ingroup TAppEncoder
52	//! \{
53
54	// ====================================================================================================================
55	// Constructor / destructor / initialization / destroy
56	// ====================================================================================================================
57
58	TAppEncTop::TAppEncTop()
59	{
60
61	#if NH_MV
62	m_vps = new TComVPS;
63	#else
64	m_iFrameRcvd = 0;
65	#endif
66	m_totalBytes = 0;
67	m_essentialBytes = 0;
68	}
69
70	TAppEncTop::~TAppEncTop()
71	{
72	#if NH_MV
73	if (m_vps)
74	{
75	delete m_vps;
76	};
77	#endif
78
79	}
80
81	Void TAppEncTop::xInitLibCfg()
82	{
83	#if NH_MV
84	TComVPS& vps = (*m_vps);
85	#else
86	TComVPS vps;
87	#endif
88
89	#if NH_3D
90	vps.createCamPars(m_iNumberOfViews);
91	#endif
92
93	#if NH_3D_DLT
94	TComDLT dlt = TComDLT();
95	#endif
96
97	#if NH_MV
98	Int maxTempLayer = -1;
99	for (Int j = 0; j < m_numberOfLayers; j++)
100	{
101	maxTempLayer = max( m_maxTempLayerMvc[ j ], maxTempLayer );
102	}
103
104	vps.setMaxTLayers ( maxTempLayer );
105	if ( maxTempLayer )
106	{
107	vps.setTemporalNestingFlag(true);
108	}
109	vps.setMaxLayersMinus1( m_numberOfLayers - 1);
110	for(Int i = 0; i < MAX_TLAYER; i++)
111	{
112	Int maxNumReOrderPics = 0;
113	Int maxDecPicBuffering = 0;
114	for (Int j = 0; j < m_numberOfLayers; j++)
115	{
116	maxNumReOrderPics = max( maxNumReOrderPics, m_numReorderPicsMvc [ j ][ i ] );
117	maxDecPicBuffering = max( maxDecPicBuffering, m_maxDecPicBufferingMvc[ j ][ i ] );
118	}
119
120	vps.setNumReorderPics ( maxNumReOrderPics ,i );
121	vps.setMaxDecPicBuffering ( maxDecPicBuffering ,i );
122	}
123	#else
124	vps.setMaxTLayers ( m_maxTempLayer );
125	if (m_maxTempLayer == 1)
126	{
127	vps.setTemporalNestingFlag(true);
128	}
129	vps.setMaxLayers ( 1 );
130	for(Int i = 0; i < MAX_TLAYER; i++)
131	{
132	vps.setNumReorderPics ( m_numReorderPics[i], i );
133	vps.setMaxDecPicBuffering ( m_maxDecPicBuffering[i], i );
134	}
135	#endif
136	#if NH_MV
137	xSetTimingInfo ( vps );
138	xSetHrdParameters ( vps );
139	xSetLayerIds ( vps );
140	xSetDimensionIdAndLength ( vps );
141	xSetDependencies ( vps );
142	xSetRepFormat ( vps );
143	xSetProfileTierLevel ( vps );
144	xSetLayerSets ( vps );
145	xSetDpbSize ( vps );
146	xSetVPSVUI ( vps );
147	#if NH_3D
148	xSetCamPara ( vps );
149	m_ivPicLists.setVPS ( &vps );
150	#endif
151	#if NH_3D_DLT
152	xDeriveDltArray ( vps, &dlt );
153	#endif
154	if ( m_targetEncLayerIdList.size() == 0 )
155	{
156	for (Int i = 0; i < m_numberOfLayers; i++ )
157	{
158	m_targetEncLayerIdList.push_back( vps.getLayerIdInNuh( i ) );
159	}
160	}
161	for( Int i = (Int) m_targetEncLayerIdList.size()-1 ; i >= 0 ; i--)
162	{
163	Int iNuhLayerId = m_targetEncLayerIdList[i];
164	Bool allRefLayersPresent = true;
165	for( Int j = 0; j < vps.getNumRefLayers( iNuhLayerId ); j++)
166	{
167	allRefLayersPresent = allRefLayersPresent && xLayerIdInTargetEncLayerIdList( vps.getIdRefLayer( iNuhLayerId, j) );
168	}
169	if ( !allRefLayersPresent )
170	{
171	printf("\nCannot encode layer with nuh_layer_id equal to %d since not all reference layers are in TargetEncLayerIdList\n", iNuhLayerId);
172	m_targetEncLayerIdList.erase( m_targetEncLayerIdList.begin() + i );
173	}
174	}
175
176	if ( m_outputVpsInfo )
177	{
178	vps.printScalabilityId();
179	vps.printLayerDependencies();
180	vps.printLayerSets();
181	vps.printPTL();
182	}
183
184	#if NH_3D
185	// Set 3d tool parameters
186	for (Int d = 0; d < 2; d++)
187	{
188	m_sps3dExtension.setIvMvPredFlag ( d, m_ivMvPredFlag[d] );
189	m_sps3dExtension.setIvMvScalingFlag ( d, m_ivMvScalingFlag[d] );
190	if (d == 0 )
191	{
192	m_sps3dExtension.setLog2SubPbSizeMinus3 ( d, m_log2SubPbSizeMinus3 );
193	m_sps3dExtension.setIvResPredFlag ( d, m_ivResPredFlag );
194	m_sps3dExtension.setDepthRefinementFlag ( d, m_depthRefinementFlag );
195	m_sps3dExtension.setViewSynthesisPredFlag ( d, m_viewSynthesisPredFlag );
196	m_sps3dExtension.setDepthBasedBlkPartFlag ( d, m_depthBasedBlkPartFlag );
197	}
198	else
199	{
200	m_sps3dExtension.setMpiFlag ( d, m_mpiFlag );
201	m_sps3dExtension.setLog2MpiSubPbSizeMinus3( d, m_log2MpiSubPbSizeMinus3);
202	m_sps3dExtension.setIntraContourFlag ( d, m_intraContourFlag );
203	m_sps3dExtension.setIntraSdcWedgeFlag ( d, m_intraSdcFlag \|\| m_intraWedgeFlag );
204	m_sps3dExtension.setQtPredFlag ( d, m_qtPredFlag );
205	m_sps3dExtension.setInterSdcFlag ( d, m_interSdcFlag );
206	m_sps3dExtension.setDepthIntraSkipFlag ( d, m_depthIntraSkipFlag );
207	}
208	}
209	#endif
210
211
212	/// Create encoders and set profiles profiles
213	for(Int layerIdInVps = 0; layerIdInVps < m_numberOfLayers; layerIdInVps++)
214	{
215	m_frameRcvd .push_back(0);
216	m_acTEncTopList .push_back(new TEncTop);
217	m_acTVideoIOYuvInputFileList.push_back(new TVideoIOYuv);
218	m_acTVideoIOYuvReconFileList.push_back(new TVideoIOYuv);
219	#if NH_3D
220	Int profileIdc = -1;
221	for (Int olsIdx = 0; olsIdx < vps.getNumOutputLayerSets(); olsIdx++ )
222	{
223	Int lsIdx = vps.olsIdxToLsIdx( olsIdx );
224	for(Int i = 0; i < vps.getNumLayersInIdList( lsIdx ); i++ )
225	{
226	if( vps.getLayerIdInNuh( layerIdInVps) == vps.getLayerSetLayerIdList(lsIdx, i) )
227	{
228	Int ptlIdx = vps.getProfileTierLevelIdx( olsIdx, i );
229	if ( ptlIdx != -1 )
230	{
231	Int curProfileIdc = vps.getPTL(ptlIdx)->getGeneralPTL()->getProfileIdc();
232	if (profileIdc == -1)
233	{
234	profileIdc = curProfileIdc;
235	}
236	else
237	{
238	if ( profileIdc != curProfileIdc )
239	{
240	fprintf(stderr, "Error: ProfileIdc for layer with index %d in VPS not equal in all OLSs. \n", layerIdInVps );
241	exit(EXIT_FAILURE);
242	}
243	}
244	}
245	}
246	}
247	}
248
249	if (profileIdc == -1 )
250	{
251	fprintf(stderr, "Error: No profile given for layer with index %d in VPS not equal in all OLS. \n", layerIdInVps );
252	exit(EXIT_FAILURE);
253	}
254	m_acTEncTopList[ layerIdInVps ]->setProfileIdc( profileIdc );
255	#endif
256	}
257
258
259	for(Int layerIdInVps = 0; layerIdInVps < m_numberOfLayers; layerIdInVps++)
260	{
261	m_cListPicYuvRec .push_back(new TComList<TComPicYuv*>) ;
262	m_ivPicLists.push_back( m_acTEncTopList[ layerIdInVps ]->getListPic() );
263	TEncTop& m_cTEncTop = *m_acTEncTopList[ layerIdInVps ]; // It is not a member, but this name helps avoiding code duplication !!!
264
265	Int layerId = vps.getLayerIdInNuh( layerIdInVps );
266	m_cTEncTop.setLayerIdInVps ( layerIdInVps );
267	m_cTEncTop.setLayerId ( layerId );
268	m_cTEncTop.setViewId ( vps.getViewId ( layerId ) );
269	m_cTEncTop.setViewIndex ( vps.getViewIndex ( layerId ) );
270	#if NH_3D
271	Bool isDepth = ( vps.getDepthId ( layerId ) != 0 ) ;
272	m_cTEncTop.setIsDepth ( isDepth );
273	//====== Camera Parameters =========
274	m_cTEncTop.setCameraParameters ( &m_cCameraData );
275	#if NH_3D_VSO
276	//====== VSO =========
277	m_cTEncTop.setRenderModelParameters ( &m_cRenModStrParser );
278	m_cTEncTop.setForceLambdaScaleVSO ( isDepth ? m_bForceLambdaScaleVSO : false );
279	m_cTEncTop.setLambdaScaleVSO ( isDepth ? m_dLambdaScaleVSO : 1 );
280	m_cTEncTop.setVSOMode ( isDepth ? m_uiVSOMode : 0 );
281
282	m_cTEncTop.setAllowNegDist ( isDepth ? m_bAllowNegDist : false );
283
284	// SAIT_VSO_EST_A0033
285	m_cTEncTop.setUseEstimatedVSD ( isDepth ? m_bUseEstimatedVSD : false );
286
287	// LGE_WVSO_A0119
288	m_cTEncTop.setUseWVSO ( isDepth ? m_bUseWVSO : false );
289	m_cTEncTop.setVSOWeight ( isDepth ? m_iVSOWeight : 0 );
290	m_cTEncTop.setVSDWeight ( isDepth ? m_iVSDWeight : 0 );
291	m_cTEncTop.setDWeight ( isDepth ? m_iDWeight : 0 );
292	#endif // H_3D_VSO
293	#if NH_3D_IC
294	m_cTEncTop.setUseIC ( vps.getViewIndex( layerId ) == 0 \|\| isDepth ? false : m_abUseIC );
295	m_cTEncTop.setUseICLowLatencyEnc ( m_bUseLowLatencyICEnc );
296	#endif
297
298
299	m_cTEncTop.setUseDMM ( isDepth ? m_intraWedgeFlag : false );
300	m_cTEncTop.setUseSDC ( isDepth ? m_intraSdcFlag : false );
301	m_cTEncTop.setUseDLT ( isDepth ? m_useDLT : false );
302	m_cTEncTop.setUseQTL ( isDepth ? m_bUseQTL : false );
303	m_cTEncTop.setSps3dExtension ( m_sps3dExtension );
304	#endif // NH_3D
305
306	m_cTEncTop.setIvPicLists ( &m_ivPicLists );
307	#endif // NH_MV
308	m_cTEncTop.setVPS(&vps);
309
310	#if NH_3D_DLT
311	m_cTEncTop.setDLT(dlt);
312	#endif
313
314	#if NH_MV
315	m_cTEncTop.setProfile ( m_profiles[0]);
316	m_cTEncTop.setLevel ( m_levelTier[0], m_level[0] );
317	#else
318	m_cTEncTop.setProfile ( m_profile);
319	m_cTEncTop.setLevel ( m_levelTier, m_level);
320	#endif
321	m_cTEncTop.setProgressiveSourceFlag ( m_progressiveSourceFlag);
322	m_cTEncTop.setInterlacedSourceFlag ( m_interlacedSourceFlag);
323	m_cTEncTop.setNonPackedConstraintFlag ( m_nonPackedConstraintFlag);
324	m_cTEncTop.setFrameOnlyConstraintFlag ( m_frameOnlyConstraintFlag);
325	m_cTEncTop.setBitDepthConstraintValue ( m_bitDepthConstraint );
326	m_cTEncTop.setChromaFormatConstraintValue ( m_chromaFormatConstraint );
327	m_cTEncTop.setIntraConstraintFlag ( m_intraConstraintFlag );
328	m_cTEncTop.setOnePictureOnlyConstraintFlag ( m_onePictureOnlyConstraintFlag );
329	m_cTEncTop.setLowerBitRateConstraintFlag ( m_lowerBitRateConstraintFlag );
330
331	m_cTEncTop.setPrintMSEBasedSequencePSNR ( m_printMSEBasedSequencePSNR);
332	m_cTEncTop.setPrintFrameMSE ( m_printFrameMSE);
333	m_cTEncTop.setPrintSequenceMSE ( m_printSequenceMSE);
334	m_cTEncTop.setCabacZeroWordPaddingEnabled ( m_cabacZeroWordPaddingEnabled );
335
336	m_cTEncTop.setFrameRate ( m_iFrameRate );
337	m_cTEncTop.setFrameSkip ( m_FrameSkip );
338	m_cTEncTop.setSourceWidth ( m_iSourceWidth );
339	m_cTEncTop.setSourceHeight ( m_iSourceHeight );
340	m_cTEncTop.setConformanceWindow ( m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom );
341	m_cTEncTop.setFramesToBeEncoded ( m_framesToBeEncoded );
342
343	//====== Coding Structure ========
344	#if NH_MV
345	m_cTEncTop.setIntraPeriod ( m_iIntraPeriod[ layerIdInVps ] );
346	#else
347	m_cTEncTop.setIntraPeriod ( m_iIntraPeriod );
348	#endif
349	m_cTEncTop.setDecodingRefreshType ( m_iDecodingRefreshType );
350	m_cTEncTop.setGOPSize ( m_iGOPSize );
351	#if NH_MV
352	m_cTEncTop.setGopList ( m_GOPListMvc[layerIdInVps] );
353	m_cTEncTop.setExtraRPSs ( m_extraRPSsMvc[layerIdInVps] );
354	for(Int i = 0; i < MAX_TLAYER; i++)
355	{
356	m_cTEncTop.setNumReorderPics ( m_numReorderPicsMvc[layerIdInVps][i], i );
357	m_cTEncTop.setMaxDecPicBuffering ( m_maxDecPicBufferingMvc[layerIdInVps][i], i );
358	}
359	#else
360	m_cTEncTop.setGopList ( m_GOPList );
361	m_cTEncTop.setExtraRPSs ( m_extraRPSs );
362	for(Int i = 0; i < MAX_TLAYER; i++)
363	{
364	m_cTEncTop.setNumReorderPics ( m_numReorderPics[i], i );
365	m_cTEncTop.setMaxDecPicBuffering ( m_maxDecPicBuffering[i], i );
366	}
367	#endif
368	for( UInt uiLoop = 0; uiLoop < MAX_TLAYER; ++uiLoop )
369	{
370	m_cTEncTop.setLambdaModifier ( uiLoop, m_adLambdaModifier[ uiLoop ] );
371	}
372	#if NH_MV
373	m_cTEncTop.setQP ( m_iQP[layerIdInVps] );
374	#else
375	m_cTEncTop.setQP ( m_iQP );
376	#endif
377
378	m_cTEncTop.setPad ( m_aiPad );
379
380	#if NH_MV
381	m_cTEncTop.setMaxTempLayer ( m_maxTempLayerMvc[layerIdInVps] );
382	#else
383	m_cTEncTop.setMaxTempLayer ( m_maxTempLayer );
384	#endif
385	m_cTEncTop.setUseAMP( m_enableAMP );
386
387	//===== Slice ========
388
389	//====== Loop/Deblock Filter ========
390	#if NH_MV
391	m_cTEncTop.setLoopFilterDisable ( m_bLoopFilterDisable[layerIdInVps]);
392	#else
393	m_cTEncTop.setLoopFilterDisable ( m_bLoopFilterDisable );
394	#endif
395	m_cTEncTop.setLoopFilterOffsetInPPS ( m_loopFilterOffsetInPPS );
396	m_cTEncTop.setLoopFilterBetaOffset ( m_loopFilterBetaOffsetDiv2 );
397	m_cTEncTop.setLoopFilterTcOffset ( m_loopFilterTcOffsetDiv2 );
398	m_cTEncTop.setDeblockingFilterMetric ( m_DeblockingFilterMetric );
399
400	//====== Motion search ========
401	m_cTEncTop.setDisableIntraPUsInInterSlices ( m_bDisableIntraPUsInInterSlices );
402	m_cTEncTop.setFastSearch ( m_iFastSearch );
403	m_cTEncTop.setSearchRange ( m_iSearchRange );
404	m_cTEncTop.setBipredSearchRange ( m_bipredSearchRange );
405	m_cTEncTop.setClipForBiPredMeEnabled ( m_bClipForBiPredMeEnabled );
406	m_cTEncTop.setFastMEAssumingSmootherMVEnabled ( m_bFastMEAssumingSmootherMVEnabled );
407
408	#if NH_MV
409	m_cTEncTop.setUseDisparitySearchRangeRestriction ( m_bUseDisparitySearchRangeRestriction );
410	m_cTEncTop.setVerticalDisparitySearchRange ( m_iVerticalDisparitySearchRange );
411	#endif
412	//====== Quality control ========
413	m_cTEncTop.setMaxDeltaQP ( m_iMaxDeltaQP );
414	m_cTEncTop.setMaxCuDQPDepth ( m_iMaxCuDQPDepth );
415	m_cTEncTop.setDiffCuChromaQpOffsetDepth ( m_diffCuChromaQpOffsetDepth );
416	m_cTEncTop.setChromaCbQpOffset ( m_cbQpOffset );
417	m_cTEncTop.setChromaCrQpOffset ( m_crQpOffset );
418
419	#if NH_3D
420	m_cTEncTop.setChromaFormatIdc ( isDepth ? CHROMA_400 : m_chromaFormatIDC );
421	#else
422	m_cTEncTop.setChromaFormatIdc ( m_chromaFormatIDC );
423	#endif
424
425	#if ADAPTIVE_QP_SELECTION
426	m_cTEncTop.setUseAdaptQpSelect ( m_bUseAdaptQpSelect );
427	#endif
428
429	m_cTEncTop.setUseAdaptiveQP ( m_bUseAdaptiveQP );
430	m_cTEncTop.setQPAdaptationRange ( m_iQPAdaptationRange );
431	m_cTEncTop.setExtendedPrecisionProcessingFlag ( m_extendedPrecisionProcessingFlag );
432	m_cTEncTop.setHighPrecisionOffsetsEnabledFlag ( m_highPrecisionOffsetsEnabledFlag );
433	//====== Tool list ========
434	m_cTEncTop.setDeltaQpRD ( m_uiDeltaQpRD );
435	m_cTEncTop.setFastDeltaQp ( m_bFastDeltaQP );
436	m_cTEncTop.setUseASR ( m_bUseASR );
437	m_cTEncTop.setUseHADME ( m_bUseHADME );
438	#if NH_MV
439	m_cTEncTop.setdQPs ( m_aidQP[layerIdInVps] );
440	#else
441	m_cTEncTop.setdQPs ( m_aidQP );
442	#endif
443	m_cTEncTop.setUseRDOQ ( m_useRDOQ );
444	m_cTEncTop.setUseRDOQTS ( m_useRDOQTS );
445	#if T0196_SELECTIVE_RDOQ
446	m_cTEncTop.setUseSelectiveRDOQ ( m_useSelectiveRDOQ );
447	#endif
448	m_cTEncTop.setRDpenalty ( m_rdPenalty );
449	m_cTEncTop.setMaxCUWidth ( m_uiMaxCUWidth );
450	m_cTEncTop.setMaxCUHeight ( m_uiMaxCUHeight );
451	m_cTEncTop.setMaxTotalCUDepth ( m_uiMaxTotalCUDepth );
452	m_cTEncTop.setLog2DiffMaxMinCodingBlockSize ( m_uiLog2DiffMaxMinCodingBlockSize );
453	m_cTEncTop.setQuadtreeTULog2MaxSize ( m_uiQuadtreeTULog2MaxSize );
454	m_cTEncTop.setQuadtreeTULog2MinSize ( m_uiQuadtreeTULog2MinSize );
455	m_cTEncTop.setQuadtreeTUMaxDepthInter ( m_uiQuadtreeTUMaxDepthInter );
456	m_cTEncTop.setQuadtreeTUMaxDepthIntra ( m_uiQuadtreeTUMaxDepthIntra );
457	m_cTEncTop.setUseFastEnc ( m_bUseFastEnc );
458	m_cTEncTop.setUseEarlyCU ( m_bUseEarlyCU );
459	m_cTEncTop.setUseFastDecisionForMerge ( m_useFastDecisionForMerge );
460	m_cTEncTop.setUseCbfFastMode ( m_bUseCbfFastMode );
461	m_cTEncTop.setUseEarlySkipDetection ( m_useEarlySkipDetection );
462	m_cTEncTop.setCrossComponentPredictionEnabledFlag ( m_crossComponentPredictionEnabledFlag );
463	m_cTEncTop.setUseReconBasedCrossCPredictionEstimate ( m_reconBasedCrossCPredictionEstimate );
464	#if NH_MV
465	m_cTEncTop.setLog2SaoOffsetScale ( CHANNEL_TYPE_LUMA , m_log2SaoOffsetScale[layerIdInVps][CHANNEL_TYPE_LUMA] );
466	m_cTEncTop.setLog2SaoOffsetScale ( CHANNEL_TYPE_CHROMA, m_log2SaoOffsetScale[layerIdInVps][CHANNEL_TYPE_CHROMA] );
467	#else
468	m_cTEncTop.setLog2SaoOffsetScale ( CHANNEL_TYPE_LUMA , m_log2SaoOffsetScale[CHANNEL_TYPE_LUMA] );
469	m_cTEncTop.setLog2SaoOffsetScale ( CHANNEL_TYPE_CHROMA, m_log2SaoOffsetScale[CHANNEL_TYPE_CHROMA] );
470	#endif
471	m_cTEncTop.setUseTransformSkip ( m_useTransformSkip );
472	m_cTEncTop.setUseTransformSkipFast ( m_useTransformSkipFast );
473	m_cTEncTop.setTransformSkipRotationEnabledFlag ( m_transformSkipRotationEnabledFlag );
474	m_cTEncTop.setTransformSkipContextEnabledFlag ( m_transformSkipContextEnabledFlag );
475	m_cTEncTop.setPersistentRiceAdaptationEnabledFlag ( m_persistentRiceAdaptationEnabledFlag );
476	m_cTEncTop.setCabacBypassAlignmentEnabledFlag ( m_cabacBypassAlignmentEnabledFlag );
477	m_cTEncTop.setLog2MaxTransformSkipBlockSize ( m_log2MaxTransformSkipBlockSize );
478	for (UInt signallingModeIndex = 0; signallingModeIndex < NUMBER_OF_RDPCM_SIGNALLING_MODES; signallingModeIndex++)
479	{
480	m_cTEncTop.setRdpcmEnabledFlag ( RDPCMSignallingMode(signallingModeIndex), m_rdpcmEnabledFlag[signallingModeIndex]);
481	}
482	m_cTEncTop.setUseConstrainedIntraPred ( m_bUseConstrainedIntraPred );
483	m_cTEncTop.setFastUDIUseMPMEnabled ( m_bFastUDIUseMPMEnabled );
484	m_cTEncTop.setFastMEForGenBLowDelayEnabled ( m_bFastMEForGenBLowDelayEnabled );
485	m_cTEncTop.setUseBLambdaForNonKeyLowDelayPictures ( m_bUseBLambdaForNonKeyLowDelayPictures );
486	m_cTEncTop.setPCMLog2MinSize ( m_uiPCMLog2MinSize);
487	m_cTEncTop.setUsePCM ( m_usePCM );
488
489	// set internal bit-depth and constants
490	for (UInt channelType = 0; channelType < MAX_NUM_CHANNEL_TYPE; channelType++)
491	{
492	m_cTEncTop.setBitDepth((ChannelType)channelType, m_internalBitDepth[channelType]);
493	m_cTEncTop.setPCMBitDepth((ChannelType)channelType, m_bPCMInputBitDepthFlag ? m_MSBExtendedBitDepth[channelType] : m_internalBitDepth[channelType]);
494	}
495
496	m_cTEncTop.setPCMLog2MaxSize ( m_pcmLog2MaxSize);
497	m_cTEncTop.setMaxNumMergeCand ( m_maxNumMergeCand );
498
499
500	//====== Weighted Prediction ========
501	m_cTEncTop.setUseWP ( m_useWeightedPred );
502	m_cTEncTop.setWPBiPred ( m_useWeightedBiPred );
503	//====== Parallel Merge Estimation ========
504	m_cTEncTop.setLog2ParallelMergeLevelMinus2 ( m_log2ParallelMergeLevel - 2 );
505
506	//====== Slice ========
507	m_cTEncTop.setSliceMode ( (SliceConstraint) m_sliceMode );
508	m_cTEncTop.setSliceArgument ( m_sliceArgument );
509
510	//====== Dependent Slice ========
511	m_cTEncTop.setSliceSegmentMode ( (SliceConstraint) m_sliceSegmentMode );
512	m_cTEncTop.setSliceSegmentArgument ( m_sliceSegmentArgument );
513
514	if(m_sliceMode == NO_SLICES )
515	{
516	m_bLFCrossSliceBoundaryFlag = true;
517	}
518	m_cTEncTop.setLFCrossSliceBoundaryFlag ( m_bLFCrossSliceBoundaryFlag );
519	#if NH_MV
520	m_cTEncTop.setUseSAO ( m_bUseSAO[layerIdInVps] );
521	#else
522	m_cTEncTop.setUseSAO ( m_bUseSAO );
523	#endif
524	m_cTEncTop.setTestSAODisableAtPictureLevel ( m_bTestSAODisableAtPictureLevel );
525	m_cTEncTop.setSaoEncodingRate ( m_saoEncodingRate );
526	m_cTEncTop.setSaoEncodingRateChroma ( m_saoEncodingRateChroma );
527	m_cTEncTop.setMaxNumOffsetsPerPic ( m_maxNumOffsetsPerPic);
528
529	m_cTEncTop.setSaoCtuBoundary ( m_saoCtuBoundary);
530	m_cTEncTop.setPCMInputBitDepthFlag ( m_bPCMInputBitDepthFlag);
531	m_cTEncTop.setPCMFilterDisableFlag ( m_bPCMFilterDisableFlag);
532
533	m_cTEncTop.setIntraSmoothingDisabledFlag (!m_enableIntraReferenceSmoothing );
534	m_cTEncTop.setDecodedPictureHashSEIEnabled ( m_decodedPictureHashSEIEnabled );
535	m_cTEncTop.setRecoveryPointSEIEnabled ( m_recoveryPointSEIEnabled );
536	m_cTEncTop.setBufferingPeriodSEIEnabled ( m_bufferingPeriodSEIEnabled );
537	m_cTEncTop.setPictureTimingSEIEnabled ( m_pictureTimingSEIEnabled );
538	m_cTEncTop.setToneMappingInfoSEIEnabled ( m_toneMappingInfoSEIEnabled );
539	m_cTEncTop.setTMISEIToneMapId ( m_toneMapId );
540	m_cTEncTop.setTMISEIToneMapCancelFlag ( m_toneMapCancelFlag );
541	m_cTEncTop.setTMISEIToneMapPersistenceFlag ( m_toneMapPersistenceFlag );
542	m_cTEncTop.setTMISEICodedDataBitDepth ( m_toneMapCodedDataBitDepth );
543	m_cTEncTop.setTMISEITargetBitDepth ( m_toneMapTargetBitDepth );
544	m_cTEncTop.setTMISEIModelID ( m_toneMapModelId );
545	m_cTEncTop.setTMISEIMinValue ( m_toneMapMinValue );
546	m_cTEncTop.setTMISEIMaxValue ( m_toneMapMaxValue );
547	m_cTEncTop.setTMISEISigmoidMidpoint ( m_sigmoidMidpoint );
548	m_cTEncTop.setTMISEISigmoidWidth ( m_sigmoidWidth );
549	m_cTEncTop.setTMISEIStartOfCodedInterva ( m_startOfCodedInterval );
550	m_cTEncTop.setTMISEINumPivots ( m_numPivots );
551	m_cTEncTop.setTMISEICodedPivotValue ( m_codedPivotValue );
552	m_cTEncTop.setTMISEITargetPivotValue ( m_targetPivotValue );
553	m_cTEncTop.setTMISEICameraIsoSpeedIdc ( m_cameraIsoSpeedIdc );
554	m_cTEncTop.setTMISEICameraIsoSpeedValue ( m_cameraIsoSpeedValue );
555	m_cTEncTop.setTMISEIExposureIndexIdc ( m_exposureIndexIdc );
556	m_cTEncTop.setTMISEIExposureIndexValue ( m_exposureIndexValue );
557	m_cTEncTop.setTMISEIExposureCompensationValueSignFlag ( m_exposureCompensationValueSignFlag );
558	m_cTEncTop.setTMISEIExposureCompensationValueNumerator ( m_exposureCompensationValueNumerator );
559	m_cTEncTop.setTMISEIExposureCompensationValueDenomIdc ( m_exposureCompensationValueDenomIdc );
560	m_cTEncTop.setTMISEIRefScreenLuminanceWhite ( m_refScreenLuminanceWhite );
561	m_cTEncTop.setTMISEIExtendedRangeWhiteLevel ( m_extendedRangeWhiteLevel );
562	m_cTEncTop.setTMISEINominalBlackLevelLumaCodeValue ( m_nominalBlackLevelLumaCodeValue );
563	m_cTEncTop.setTMISEINominalWhiteLevelLumaCodeValue ( m_nominalWhiteLevelLumaCodeValue );
564	m_cTEncTop.setTMISEIExtendedWhiteLevelLumaCodeValue ( m_extendedWhiteLevelLumaCodeValue );
565	m_cTEncTop.setChromaSamplingFilterHintEnabled ( m_chromaSamplingFilterSEIenabled );
566	m_cTEncTop.setChromaSamplingHorFilterIdc ( m_chromaSamplingHorFilterIdc );
567	m_cTEncTop.setChromaSamplingVerFilterIdc ( m_chromaSamplingVerFilterIdc );
568	m_cTEncTop.setFramePackingArrangementSEIEnabled ( m_framePackingSEIEnabled );
569	m_cTEncTop.setFramePackingArrangementSEIType ( m_framePackingSEIType );
570	m_cTEncTop.setFramePackingArrangementSEIId ( m_framePackingSEIId );
571	m_cTEncTop.setFramePackingArrangementSEIQuincunx ( m_framePackingSEIQuincunx );
572	m_cTEncTop.setFramePackingArrangementSEIInterpretation ( m_framePackingSEIInterpretation );
573	m_cTEncTop.setSegmentedRectFramePackingArrangementSEIEnabled ( m_segmentedRectFramePackingSEIEnabled );
574	m_cTEncTop.setSegmentedRectFramePackingArrangementSEICancel ( m_segmentedRectFramePackingSEICancel );
575	m_cTEncTop.setSegmentedRectFramePackingArrangementSEIType ( m_segmentedRectFramePackingSEIType );
576	m_cTEncTop.setSegmentedRectFramePackingArrangementSEIPersistence( m_segmentedRectFramePackingSEIPersistence );
577	m_cTEncTop.setDisplayOrientationSEIAngle ( m_displayOrientationSEIAngle );
578	m_cTEncTop.setTemporalLevel0IndexSEIEnabled ( m_temporalLevel0IndexSEIEnabled );
579	m_cTEncTop.setGradualDecodingRefreshInfoEnabled ( m_gradualDecodingRefreshInfoEnabled );
580	m_cTEncTop.setNoDisplaySEITLayer ( m_noDisplaySEITLayer );
581	m_cTEncTop.setDecodingUnitInfoSEIEnabled ( m_decodingUnitInfoSEIEnabled );
582	m_cTEncTop.setSOPDescriptionSEIEnabled ( m_SOPDescriptionSEIEnabled );
583	m_cTEncTop.setScalableNestingSEIEnabled ( m_scalableNestingSEIEnabled );
584	#if NH_MV
585	m_cTEncTop.setSubBitstreamPropSEIEnabled ( m_subBistreamPropSEIEnabled );
586	if( m_subBistreamPropSEIEnabled )
587	{
588	m_cTEncTop.setNumAdditionalSubStreams ( m_sbPropNumAdditionalSubStreams );
589	m_cTEncTop.setSubBitstreamMode ( m_sbPropSubBitstreamMode );
590	m_cTEncTop.setOutputLayerSetIdxToVps ( m_sbPropOutputLayerSetIdxToVps );
591	m_cTEncTop.setHighestSublayerId ( m_sbPropHighestSublayerId );
592	m_cTEncTop.setAvgBitRate ( m_sbPropAvgBitRate );
593	m_cTEncTop.setMaxBitRate ( m_sbPropMaxBitRate );
594	}
595	#endif
596
597	m_cTEncTop.setTMCTSSEIEnabled ( m_tmctsSEIEnabled );
598	m_cTEncTop.setTimeCodeSEIEnabled ( m_timeCodeSEIEnabled );
599	m_cTEncTop.setNumberOfTimeSets ( m_timeCodeSEINumTs );
600	for(Int i = 0; i < m_timeCodeSEINumTs; i++)
601	{
602	m_cTEncTop.setTimeSet(m_timeSetArray[i], i);
603	}
604	m_cTEncTop.setKneeSEIEnabled ( m_kneeSEIEnabled );
605	m_cTEncTop.setKneeSEIId ( m_kneeSEIId );
606	m_cTEncTop.setKneeSEICancelFlag ( m_kneeSEICancelFlag );
607	m_cTEncTop.setKneeSEIPersistenceFlag ( m_kneeSEIPersistenceFlag );
608	m_cTEncTop.setKneeSEIInputDrange ( m_kneeSEIInputDrange );
609	m_cTEncTop.setKneeSEIInputDispLuminance ( m_kneeSEIInputDispLuminance );
610	m_cTEncTop.setKneeSEIOutputDrange ( m_kneeSEIOutputDrange );
611	m_cTEncTop.setKneeSEIOutputDispLuminance ( m_kneeSEIOutputDispLuminance );
612	m_cTEncTop.setKneeSEINumKneePointsMinus1 ( m_kneeSEINumKneePointsMinus1 );
613	m_cTEncTop.setKneeSEIInputKneePoint ( m_kneeSEIInputKneePoint );
614	m_cTEncTop.setKneeSEIOutputKneePoint ( m_kneeSEIOutputKneePoint );
615	m_cTEncTop.setMasteringDisplaySEI ( m_masteringDisplay );
616
617	m_cTEncTop.setTileUniformSpacingFlag ( m_tileUniformSpacingFlag );
618	m_cTEncTop.setNumColumnsMinus1 ( m_numTileColumnsMinus1 );
619	m_cTEncTop.setNumRowsMinus1 ( m_numTileRowsMinus1 );
620	if(!m_tileUniformSpacingFlag)
621	{
622	m_cTEncTop.setColumnWidth ( m_tileColumnWidth );
623	m_cTEncTop.setRowHeight ( m_tileRowHeight );
624	}
625	m_cTEncTop.xCheckGSParameters();
626	Int uiTilesCount = (m_numTileRowsMinus1+1) * (m_numTileColumnsMinus1+1);
627	if(uiTilesCount == 1)
628	{
629	m_bLFCrossTileBoundaryFlag = true;
630	}
631	m_cTEncTop.setLFCrossTileBoundaryFlag ( m_bLFCrossTileBoundaryFlag );
632	m_cTEncTop.setWaveFrontSynchro ( m_iWaveFrontSynchro );
633	m_cTEncTop.setTMVPModeId ( m_TMVPModeId );
634	m_cTEncTop.setUseScalingListId ( m_useScalingListId );
635	m_cTEncTop.setScalingListFile ( m_scalingListFile );
636	m_cTEncTop.setSignHideFlag ( m_signHideFlag);
637	#if KWU_RC_VIEWRC_E0227 \|\| KWU_RC_MADPRED_E0227
638	if(!m_cTEncTop.getIsDepth()) //only for texture
639	{
640	m_cTEncTop.setUseRateCtrl ( m_RCEnableRateControl );
641	}
642	else
643	{
644	m_cTEncTop.setUseRateCtrl ( 0 );
645	}
646	#else
647	m_cTEncTop.setUseRateCtrl ( m_RCEnableRateControl );
648	#endif
649	#if !KWU_RC_VIEWRC_E0227
650	m_cTEncTop.setTargetBitrate ( m_RCTargetBitrate );
651	#endif
652	m_cTEncTop.setKeepHierBit ( m_RCKeepHierarchicalBit );
653	m_cTEncTop.setLCULevelRC ( m_RCLCULevelRC );
654	m_cTEncTop.setUseLCUSeparateModel ( m_RCUseLCUSeparateModel );
655	m_cTEncTop.setInitialQP ( m_RCInitialQP );
656	m_cTEncTop.setForceIntraQP ( m_RCForceIntraQP );
657	#if KWU_RC_MADPRED_E0227
658	if(m_cTEncTop.getUseRateCtrl() && !m_cTEncTop.getIsDepth())
659	{
660	m_cTEncTop.setUseDepthMADPred(layerIdInVps ? m_depthMADPred : 0);
661	if(m_cTEncTop.getUseDepthMADPred())
662	{
663	m_cTEncTop.setCamParam(&m_cCameraData);
664	}
665	}
666	#endif
667	#if KWU_RC_VIEWRC_E0227
668	if(m_cTEncTop.getUseRateCtrl() && !m_cTEncTop.getIsDepth())
669	{
670	m_cTEncTop.setUseViewWiseRateCtrl(m_viewWiseRateCtrl);
671	if(m_iNumberOfViews == 1)
672	{
673	if(m_viewWiseRateCtrl)
674	{
675	m_cTEncTop.setTargetBitrate(m_viewTargetBits[layerIdInVps>>1]);
676	}
677	else
678	{
679	m_cTEncTop.setTargetBitrate ( m_RCTargetBitrate );
680	}
681	}
682	else
683	{
684	if(m_viewWiseRateCtrl)
685	{
686	m_cTEncTop.setTargetBitrate(m_viewTargetBits[layerIdInVps>>1]);
687	}
688	else
689	{
690	if(m_iNumberOfViews == 2)
691	{
692	if(m_cTEncTop.getViewId() == 0)
693	{
694	m_cTEncTop.setTargetBitrate ( (m_RCTargetBitrate*80)/100 );
695	}
696	else if(m_cTEncTop.getViewId() == 1)
697	{
698	m_cTEncTop.setTargetBitrate ( (m_RCTargetBitrate*20)/100 );
699	}
700	}
701	else if(m_iNumberOfViews == 3)
702	{
703	if(m_cTEncTop.getViewId() == 0)
704	{
705	m_cTEncTop.setTargetBitrate ( (m_RCTargetBitrate*66)/100 );
706	}
707	else if(m_cTEncTop.getViewId() == 1)
708	{
709	m_cTEncTop.setTargetBitrate ( (m_RCTargetBitrate*17)/100 );
710	}
711	else if(m_cTEncTop.getViewId() == 2)
712	{
713	m_cTEncTop.setTargetBitrate ( (m_RCTargetBitrate*17)/100 );
714	}
715	}
716	else
717	{
718	m_cTEncTop.setTargetBitrate ( m_RCTargetBitrate );
719	}
720	}
721	}
722	}
723	#endif
724	m_cTEncTop.setTransquantBypassEnableFlag ( m_TransquantBypassEnableFlag );
725	m_cTEncTop.setCUTransquantBypassFlagForceValue ( m_CUTransquantBypassFlagForce );
726	m_cTEncTop.setCostMode ( m_costMode );
727	m_cTEncTop.setUseRecalculateQPAccordingToLambda ( m_recalculateQPAccordingToLambda );
728	m_cTEncTop.setUseStrongIntraSmoothing ( m_useStrongIntraSmoothing );
729	m_cTEncTop.setActiveParameterSetsSEIEnabled ( m_activeParameterSetsSEIEnabled );
730	m_cTEncTop.setVuiParametersPresentFlag ( m_vuiParametersPresentFlag );
731	m_cTEncTop.setAspectRatioInfoPresentFlag ( m_aspectRatioInfoPresentFlag);
732	m_cTEncTop.setAspectRatioIdc ( m_aspectRatioIdc );
733	m_cTEncTop.setSarWidth ( m_sarWidth );
734	m_cTEncTop.setSarHeight ( m_sarHeight );
735	m_cTEncTop.setOverscanInfoPresentFlag ( m_overscanInfoPresentFlag );
736	m_cTEncTop.setOverscanAppropriateFlag ( m_overscanAppropriateFlag );
737	m_cTEncTop.setVideoSignalTypePresentFlag ( m_videoSignalTypePresentFlag );
738	m_cTEncTop.setVideoFormat ( m_videoFormat );
739	m_cTEncTop.setVideoFullRangeFlag ( m_videoFullRangeFlag );
740	m_cTEncTop.setColourDescriptionPresentFlag ( m_colourDescriptionPresentFlag );
741	m_cTEncTop.setColourPrimaries ( m_colourPrimaries );
742	m_cTEncTop.setTransferCharacteristics ( m_transferCharacteristics );
743	m_cTEncTop.setMatrixCoefficients ( m_matrixCoefficients );
744	m_cTEncTop.setChromaLocInfoPresentFlag ( m_chromaLocInfoPresentFlag );
745	m_cTEncTop.setChromaSampleLocTypeTopField ( m_chromaSampleLocTypeTopField );
746	m_cTEncTop.setChromaSampleLocTypeBottomField ( m_chromaSampleLocTypeBottomField );
747	m_cTEncTop.setNeutralChromaIndicationFlag ( m_neutralChromaIndicationFlag );
748	m_cTEncTop.setDefaultDisplayWindow ( m_defDispWinLeftOffset, m_defDispWinRightOffset, m_defDispWinTopOffset, m_defDispWinBottomOffset );
749	m_cTEncTop.setFrameFieldInfoPresentFlag ( m_frameFieldInfoPresentFlag );
750	m_cTEncTop.setPocProportionalToTimingFlag ( m_pocProportionalToTimingFlag );
751	m_cTEncTop.setNumTicksPocDiffOneMinus1 ( m_numTicksPocDiffOneMinus1 );
752	m_cTEncTop.setBitstreamRestrictionFlag ( m_bitstreamRestrictionFlag );
753	m_cTEncTop.setTilesFixedStructureFlag ( m_tilesFixedStructureFlag );
754	m_cTEncTop.setMotionVectorsOverPicBoundariesFlag ( m_motionVectorsOverPicBoundariesFlag );
755	m_cTEncTop.setMinSpatialSegmentationIdc ( m_minSpatialSegmentationIdc );
756	m_cTEncTop.setMaxBytesPerPicDenom ( m_maxBytesPerPicDenom );
757	m_cTEncTop.setMaxBitsPerMinCuDenom ( m_maxBitsPerMinCuDenom );
758	m_cTEncTop.setLog2MaxMvLengthHorizontal ( m_log2MaxMvLengthHorizontal );
759	m_cTEncTop.setLog2MaxMvLengthVertical ( m_log2MaxMvLengthVertical );
760	m_cTEncTop.setEfficientFieldIRAPEnabled ( m_bEfficientFieldIRAPEnabled );
761	m_cTEncTop.setHarmonizeGopFirstFieldCoupleEnabled ( m_bHarmonizeGopFirstFieldCoupleEnabled );
762
763	m_cTEncTop.setSummaryOutFilename ( m_summaryOutFilename );
764	m_cTEncTop.setSummaryPicFilenameBase ( m_summaryPicFilenameBase );
765	m_cTEncTop.setSummaryVerboseness ( m_summaryVerboseness );
766
767	#if NH_MV
768	}
769	#endif
770	#if NH_3D_VSO
771	if ( m_bUseVSO )
772	{
773	if ( m_uiVSOMode == 4 )
774	{
775	#if H_3D_VSO_EARLY_SKIP
776	m_cRendererModel.create( m_cRenModStrParser.getNumOfBaseViews(), m_cRenModStrParser.getNumOfModels(), m_iSourceWidth, m_uiMaxCUHeight , LOG2_DISP_PREC_LUT, 0, m_bVSOEarlySkip );
777	#else
778	m_cRendererModel.create( m_cRenModStrParser.getNumOfBaseViews(), m_cRenModStrParser.getNumOfModels(), m_iSourceWidth, m_uiMaxCUHeight , LOG2_DISP_PREC_LUT, 0 );
779	#endif
780	for ( Int layer = 0; layer < m_numberOfLayers ; layer++ )
781	{
782	TEncTop* pcEncTop = m_acTEncTopList[ layer ];
783	Int iViewNum = pcEncTop->getViewIndex();
784	Int iContent = pcEncTop->getIsDepth() ? 1 : 0;
785	Int iNumOfModels = m_cRenModStrParser.getNumOfModelsForView(iViewNum, iContent);
786
787	Bool bUseVSO = (iNumOfModels != 0);
788
789	pcEncTop->setUseVSO( bUseVSO );
790	pcEncTop->getRdCost()->setRenModel( bUseVSO ? &m_cRendererModel : NULL );
791
792	for (Int iCurModel = 0; iCurModel < iNumOfModels; iCurModel++ )
793	{
794	Int iModelNum; Int iLeftViewNum; Int iRightViewNum; Int iDump; Int iOrgRefNum; Int iBlendMode;
795
796	m_cRenModStrParser.getSingleModelData ( iViewNum, iContent, iCurModel, iModelNum, iBlendMode, iLeftViewNum, iRightViewNum, iOrgRefNum, iDump ) ;
797	m_cRendererModel .createSingleModel ( iViewNum, iContent, iModelNum, iLeftViewNum, iRightViewNum, (iOrgRefNum != -1), iBlendMode );
798	}
799	}
800	}
801	else
802	{
803	AOT(true);
804	}
805	}
806	#endif
807	}
808
809	Void TAppEncTop::xCreateLib()
810	{
811	#if NH_MV
812	// initialize global variables
813	initROM();
814	#if NH_3D_DMM
815	initWedgeLists( true );
816	#endif
817
818	for( Int layer=0; layer < m_numberOfLayers; layer++)
819	{
820	m_acTVideoIOYuvInputFileList[layer]->open( m_pchInputFileList[layer], false, m_inputBitDepth, m_MSBExtendedBitDepth, m_internalBitDepth ); // read mode
821	m_acTVideoIOYuvInputFileList[layer]->skipFrames( m_FrameSkip, m_iSourceWidth - m_aiPad[0], m_iSourceHeight - m_aiPad[1], m_InputChromaFormatIDC);
822
823	if (m_pchReconFileList[layer])
824	{
825	m_acTVideoIOYuvReconFileList[layer]->open( m_pchReconFileList[layer], true, m_outputBitDepth, m_outputBitDepth, m_internalBitDepth); // write mode
826	}
827	m_acTEncTopList[layer]->create();
828	}
829	#else
830	// Video I/O
831	m_cTVideoIOYuvInputFile.open( m_pchInputFile, false, m_inputBitDepth, m_MSBExtendedBitDepth, m_internalBitDepth ); // read mode
832	m_cTVideoIOYuvInputFile.skipFrames(m_FrameSkip, m_iSourceWidth - m_aiPad[0], m_iSourceHeight - m_aiPad[1], m_InputChromaFormatIDC);
833
834	if (m_pchReconFile)
835	{
836	m_cTVideoIOYuvReconFile.open(m_pchReconFile, true, m_outputBitDepth, m_outputBitDepth, m_internalBitDepth); // write mode
837	}
838
839	// Neo Decoder
840	m_cTEncTop.create();
841	#endif
842	}
843
844	Void TAppEncTop::xDestroyLib()
845	{
846	#if NH_MV
847	// destroy ROM
848	destroyROM();
849
850	for(Int layer=0; layer<m_numberOfLayers; layer++)
851	{
852	m_acTVideoIOYuvInputFileList[layer]->close();
853	m_acTVideoIOYuvReconFileList[layer]->close();
854	delete m_acTVideoIOYuvInputFileList[layer] ;
855	m_acTVideoIOYuvInputFileList[layer] = NULL;
856	delete m_acTVideoIOYuvReconFileList[layer] ;
857	m_acTVideoIOYuvReconFileList[layer] = NULL;
858	m_acTEncTopList[layer]->deletePicBuffer();
859	m_acTEncTopList[layer]->destroy();
860	delete m_acTEncTopList[layer] ;
861	m_acTEncTopList[layer] = NULL;
862	delete m_cListPicYuvRec[layer] ;
863	m_cListPicYuvRec[layer] = NULL;
864	}
865	#else
866	// Video I/O
867	m_cTVideoIOYuvInputFile.close();
868	m_cTVideoIOYuvReconFile.close();
869
870	// Neo Decoder
871	m_cTEncTop.destroy();
872	#endif
873	}
874
875	Void TAppEncTop::xInitLib(Bool isFieldCoding)
876	{
877	#if NH_MV
878	for(Int layer=0; layer<m_numberOfLayers; layer++)
879	{
880	#if KWU_RC_MADPRED_E0227
881	m_acTEncTopList[layer]->init( isFieldCoding, this );
882	#else
883	m_acTEncTopList[layer]->init( isFieldCoding );
884	#endif
885	}
886	#else
887	m_cTEncTop.init(isFieldCoding);
888	#endif
889	}
890
891	// ====================================================================================================================
892	// Public member functions
893	// ====================================================================================================================
894
895	/**
896	- create internal class
897	- initialize internal variable
898	- until the end of input YUV file, call encoding function in TEncTop class
899	- delete allocated buffers
900	- destroy internal class
901	.
902	*/
903	Void TAppEncTop::encode()
904	{
905	fstream bitstreamFile(m_pchBitstreamFile, fstream::binary \| fstream::out);
906	if (!bitstreamFile)
907	{
908	fprintf(stderr, "\nfailed to open bitstream file `%s' for writing\n", m_pchBitstreamFile);
909	exit(EXIT_FAILURE);
910	}
911
912	#if !NH_3D
913	TComPicYuv* pcPicYuvOrg = new TComPicYuv;
914	#endif
915	TComPicYuv* pcPicYuvRec = NULL;
916
917	// initialize internal class & member variables
918	xInitLibCfg();
919	xCreateLib();
920	xInitLib(m_isField);
921
922	printChromaFormat();
923
924	// main encoder loop
925	#if NH_MV
926	Bool allEos = false;
927	std::vector<Bool> eos ;
928	std::vector<Bool> flush ;
929
930	Int gopSize = 1;
931	Int maxGopSize = 0;
932	maxGopSize = (std::max)(maxGopSize, m_acTEncTopList[0]->getGOPSize());
933
934	for(Int layer=0; layer < m_numberOfLayers; layer++ )
935	{
936	eos .push_back( false );
937	flush.push_back( false );
938	}
939	#else
940	Int iNumEncoded = 0;
941	Bool bEos = false;
942	#endif
943	const InputColourSpaceConversion ipCSC = m_inputColourSpaceConvert;
944	const InputColourSpaceConversion snrCSC = (!m_snrInternalColourSpace) ? m_inputColourSpaceConvert : IPCOLOURSPACE_UNCHANGED;
945
946	list<AccessUnit> outputAccessUnits; ///< list of access units to write out. is populated by the encoding process
947
948	#if NH_3D
949	TComPicYuv* picYuvOrg[2];
950	TComPicYuv picYuvTrueOrg[2];
951	for (Int d = 0; d < 2 ; d++)
952	{
953	picYuvOrg[d] = new TComPicYuv;
954	picYuvOrg[d] ->create( m_iSourceWidth, m_isField ? m_iSourceHeightOrg : m_iSourceHeight, ( d > 0 ) ? CHROMA_400 : m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
955	picYuvTrueOrg[d].create( m_iSourceWidth, m_isField ? m_iSourceHeightOrg : m_iSourceHeight, ( d > 0 ) ? CHROMA_400 : m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
956	}
957	#else
958	TComPicYuv cPicYuvTrueOrg;
959
960	// allocate original YUV buffer
961	if( m_isField )
962	{
963	pcPicYuvOrg->create ( m_iSourceWidth, m_iSourceHeightOrg, m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
964	cPicYuvTrueOrg.create(m_iSourceWidth, m_iSourceHeightOrg, m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true);
965	}
966	else
967	{
968	pcPicYuvOrg->create ( m_iSourceWidth, m_iSourceHeight, m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
969	cPicYuvTrueOrg.create(m_iSourceWidth, m_iSourceHeight, m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
970	}
971	#endif
972	#if NH_MV
973	while ( (m_targetEncLayerIdList.size() != 0 ) && !allEos )
974	{
975	for(Int layer=0; layer < m_numberOfLayers; layer++ )
976	{
977	#if NH_3D
978	TComPicYuv* pcPicYuvOrg = picYuvOrg [ m_depthFlag[layer] ];
979	TComPicYuv& cPicYuvTrueOrg = picYuvTrueOrg[ m_depthFlag[layer] ];
980	#endif
981	if (!xLayerIdInTargetEncLayerIdList( m_vps->getLayerIdInNuh( layer ) ))
982	{
983	continue;
984	}
985
986	Int frmCnt = 0;
987	while ( !eos[layer] && !(frmCnt == gopSize))
988	{
989	// get buffers
990	xGetBuffer(pcPicYuvRec, layer);
991
992	// read input YUV file
993	m_acTVideoIOYuvInputFileList[layer]->read ( pcPicYuvOrg, &cPicYuvTrueOrg, ipCSC, m_aiPad, m_InputChromaFormatIDC );
994	m_acTEncTopList [layer]->initNewPic( pcPicYuvOrg );
995
996	// increase number of received frames
997	m_frameRcvd[layer]++;
998
999	frmCnt++;
1000
1001	eos[layer] = (m_frameRcvd[layer] == m_framesToBeEncoded);
1002	allEos = allEos\|\|eos[layer];
1003
1004	// if end of file (which is only detected on a read failure) flush the encoder of any queued pictures
1005	if (m_acTVideoIOYuvInputFileList[layer]->isEof())
1006	{
1007	flush [layer] = true;
1008	eos [layer] = true;
1009	m_frameRcvd [layer]--;
1010	m_acTEncTopList[layer]->setFramesToBeEncoded(m_frameRcvd[layer]);
1011	}
1012	}
1013	}
1014	for ( Int gopId=0; gopId < gopSize; gopId++ )
1015	{
1016	#if NH_3D
1017	UInt iNextPoc = m_acTEncTopList[0] -> getFrameId( gopId );
1018	if ( iNextPoc < m_framesToBeEncoded )
1019	{
1020	m_cCameraData.update( iNextPoc );
1021	}
1022	#endif
1023	for(Int layer=0; layer < m_numberOfLayers; layer++ )
1024	{
1025	#if NH_3D
1026	TComPicYuv* pcPicYuvOrg = picYuvOrg [ m_depthFlag[layer] ];
1027	TComPicYuv& cPicYuvTrueOrg = picYuvTrueOrg[ m_depthFlag[layer] ];
1028	#endif
1029	if (!xLayerIdInTargetEncLayerIdList( m_vps->getLayerIdInNuh( layer ) ))
1030	{
1031	continue;
1032	}
1033
1034	#if NH_3D_VSO
1035	if( m_bUseVSO && m_bUseEstimatedVSD && iNextPoc < m_framesToBeEncoded )
1036	{
1037	m_cCameraData.setDispCoeff( iNextPoc, m_acTEncTopList[layer]->getViewIndex() );
1038	m_acTEncTopList[layer] ->setDispCoeff( m_cCameraData.getDispCoeff() );
1039	}
1040	#endif
1041
1042	Int iNumEncoded = 0;
1043
1044	// call encoding function for one frame
1045	m_acTEncTopList[layer]->encode( eos[layer], flush[layer] ? 0 : pcPicYuvOrg, flush[layer] ? 0 : &cPicYuvTrueOrg, snrCSC, *m_cListPicYuvRec[layer], outputAccessUnits, iNumEncoded, gopId );
1046	xWriteOutput(bitstreamFile, iNumEncoded, outputAccessUnits, layer);
1047	outputAccessUnits.clear();
1048	}
1049	}
1050
1051	gopSize = maxGopSize;
1052	}
1053	for(Int layer=0; layer < m_numberOfLayers; layer++ )
1054	{
1055	if (!xLayerIdInTargetEncLayerIdList( m_vps->getLayerIdInNuh( layer ) ))
1056	{
1057	continue;
1058	}
1059	m_acTEncTopList[layer]->printSummary(m_isField);
1060	}
1061	#else
1062
1063	while ( !bEos )
1064	{
1065	// get buffers
1066	xGetBuffer(pcPicYuvRec);
1067
1068	// read input YUV file
1069	m_cTVideoIOYuvInputFile.read( pcPicYuvOrg, &cPicYuvTrueOrg, ipCSC, m_aiPad, m_InputChromaFormatIDC, m_bClipInputVideoToRec709Range );
1070
1071	// increase number of received frames
1072	m_iFrameRcvd++;
1073
1074	bEos = (m_isField && (m_iFrameRcvd == (m_framesToBeEncoded >> 1) )) \|\| ( !m_isField && (m_iFrameRcvd == m_framesToBeEncoded) );
1075
1076	Bool flush = 0;
1077	// if end of file (which is only detected on a read failure) flush the encoder of any queued pictures
1078	if (m_cTVideoIOYuvInputFile.isEof())
1079	{
1080	flush = true;
1081	bEos = true;
1082	m_iFrameRcvd--;
1083	m_cTEncTop.setFramesToBeEncoded(m_iFrameRcvd);
1084	}
1085
1086	// call encoding function for one frame
1087	if ( m_isField )
1088	{
1089	m_cTEncTop.encode( bEos, flush ? 0 : pcPicYuvOrg, flush ? 0 : &cPicYuvTrueOrg, snrCSC, m_cListPicYuvRec, outputAccessUnits, iNumEncoded, m_isTopFieldFirst );
1090	}
1091	else
1092	{
1093	m_cTEncTop.encode( bEos, flush ? 0 : pcPicYuvOrg, flush ? 0 : &cPicYuvTrueOrg, snrCSC, m_cListPicYuvRec, outputAccessUnits, iNumEncoded );
1094	}
1095
1096	// write bistream to file if necessary
1097	if ( iNumEncoded > 0 )
1098	{
1099	xWriteOutput(bitstreamFile, iNumEncoded, outputAccessUnits);
1100	outputAccessUnits.clear();
1101	}
1102	}
1103
1104	m_cTEncTop.printSummary(m_isField);
1105	#endif
1106
1107	#if NH_3D
1108	// delete original YUV buffer
1109	for (Int d = 0; d < 2; d++)
1110	{
1111	picYuvOrg[d]->destroy();
1112	delete picYuvOrg[d];
1113	picYuvOrg[d] = NULL;
1114
1115	picYuvTrueOrg[d].destroy();
1116	}
1117	#else
1118	// delete original YUV buffer
1119	pcPicYuvOrg->destroy();
1120	delete pcPicYuvOrg;
1121	pcPicYuvOrg = NULL;
1122	#endif
1123
1124	#if !NH_MV
1125	// delete used buffers in encoder class
1126	m_cTEncTop.deletePicBuffer();
1127	#endif
1128	#if !NH_3D
1129	cPicYuvTrueOrg.destroy();
1130	#endif
1131
1132	// delete buffers & classes
1133	xDeleteBuffer();
1134	xDestroyLib();
1135
1136	printRateSummary();
1137
1138	#if H_3D_REN_MAX_DEV_OUT
1139	Double dMaxDispDiff = m_cCameraData.getMaxShiftDeviation();
1140
1141	if ( !(dMaxDispDiff < 0) )
1142	{
1143	printf("\n Max. possible shift error: %12.3f samples.\n", dMaxDispDiff );
1144	}
1145	#endif
1146
1147	return;
1148	}
1149
1150	// ====================================================================================================================
1151	// Protected member functions
1152	// ====================================================================================================================
1153
1154	/**
1155	- application has picture buffer list with size of GOP
1156	- picture buffer list acts as ring buffer
1157	- end of the list has the latest picture
1158	.
1159	*/
1160	#if NH_MV
1161	Void TAppEncTop::xGetBuffer( TComPicYuv*& rpcPicYuvRec, UInt layer)
1162	#else
1163	Void TAppEncTop::xGetBuffer( TComPicYuv*& rpcPicYuvRec)
1164	#endif
1165	{
1166	assert( m_iGOPSize > 0 );
1167
1168	// org. buffer
1169	#if NH_MV
1170	if ( m_cListPicYuvRec[layer]->size() == (UInt)m_iGOPSize )
1171	{
1172	rpcPicYuvRec = m_cListPicYuvRec[layer]->popFront();
1173	#else
1174	if ( m_cListPicYuvRec.size() >= (UInt)m_iGOPSize ) // buffer will be 1 element longer when using field coding, to maintain first field whilst processing second.
1175	{
1176	rpcPicYuvRec = m_cListPicYuvRec.popFront();
1177	#endif
1178	}
1179	else
1180	{
1181	rpcPicYuvRec = new TComPicYuv;
1182	#if NH_3D
1183	rpcPicYuvRec->create( m_iSourceWidth, m_iSourceHeight, m_depthFlag[layer] > 0 ? CHROMA_400 : m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
1184	#else
1185	rpcPicYuvRec->create( m_iSourceWidth, m_iSourceHeight, m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
1186	#endif
1187
1188	}
1189	#if NH_MV
1190	m_cListPicYuvRec[layer]->pushBack( rpcPicYuvRec );
1191	#else
1192	m_cListPicYuvRec.pushBack( rpcPicYuvRec );
1193	#endif
1194	}
1195
1196	Void TAppEncTop::xDeleteBuffer( )
1197	{
1198	#if NH_MV
1199	for(Int layer=0; layer<m_cListPicYuvRec.size(); layer++)
1200	{
1201	if(m_cListPicYuvRec[layer])
1202	{
1203	TComList<TComPicYuv*>::iterator iterPicYuvRec = m_cListPicYuvRec[layer]->begin();
1204	Int iSize = Int( m_cListPicYuvRec[layer]->size() );
1205	#else
1206	TComList<TComPicYuv*>::iterator iterPicYuvRec = m_cListPicYuvRec.begin();
1207
1208	Int iSize = Int( m_cListPicYuvRec.size() );
1209	#endif
1210
1211	for ( Int i = 0; i < iSize; i++ )
1212	{
1213	TComPicYuv* pcPicYuvRec = *(iterPicYuvRec++);
1214	pcPicYuvRec->destroy();
1215	delete pcPicYuvRec; pcPicYuvRec = NULL;
1216	}
1217	#if NH_MV
1218	}
1219	}
1220	#endif
1221
1222	}
1223
1224	/**
1225	Write access units to output file.
1226	\param bitstreamFile target bitstream file
1227	\param iNumEncoded number of encoded frames
1228	\param accessUnits list of access units to be written
1229	*/
1230	#if NH_MV
1231	Void TAppEncTop::xWriteOutput(std::ostream& bitstreamFile, Int iNumEncoded, std::list<AccessUnit>& accessUnits, UInt layerIdx)
1232	#else
1233	Void TAppEncTop::xWriteOutput(std::ostream& bitstreamFile, Int iNumEncoded, const std::list<AccessUnit>& accessUnits)
1234	#endif
1235	{
1236	const InputColourSpaceConversion ipCSC = (!m_outputInternalColourSpace) ? m_inputColourSpaceConvert : IPCOLOURSPACE_UNCHANGED;
1237
1238	if (m_isField)
1239	{
1240	//Reinterlace fields
1241	Int i;
1242	#if NH_MV
1243	if( iNumEncoded > 0 )
1244	{
1245	TComList<TComPicYuv*>::iterator iterPicYuvRec = m_cListPicYuvRec[layerIdx]->end();
1246	#else
1247	TComList<TComPicYuv*>::iterator iterPicYuvRec = m_cListPicYuvRec.end();
1248	list<AccessUnit>::const_iterator iterBitstream = accessUnits.begin();
1249	#endif
1250
1251	for ( i = 0; i < iNumEncoded; i++ )
1252	{
1253	--iterPicYuvRec;
1254	}
1255
1256	for ( i = 0; i < iNumEncoded/2; i++ )
1257	{
1258	TComPicYuv* pcPicYuvRecTop = *(iterPicYuvRec++);
1259	TComPicYuv* pcPicYuvRecBottom = *(iterPicYuvRec++);
1260
1261	#if NH_MV
1262	if (m_pchReconFileList[layerIdx])
1263	{
1264	#if NH_3D
1265	m_acTVideoIOYuvReconFileList[layerIdx]->write( pcPicYuvRecTop, pcPicYuvRecBottom, ipCSC, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom, m_depth420OutputFlag && m_depthFlag[layerIdx ] ? CHROMA_420 : NUM_CHROMA_FORMAT, m_isTopFieldFirst );
1266	#else
1267	m_acTVideoIOYuvReconFileList[layerIdx]->write( pcPicYuvRecTop, pcPicYuvRecBottom, ipCSC, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom, NUM_CHROMA_FORMAT, m_isTopFieldFirst );
1268	#endif
1269	}
1270	}
1271	}
1272
1273	if( ! accessUnits.empty() )
1274	{
1275	list<AccessUnit>::iterator aUIter;
1276	for( aUIter = accessUnits.begin(); aUIter != accessUnits.end(); aUIter++ )
1277	{
1278	const vector<UInt>& stats = writeAnnexB(bitstreamFile, *aUIter);
1279	rateStatsAccum(*aUIter, stats);
1280	}
1281	}
1282	#else
1283	if (m_pchReconFile)
1284	{
1285	m_cTVideoIOYuvReconFile.write( pcPicYuvRecTop, pcPicYuvRecBottom, ipCSC, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom, NUM_CHROMA_FORMAT, m_isTopFieldFirst );
1286	}
1287
1288	const AccessUnit& auTop = *(iterBitstream++);
1289	const vector<UInt>& statsTop = writeAnnexB(bitstreamFile, auTop);
1290	rateStatsAccum(auTop, statsTop);
1291
1292	const AccessUnit& auBottom = *(iterBitstream++);
1293	const vector<UInt>& statsBottom = writeAnnexB(bitstreamFile, auBottom);
1294	rateStatsAccum(auBottom, statsBottom);
1295	}
1296	#endif
1297	}
1298	else
1299	{
1300	Int i;
1301	#if NH_MV
1302	if( iNumEncoded > 0 )
1303	{
1304	TComList<TComPicYuv*>::iterator iterPicYuvRec = m_cListPicYuvRec[layerIdx]->end();
1305	#else
1306	TComList<TComPicYuv*>::iterator iterPicYuvRec = m_cListPicYuvRec.end();
1307	list<AccessUnit>::const_iterator iterBitstream = accessUnits.begin();
1308	#endif
1309
1310	for ( i = 0; i < iNumEncoded; i++ )
1311	{
1312	--iterPicYuvRec;
1313	}
1314
1315	for ( i = 0; i < iNumEncoded; i++ )
1316	{
1317	TComPicYuv* pcPicYuvRec = *(iterPicYuvRec++);
1318	#if NH_MV
1319	if (m_pchReconFileList[layerIdx])
1320	{
1321	#if NH_3D
1322	m_acTVideoIOYuvReconFileList[layerIdx]->write( pcPicYuvRec, ipCSC, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom, m_depth420OutputFlag && m_depthFlag[layerIdx ] ? CHROMA_420 : NUM_CHROMA_FORMAT );
1323	#else
1324	m_acTVideoIOYuvReconFileList[layerIdx]->write( pcPicYuvRec, ipCSC, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom );
1325	#endif
1326
1327	}
1328	}
1329	}
1330	if( ! accessUnits.empty() )
1331	{
1332	list<AccessUnit>::iterator aUIter;
1333	for( aUIter = accessUnits.begin(); aUIter != accessUnits.end(); aUIter++ )
1334	{
1335	const vector<unsigned>& stats = writeAnnexB(bitstreamFile, *aUIter);
1336	rateStatsAccum(*aUIter, stats);
1337	}
1338	}
1339	#else
1340	if (m_pchReconFile)
1341	{
1342	m_cTVideoIOYuvReconFile.write( pcPicYuvRec, ipCSC, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom,
1343	NUM_CHROMA_FORMAT, m_bClipOutputVideoToRec709Range );
1344	}
1345
1346	const AccessUnit& au = *(iterBitstream++);
1347	const vector<UInt>& stats = writeAnnexB(bitstreamFile, au);
1348	rateStatsAccum(au, stats);
1349	}
1350	#endif
1351	}
1352	}
1353
1354	/**
1355	*
1356	*/
1357	Void TAppEncTop::rateStatsAccum(const AccessUnit& au, const std::vector<UInt>& annexBsizes)
1358	{
1359	AccessUnit::const_iterator it_au = au.begin();
1360	vector<UInt>::const_iterator it_stats = annexBsizes.begin();
1361
1362	for (; it_au != au.end(); it_au++, it_stats++)
1363	{
1364	switch ((*it_au)->m_nalUnitType)
1365	{
1366	case NAL_UNIT_CODED_SLICE_TRAIL_R:
1367	case NAL_UNIT_CODED_SLICE_TRAIL_N:
1368	case NAL_UNIT_CODED_SLICE_TSA_R:
1369	case NAL_UNIT_CODED_SLICE_TSA_N:
1370	case NAL_UNIT_CODED_SLICE_STSA_R:
1371	case NAL_UNIT_CODED_SLICE_STSA_N:
1372	case NAL_UNIT_CODED_SLICE_BLA_W_LP:
1373	case NAL_UNIT_CODED_SLICE_BLA_W_RADL:
1374	case NAL_UNIT_CODED_SLICE_BLA_N_LP:
1375	case NAL_UNIT_CODED_SLICE_IDR_W_RADL:
1376	case NAL_UNIT_CODED_SLICE_IDR_N_LP:
1377	case NAL_UNIT_CODED_SLICE_CRA:
1378	case NAL_UNIT_CODED_SLICE_RADL_N:
1379	case NAL_UNIT_CODED_SLICE_RADL_R:
1380	case NAL_UNIT_CODED_SLICE_RASL_N:
1381	case NAL_UNIT_CODED_SLICE_RASL_R:
1382	case NAL_UNIT_VPS:
1383	case NAL_UNIT_SPS:
1384	case NAL_UNIT_PPS:
1385	m_essentialBytes += *it_stats;
1386	break;
1387	default:
1388	break;
1389	}
1390
1391	m_totalBytes += *it_stats;
1392	}
1393	}
1394
1395	Void TAppEncTop::printRateSummary()
1396	{
1397	#if NH_MV
1398	Double time = (Double) m_frameRcvd[0] / m_iFrameRate;
1399	printf("\n");
1400	#else
1401	Double time = (Double) m_iFrameRcvd / m_iFrameRate;
1402	#endif
1403	printf("Bytes written to file: %u (%.3f kbps)\n", m_totalBytes, 0.008 * m_totalBytes / time);
1404	if (m_summaryVerboseness > 0)
1405	{
1406	printf("Bytes for SPS/PPS/Slice (Incl. Annex B): %u (%.3f kbps)\n", m_essentialBytes, 0.008 * m_essentialBytes / time);
1407	}
1408	}
1409
1410	Void TAppEncTop::printChromaFormat()
1411	{
1412	std::cout << std::setw(43) << "Input ChromaFormatIDC = ";
1413	switch (m_InputChromaFormatIDC)
1414	{
1415	case CHROMA_400: std::cout << " 4:0:0"; break;
1416	case CHROMA_420: std::cout << " 4:2:0"; break;
1417	case CHROMA_422: std::cout << " 4:2:2"; break;
1418	case CHROMA_444: std::cout << " 4:4:4"; break;
1419	default:
1420	std::cerr << "Invalid";
1421	exit(1);
1422	}
1423	std::cout << std::endl;
1424
1425	#if NH_MV
1426	for (Int i = 0; i < m_numberOfLayers; i++)
1427	{
1428	std::cout << "Layer " << i << std::setw( 43 - (i > 9 ? 6 : 7) ) << "Internal ChromaFormatIDC = ";
1429	switch (m_acTEncTopList[i]->getChromaFormatIdc())
1430	#else
1431	std::cout << std::setw(43) << "Output (internal) ChromaFormatIDC = ";
1432	switch (m_cTEncTop.getChromaFormatIdc())
1433	#endif
1434	{
1435	case CHROMA_400: std::cout << " 4:0:0"; break;
1436	case CHROMA_420: std::cout << " 4:2:0"; break;
1437	case CHROMA_422: std::cout << " 4:2:2"; break;
1438	case CHROMA_444: std::cout << " 4:4:4"; break;
1439	default:
1440	std::cerr << "Invalid";
1441	exit(1);
1442	}
1443	#if NH_MV
1444	std::cout << std::endl;
1445	}
1446	#endif
1447	std::cout << "\n" << std::endl;
1448	}
1449
1450	#if NH_3D_DLT
1451	Void TAppEncTop::xAnalyzeInputBaseDepth(UInt layer, UInt uiNumFrames, TComVPS* vps, TComDLT* dlt)
1452	{
1453	TComPicYuv* pcDepthPicYuvOrg = new TComPicYuv;
1454	TComPicYuv* pcDepthPicYuvTrueOrg = new TComPicYuv;
1455	// allocate original YUV buffer
1456	pcDepthPicYuvOrg->create( m_iSourceWidth, m_iSourceHeight, CHROMA_420, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, false );
1457	pcDepthPicYuvTrueOrg->create( m_iSourceWidth, m_iSourceHeight, CHROMA_420, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, false );
1458
1459	TVideoIOYuv* depthVideoFile = new TVideoIOYuv;
1460
1461	UInt uiMaxDepthValue = ((1 << m_inputBitDepth[CHANNEL_TYPE_LUMA])-1);
1462
1463	std::vector<Bool> abValidDepths(256, false);
1464
1465	depthVideoFile->open( m_pchInputFileList[layer], false, m_inputBitDepth, m_MSBExtendedBitDepth, m_internalBitDepth );
1466
1467	Int iHeight = pcDepthPicYuvOrg->getHeight(COMPONENT_Y);
1468	Int iWidth = pcDepthPicYuvOrg->getWidth(COMPONENT_Y);
1469	Int iStride = pcDepthPicYuvOrg->getStride(COMPONENT_Y);
1470
1471	Pel* pInDM = pcDepthPicYuvOrg->getAddr(COMPONENT_Y);
1472
1473	for(Int uiFrame=0; uiFrame < uiNumFrames; uiFrame++ )
1474	{
1475	depthVideoFile->read( pcDepthPicYuvOrg, pcDepthPicYuvTrueOrg, IPCOLOURSPACE_UNCHANGED, m_aiPad, m_InputChromaFormatIDC, m_bClipInputVideoToRec709Range );
1476
1477	// check all pixel values
1478	for (Int i=0; i<iHeight; i++)
1479	{
1480	Int rowOffset = i*iStride;
1481
1482	for (Int j=0; j<iWidth; j++)
1483	{
1484	Pel depthValue = pInDM[rowOffset+j];
1485	abValidDepths[depthValue] = true;
1486	}
1487	}
1488	}
1489
1490	depthVideoFile->close();
1491	delete depthVideoFile;
1492
1493	pcDepthPicYuvOrg->destroy();
1494	delete pcDepthPicYuvOrg;
1495	pcDepthPicYuvTrueOrg->destroy();
1496	delete pcDepthPicYuvTrueOrg;
1497
1498	// convert boolean array to idx2Depth LUT
1499	std::vector<Int> aiIdx2DepthValue(256, 0);
1500	Int iNumDepthValues = 0;
1501	for(Int p=0; p<=uiMaxDepthValue; p++)
1502	{
1503	if( abValidDepths[p] == true)
1504	{
1505	aiIdx2DepthValue[iNumDepthValues++] = p;
1506	}
1507	}
1508
1509	if( uiNumFrames == 0 \|\| gCeilLog2(iNumDepthValues) == m_inputBitDepth[CHANNEL_TYPE_LUMA] )
1510	{
1511	dlt->setUseDLTFlag(layer, false);
1512	}
1513
1514	// assign LUT
1515	if( dlt->getUseDLTFlag(layer) )
1516	{
1517	dlt->setDepthLUTs(layer, aiIdx2DepthValue, iNumDepthValues);
1518	}
1519	}
1520	#endif
1521
1522	#if NH_MV
1523	Void TAppEncTop::xSetDimensionIdAndLength( TComVPS& vps )
1524	{
1525	vps.setScalabilityMaskFlag( m_scalabilityMask );
1526	for( Int dim = 0; dim < m_dimIds.size(); dim++ )
1527	{
1528	vps.setDimensionIdLen( dim, m_dimensionIdLen[ dim ] );
1529	for( Int layer = 0; layer <= vps.getMaxLayersMinus1(); layer++ )
1530	{
1531	vps.setDimensionId( layer, dim, m_dimIds[ dim ][ layer ] );
1532	}
1533	}
1534
1535	vps.initNumViews();
1536	Int maxViewId = xGetMax( m_viewId );
1537
1538	Int viewIdLen = gCeilLog2( maxViewId + 1 );
1539	const Int maxViewIdLen = ( 1 << 4 ) - 1;
1540	assert( viewIdLen <= maxViewIdLen );
1541	vps.setViewIdLen( viewIdLen );
1542	for (Int i = 0; i < m_iNumberOfViews; i++)
1543	{
1544	vps.setViewIdVal( i, m_viewId[ i] );
1545	}
1546
1547	assert( m_iNumberOfViews == vps.getNumViews() );
1548
1549
1550	#if NH_3D
1551	vps.initViewCompLayer( );
1552	#endif
1553	}
1554
1555	Void TAppEncTop::xSetDependencies( TComVPS& vps )
1556	{
1557	// Direct dependency flags + dependency types
1558	for( Int depLayer = 1; depLayer < MAX_NUM_LAYERS; depLayer++ )
1559	{
1560	for( Int refLayer = 0; refLayer < MAX_NUM_LAYERS; refLayer++ )
1561	{
1562	vps.setDirectDependencyFlag( depLayer, refLayer, false);
1563	vps.setDirectDependencyType( depLayer, refLayer, -1 );
1564	}
1565	}
1566
1567	Int defaultDirectDependencyType = -1;
1568	Bool defaultDirectDependencyFlag = false;
1569
1570	Int directDepTypeLenMinus2 = 0;
1571	for( Int depLayer = 1; depLayer < m_numberOfLayers; depLayer++ )
1572	{
1573	Int numRefLayers = (Int) m_directRefLayers[depLayer].size();
1574	assert( numRefLayers == (Int) m_dependencyTypes[depLayer].size() );
1575	for( Int i = 0; i < numRefLayers; i++ )
1576	{
1577	Int refLayer = m_directRefLayers[depLayer][i];
1578	vps.setDirectDependencyFlag( depLayer, refLayer, true);
1579	Int curDirectDependencyType = m_dependencyTypes[depLayer][i];
1580	directDepTypeLenMinus2 = std::max( directDepTypeLenMinus2, gCeilLog2( curDirectDependencyType + 1 ) - 2 );
1581	if ( defaultDirectDependencyType != -1 )
1582	{
1583	defaultDirectDependencyFlag = defaultDirectDependencyFlag && (curDirectDependencyType == defaultDirectDependencyType );
1584	}
1585	else
1586	{
1587	defaultDirectDependencyType = curDirectDependencyType;
1588	defaultDirectDependencyFlag = true;
1589	}
1590
1591	vps.setDirectDependencyType( depLayer, refLayer, curDirectDependencyType);
1592	}
1593	}
1594
1595	vps.setDefaultDirectDependencyFlag( defaultDirectDependencyFlag );
1596	vps.setDefaultDirectDependencyType( defaultDirectDependencyFlag ? defaultDirectDependencyType : -1 );
1597
1598	assert( directDepTypeLenMinus2 <= 1 );
1599	vps.setDirectDepTypeLenMinus2( directDepTypeLenMinus2 );
1600
1601
1602	vps.setRefLayers();
1603
1604	// Max sub layers, + presence flag
1605	Bool subLayersMaxMinus1PresentFlag = false;
1606	for (Int curLayerIdInVps = 0; curLayerIdInVps < m_numberOfLayers; curLayerIdInVps++ )
1607	{
1608	Int curSubLayersMaxMinus1 = 0;
1609	for( Int i = 0; i < getGOPSize(); i++ )
1610	{
1611	GOPEntry geCur = m_GOPListMvc[curLayerIdInVps][i];
1612	curSubLayersMaxMinus1 = std::max( curSubLayersMaxMinus1, geCur.m_temporalId );
1613	}
1614
1615	vps.setSubLayersVpsMaxMinus1( curLayerIdInVps, curSubLayersMaxMinus1 );
1616	subLayersMaxMinus1PresentFlag = subLayersMaxMinus1PresentFlag \|\| ( curSubLayersMaxMinus1 != vps.getMaxSubLayersMinus1() );
1617	}
1618
1619	vps.setVpsSubLayersMaxMinus1PresentFlag( subLayersMaxMinus1PresentFlag );
1620
1621	// Max temporal id for inter layer reference pictures
1622	for ( Int refLayerIdInVps = 0; refLayerIdInVps < m_numberOfLayers; refLayerIdInVps++)
1623	{
1624	Int refLayerIdInNuh = vps.getLayerIdInNuh( refLayerIdInVps );
1625	for ( Int curLayerIdInVps = 1; curLayerIdInVps < m_numberOfLayers; curLayerIdInVps++)
1626	{
1627	Int curLayerIdInNuh = vps.getLayerIdInNuh( curLayerIdInVps );
1628	Int maxTid = -1;
1629	#if NH_3D
1630	if ( vps.getDirectDependencyFlag( curLayerIdInVps, refLayerIdInVps ) )
1631	{
1632	if ( m_depthFlag[ curLayerIdInVps] == m_depthFlag[ refLayerIdInVps ] )
1633	{
1634	#endif
1635	for( Int i = 0; i < ( getGOPSize() + 1); i++ )
1636	{
1637	GOPEntry geCur = m_GOPListMvc[curLayerIdInVps][( i < getGOPSize() ? i : MAX_GOP )];
1638	GOPEntry geRef = m_GOPListMvc[refLayerIdInVps][( i < getGOPSize() ? i : MAX_GOP )];
1639	for (Int j = 0; j < geCur.m_numActiveRefLayerPics; j++)
1640	{
1641	#if NH_3D
1642	if ( vps.getIdRefListLayer( curLayerIdInNuh, geCur.m_interLayerPredLayerIdc[ j ] ) == refLayerIdInNuh )
1643	#else
1644	if ( vps.getIdDirectRefLayer( curLayerIdInNuh, geCur.m_interLayerPredLayerIdc[ j ] ) == refLayerIdInNuh )
1645	#endif
1646	{
1647	Bool refLayerZero = ( i == getGOPSize() ) && ( refLayerIdInVps == 0 );
1648	maxTid = std::max( maxTid, refLayerZero ? 0 : geRef.m_temporalId );
1649	}
1650	}
1651	}
1652	#if NH_3D
1653	}
1654	else
1655	{
1656	if( m_depthFlag[ curLayerIdInVps ] && ( m_mpiFlag\|\| m_qtPredFlag \|\| m_intraContourFlag ) )
1657	{
1658	Int nuhLayerIdTex = vps.getLayerIdInNuh( vps.getViewIndex( curLayerIdInNuh ), false );
1659	if ( nuhLayerIdTex == refLayerIdInNuh )
1660	{
1661	for( Int i = 0; i < ( getGOPSize() + 1); i++ )
1662	{
1663	GOPEntry geCur = m_GOPListMvc[curLayerIdInVps][( i < getGOPSize() ? i : MAX_GOP )];
1664	GOPEntry geRef = m_GOPListMvc[refLayerIdInVps][( i < getGOPSize() ? i : MAX_GOP )];
1665	if ( geCur.m_interCompPredFlag )
1666	{
1667	Bool refLayerZero = ( i == getGOPSize() ) && ( refLayerIdInVps == 0 );
1668	maxTid = std::max( maxTid, refLayerZero ? 0 : geRef.m_temporalId );
1669	}
1670	}
1671	}
1672	}
1673	if( !m_depthFlag[ curLayerIdInVps ] && vps.getNumRefListLayers( curLayerIdInNuh) > 0 && ( m_depthRefinementFlag \|\| m_viewSynthesisPredFlag \|\| m_depthBasedBlkPartFlag ) )
1674	{
1675	for( Int i = 0; i < ( getGOPSize() + 1); i++ )
1676	{
1677	GOPEntry geCur = m_GOPListMvc[curLayerIdInVps][( i < getGOPSize() ? i : MAX_GOP )];
1678	GOPEntry geRef = m_GOPListMvc[refLayerIdInVps][( i < getGOPSize() ? i : MAX_GOP )];
1679
1680	if ( geCur.m_interCompPredFlag )
1681	{
1682	for (Int j = 0; j < geCur.m_numActiveRefLayerPics; j++ )
1683	{
1684	Int nuhLayerIdDep = vps.getLayerIdInNuh( vps.getViewIndex( vps.getIdRefListLayer( curLayerIdInNuh, geCur.m_interLayerPredLayerIdc[j] ) ), true );
1685	if ( nuhLayerIdDep == refLayerIdInNuh )
1686	{
1687	Bool refLayerZero = ( i == getGOPSize() ) && ( refLayerIdInVps == 0 );
1688	maxTid = std::max( maxTid, refLayerZero ? 0 : geRef.m_temporalId );
1689	}
1690	}
1691	}
1692	}
1693	}
1694	}
1695	} // if ( vps.getDirectDependencyFlag( curLayerIdInVps, refLayerIdInVps ) )
1696	vps.setMaxTidIlRefPicsPlus1( refLayerIdInVps, curLayerIdInVps, maxTid + 1 );
1697	#endif
1698	} // Loop curLayerIdInVps
1699	} // Loop refLayerIdInVps
1700
1701	// Max temporal id for inter layer reference pictures presence flag
1702	Bool maxTidRefPresentFlag = false;
1703	for ( Int refLayerIdInVps = 0; refLayerIdInVps < m_numberOfLayers; refLayerIdInVps++)
1704	{
1705	for ( Int curLayerIdInVps = 1; curLayerIdInVps < m_numberOfLayers; curLayerIdInVps++)
1706	{
1707	maxTidRefPresentFlag = maxTidRefPresentFlag \|\| ( vps.getMaxTidIlRefPicsPlus1( refLayerIdInVps, curLayerIdInVps ) != 7 );
1708	}
1709	}
1710	vps.setMaxTidRefPresentFlag( maxTidRefPresentFlag );
1711
1712
1713	// Max one active ref layer flag
1714	Bool maxOneActiveRefLayerFlag = true;
1715	for ( Int layerIdInVps = 1; layerIdInVps < m_numberOfLayers && maxOneActiveRefLayerFlag; layerIdInVps++)
1716	{
1717	for( Int i = 0; i < ( getGOPSize() + 1) && maxOneActiveRefLayerFlag; i++ )
1718	{
1719	GOPEntry ge = m_GOPListMvc[layerIdInVps][ ( i < getGOPSize() ? i : MAX_GOP ) ];
1720	maxOneActiveRefLayerFlag = maxOneActiveRefLayerFlag && (ge.m_numActiveRefLayerPics <= 1);
1721	}
1722	}
1723
1724	vps.setMaxOneActiveRefLayerFlag( maxOneActiveRefLayerFlag );
1725
1726	// Poc Lsb Not Present Flag
1727	for ( Int layerIdInVps = 1; layerIdInVps < m_numberOfLayers; layerIdInVps++)
1728	{
1729	if ( m_directRefLayers[ layerIdInVps ].size() == 0 )
1730	{
1731	vps.setPocLsbNotPresentFlag( layerIdInVps, true );
1732	}
1733	}
1734
1735	// All Ref layers active flag
1736	Bool allRefLayersActiveFlag = true;
1737	for ( Int layerIdInVps = 1; layerIdInVps < m_numberOfLayers && allRefLayersActiveFlag; layerIdInVps++)
1738	{
1739	Int layerIdInNuh = vps.getLayerIdInNuh( layerIdInVps );
1740	for( Int i = 0; i < ( getGOPSize() + 1) && allRefLayersActiveFlag; i++ )
1741	{
1742	GOPEntry ge = m_GOPListMvc[layerIdInVps][ ( i < getGOPSize() ? i : MAX_GOP ) ];
1743	Int tId = ge.m_temporalId; // Should be equal for all layers.
1744
1745	// check if all reference layers when allRefLayerActiveFlag is equal to 1 are reference layer pictures specified in the gop entry
1746	#if NH_3D
1747	for (Int k = 0; k < vps.getNumRefListLayers( layerIdInNuh ) && allRefLayersActiveFlag; k++ )
1748	{
1749	Int refLayerIdInVps = vps.getLayerIdInVps( vps.getIdRefListLayer( layerIdInNuh , k ) );
1750	#else
1751	for (Int k = 0; k < vps.getNumDirectRefLayers( layerIdInNuh ) && allRefLayersActiveFlag; k++ )
1752	{
1753	Int refLayerIdInVps = vps.getLayerIdInVps( vps.getIdDirectRefLayer( layerIdInNuh , k ) );
1754	#endif
1755	if ( vps.getSubLayersVpsMaxMinus1(refLayerIdInVps) >= tId && ( tId == 0 \|\| vps.getMaxTidIlRefPicsPlus1(refLayerIdInVps,layerIdInVps) > tId ) )
1756	{
1757	Bool gopEntryFoundFlag = false;
1758	for( Int l = 0; l < ge.m_numActiveRefLayerPics && !gopEntryFoundFlag; l++ )
1759	{
1760	gopEntryFoundFlag = gopEntryFoundFlag \|\| ( ge.m_interLayerPredLayerIdc[l] == k );
1761	}
1762	allRefLayersActiveFlag = allRefLayersActiveFlag && gopEntryFoundFlag;
1763	}
1764	}
1765
1766	// check if all inter layer reference pictures specified in the gop entry are valid reference layer pictures when allRefLayerActiveFlag is equal to 1
1767	// (Should actually always be true)
1768	Bool maxTidIlRefAndSubLayerMaxVaildFlag = true;
1769	for( Int l = 0; l < ge.m_numActiveRefLayerPics; l++ )
1770	{
1771	Bool referenceLayerFoundFlag = false;
1772	#if NH_3D
1773	for (Int k = 0; k < vps.getNumRefListLayers( layerIdInNuh ); k++ )
1774	{
1775	Int refLayerIdInVps = vps.getLayerIdInVps( vps.getIdRefListLayer( layerIdInNuh, k) );
1776	#else
1777	for (Int k = 0; k < vps.getNumDirectRefLayers( layerIdInNuh ); k++ )
1778	{
1779	Int refLayerIdInVps = vps.getLayerIdInVps( vps.getIdDirectRefLayer( layerIdInNuh, k) );
1780	#endif
1781	if ( vps.getSubLayersVpsMaxMinus1(refLayerIdInVps) >= tId && ( tId == 0 \|\| vps.getMaxTidIlRefPicsPlus1(refLayerIdInVps,layerIdInVps) > tId ) )
1782	{
1783	referenceLayerFoundFlag = referenceLayerFoundFlag \|\| ( ge.m_interLayerPredLayerIdc[l] == k );
1784	}
1785	}
1786	maxTidIlRefAndSubLayerMaxVaildFlag = maxTidIlRefAndSubLayerMaxVaildFlag && referenceLayerFoundFlag;
1787	}
1788	assert ( maxTidIlRefAndSubLayerMaxVaildFlag ); // Something wrong with MaxTidIlRefPicsPlus1 or SubLayersVpsMaxMinus1
1789	}
1790	}
1791
1792	vps.setAllRefLayersActiveFlag( allRefLayersActiveFlag );
1793	};
1794
1795
1796	GOPEntry* TAppEncTop::xGetGopEntry( Int layerIdInVps, Int poc )
1797	{
1798	GOPEntry* geFound = NULL;
1799	for( Int i = 0; i < ( getGOPSize() + 1) && geFound == NULL ; i++ )
1800	{
1801	GOPEntry* ge = &(m_GOPListMvc[layerIdInVps][ ( i < getGOPSize() ? i : MAX_GOP ) ]);
1802	if ( ge->m_POC == poc )
1803	{
1804	geFound = ge;
1805	}
1806	}
1807	assert( geFound != NULL );
1808	return geFound;
1809	}
1810
1811
1812	Void TAppEncTop::xSetTimingInfo( TComVPS& vps )
1813	{
1814	vps.getTimingInfo()->setTimingInfoPresentFlag( false );
1815	}
1816
1817	Void TAppEncTop::xSetHrdParameters( TComVPS& vps )
1818	{
1819	vps.createHrdParamBuffer();
1820	for( Int i = 0; i < vps.getNumHrdParameters(); i++ )
1821	{
1822	vps.setHrdOpSetIdx( 0, i );
1823	vps.setCprmsPresentFlag( false, i );
1824	}
1825	}
1826
1827	Void TAppEncTop::xSetLayerIds( TComVPS& vps )
1828	{
1829	vps.setSplittingFlag ( m_splittingFlag );
1830
1831	Bool nuhLayerIdPresentFlag = false;
1832
1833
1834	vps.setVpsMaxLayerId( xGetMax( m_layerIdInNuh ) );
1835
1836	for (Int i = 0; i < m_numberOfLayers; i++)
1837	{
1838	nuhLayerIdPresentFlag = nuhLayerIdPresentFlag \|\| ( m_layerIdInNuh[i] != i );
1839	}
1840
1841	vps.setVpsNuhLayerIdPresentFlag( nuhLayerIdPresentFlag );
1842
1843	for (Int layer = 0; layer < m_numberOfLayers; layer++ )
1844	{
1845	vps.setLayerIdInNuh( layer, nuhLayerIdPresentFlag ? m_layerIdInNuh[ layer ] : layer );
1846	vps.setLayerIdInVps( vps.getLayerIdInNuh( layer ), layer );
1847	}
1848	}
1849
1850	Int TAppEncTop::xGetMax( std::vector<Int>& vec )
1851	{
1852	Int maxVec = 0;
1853	for ( Int i = 0; i < vec.size(); i++)
1854	{
1855	maxVec = max( vec[i], maxVec );
1856	}
1857	return maxVec;
1858	}
1859
1860	Void TAppEncTop::xSetProfileTierLevel( TComVPS& vps )
1861	{
1862
1863	// SET PTL
1864	assert( m_profiles.size() == m_level.size() && m_profiles.size() == m_levelTier.size() );
1865	vps.setVpsNumProfileTierLevelMinus1( (Int) m_profiles.size() - 1 );
1866	for ( Int ptlIdx = 0; ptlIdx <= vps.getVpsNumProfileTierLevelMinus1(); ptlIdx++ )
1867	{
1868	if ( ptlIdx > 1 )
1869	{
1870	Bool vpsProfilePresentFlag = ( m_profiles[ptlIdx] != m_profiles[ptlIdx - 1] )
1871	\|\| ( m_inblFlag[ptlIdx ] != m_inblFlag[ptlIdx - 1] );
1872	vps.setVpsProfilePresentFlag( ptlIdx, vpsProfilePresentFlag );
1873	}
1874
1875	xSetProfileTierLevel( vps, ptlIdx, -1, m_profiles[ptlIdx], m_level[ptlIdx],
1876	m_levelTier[ ptlIdx ], m_progressiveSourceFlag, m_interlacedSourceFlag,
1877	m_nonPackedConstraintFlag, m_frameOnlyConstraintFlag, m_inblFlag[ptlIdx] );
1878	}
1879	}
1880
1881	Void TAppEncTop::xSetProfileTierLevel(TComVPS& vps, Int profileTierLevelIdx, Int subLayer, Profile::Name profile, Level::Name level, Level::Tier tier, Bool progressiveSourceFlag, Bool interlacedSourceFlag, Bool nonPackedConstraintFlag, Bool frameOnlyConstraintFlag, Bool inbldFlag)
1882	{
1883	TComPTL* ptlStruct = vps.getPTL( profileTierLevelIdx );
1884	assert( ptlStruct != NULL );
1885
1886	ProfileTierLevel* ptl;
1887	if ( subLayer == -1 )
1888	{
1889	ptl = ptlStruct->getGeneralPTL();
1890	}
1891	else
1892	{
1893	ptl = ptlStruct->getSubLayerPTL( subLayer );
1894	}
1895
1896	assert( ptl != NULL );
1897
1898	ptl->setProfileIdc( profile );
1899	ptl->setTierFlag ( tier );
1900	ptl->setLevelIdc ( level );
1901	ptl->setProfileCompatibilityFlag( profile, true );
1902	ptl->setInbldFlag( inbldFlag );
1903
1904	switch ( profile )
1905	{
1906	case Profile::MAIN:
1907	break;
1908	case Profile::MULTIVIEWMAIN:
1909	#if NH_3D
1910	case Profile::MAIN3D:
1911	#endif
1912	ptl->setMax12bitConstraintFlag ( true );
1913	ptl->setMax12bitConstraintFlag ( true );
1914	ptl->setMax10bitConstraintFlag ( true );
1915	ptl->setMax8bitConstraintFlag ( true );
1916	ptl->setMax422chromaConstraintFlag ( true );
1917	ptl->setMax420chromaConstraintFlag ( true );
1918	ptl->setMaxMonochromeConstraintFlag ( false );
1919	ptl->setIntraConstraintFlag ( false );
1920	ptl->setOnePictureOnlyConstraintFlag( false );
1921	ptl->setLowerBitRateConstraintFlag ( true );
1922	break;
1923	default:
1924	assert( 0 ); // other profiles currently not supported
1925	break;
1926	}
1927	}
1928
1929	Void TAppEncTop::xSetRepFormat( TComVPS& vps )
1930	{
1931
1932	Bool anyDepth = false;
1933	#if NH_3D
1934	for ( Int i = 0; i < m_numberOfLayers; i++ )
1935	{
1936	vps.setVpsRepFormatIdx( i, m_depthFlag[ i ] ? 1 : 0 );
1937	anyDepth = anyDepth \|\| m_depthFlag[ i ];
1938	}
1939	#endif
1940
1941	vps.setRepFormatIdxPresentFlag( anyDepth );
1942	vps.setVpsNumRepFormatsMinus1 ( anyDepth ? 1 : 0 );
1943
1944
1945	std::vector<TComRepFormat> repFormat;
1946	repFormat.resize( vps.getVpsNumRepFormatsMinus1() + 1 );
1947	for ( Int j = 0; j <= vps.getVpsNumRepFormatsMinus1(); j++ )
1948	{
1949	repFormat[j].setBitDepthVpsChromaMinus8 ( m_internalBitDepth[CHANNEL_TYPE_LUMA ] - 8 );
1950	repFormat[j].setBitDepthVpsLumaMinus8 ( m_internalBitDepth[CHANNEL_TYPE_CHROMA] - 8 );
1951	repFormat[j].setChromaFormatVpsIdc ( j == 1 ? CHROMA_400 : CHROMA_420 );
1952	repFormat[j].setPicHeightVpsInLumaSamples ( m_iSourceHeight );
1953	repFormat[j].setPicWidthVpsInLumaSamples ( m_iSourceWidth );
1954	repFormat[j].setChromaAndBitDepthVpsPresentFlag( true );
1955	// ToDo not supported yet.
1956	//repFormat->setSeparateColourPlaneVpsFlag( );
1957
1958	repFormat[j].setConformanceWindowVpsFlag( true );
1959	repFormat[j].setConfWinVpsLeftOffset ( m_confWinLeft / TComSPS::getWinUnitX( repFormat[j].getChromaFormatVpsIdc() ) );
1960	repFormat[j].setConfWinVpsRightOffset ( m_confWinRight / TComSPS::getWinUnitX( repFormat[j].getChromaFormatVpsIdc() ) );
1961	repFormat[j].setConfWinVpsTopOffset ( m_confWinTop / TComSPS::getWinUnitY( repFormat[j].getChromaFormatVpsIdc() ) );
1962	repFormat[j].setConfWinVpsBottomOffset ( m_confWinBottom / TComSPS::getWinUnitY( repFormat[j].getChromaFormatVpsIdc() ) );
1963	}
1964
1965	vps.setRepFormat( repFormat );
1966
1967	}
1968
1969	Void TAppEncTop::xSetDpbSize ( TComVPS& vps )
1970	{
1971	// These settings need to be verified
1972
1973	TComDpbSize dpbSize;
1974	dpbSize.init( vps.getNumOutputLayerSets(), vps.getVpsMaxLayerId() + 1, vps.getMaxSubLayersMinus1() + 1 ) ;
1975
1976
1977	for( Int i = 0; i < vps.getNumOutputLayerSets(); i++ )
1978	{
1979	Int currLsIdx = vps.olsIdxToLsIdx( i );
1980	Bool subLayerFlagInfoPresentFlag = false;
1981
1982	for( Int j = 0; j <= vps.getMaxSubLayersInLayerSetMinus1( currLsIdx ); j++ )
1983	{
1984	Bool subLayerDpbInfoPresentFlag = false;
1985	for( Int k = 0; k < vps.getNumLayersInIdList( currLsIdx ); k++ )
1986	{
1987	Int layerIdInVps = vps.getLayerIdInVps( vps.getLayerSetLayerIdList( currLsIdx, k ) );
1988	if ( vps.getNecessaryLayerFlag( i,k ) && ( vps.getVpsBaseLayerInternalFlag() \|\| vps.getLayerSetLayerIdList( currLsIdx, k ) != 0 ) )
1989	{
1990	dpbSize.setMaxVpsDecPicBufferingMinus1( i, k, j, m_maxDecPicBufferingMvc[ layerIdInVps ][ j ] - 1 );
1991	if ( j > 0 )
1992	{
1993	subLayerDpbInfoPresentFlag = subLayerDpbInfoPresentFlag \|\| ( dpbSize.getMaxVpsDecPicBufferingMinus1( i, k, j ) != dpbSize.getMaxVpsDecPicBufferingMinus1( i, k, j - 1 ) );
1994	}
1995	}
1996	else
1997	{
1998	if (vps.getNecessaryLayerFlag(i,k) && j == 0 && k == 0 )
1999	{
2000	dpbSize.setMaxVpsDecPicBufferingMinus1(i, k ,j, 0 );
2001	}
2002	}
2003	}
2004
2005	Int maxNumReorderPics = MIN_INT;
2006	for ( Int idx = 0; idx < vps.getNumLayersInIdList( currLsIdx ); idx++ )
2007	{
2008	if (vps.getNecessaryLayerFlag(i, idx ))
2009	{
2010	Int layerIdInVps = vps.getLayerIdInVps( vps.getLayerSetLayerIdList(currLsIdx, idx) );
2011	maxNumReorderPics = std::max( maxNumReorderPics, m_numReorderPicsMvc[ layerIdInVps ][ j ] );
2012	}
2013	}
2014	assert( maxNumReorderPics != MIN_INT );
2015
2016	dpbSize.setMaxVpsNumReorderPics( i, j, maxNumReorderPics );
2017	if ( j > 0 )
2018	{
2019	subLayerDpbInfoPresentFlag = subLayerDpbInfoPresentFlag \|\| ( dpbSize.getMaxVpsNumReorderPics( i, j ) != dpbSize.getMaxVpsNumReorderPics( i, j - 1 ) );
2020	}
2021
2022	// To Be Done !
2023	// dpbSize.setMaxVpsLatencyIncreasePlus1( i, j, xx );
2024	if ( j > 0 )
2025	{
2026	subLayerDpbInfoPresentFlag = subLayerDpbInfoPresentFlag \|\| ( dpbSize.getMaxVpsLatencyIncreasePlus1( i, j ) != dpbSize.getMaxVpsLatencyIncreasePlus1( i, j - 1 ) );
2027	}
2028
2029	if( j > 0 )
2030	{
2031	dpbSize.setSubLayerDpbInfoPresentFlag( i, j, subLayerDpbInfoPresentFlag );
2032	subLayerFlagInfoPresentFlag = subLayerFlagInfoPresentFlag \|\| subLayerDpbInfoPresentFlag;
2033	}
2034	}
2035	dpbSize.setSubLayerFlagInfoPresentFlag( i, subLayerFlagInfoPresentFlag );
2036	}
2037	vps.setDpbSize( dpbSize );
2038	}
2039
2040	Void TAppEncTop::xSetLayerSets( TComVPS& vps )
2041	{
2042	// Layer sets
2043	vps.setVpsNumLayerSetsMinus1 ( m_vpsNumLayerSets - 1 );
2044
2045	for (Int lsIdx = 0; lsIdx < m_vpsNumLayerSets; lsIdx++ )
2046	{
2047	for( Int layerId = 0; layerId < MAX_NUM_LAYER_IDS; layerId++ )
2048	{
2049	vps.setLayerIdIncludedFlag( false, lsIdx, layerId );
2050	}
2051	for ( Int i = 0; i < m_layerIdsInSets[lsIdx].size(); i++)
2052	{
2053	vps.setLayerIdIncludedFlag( true, lsIdx, vps.getLayerIdInNuh( m_layerIdsInSets[lsIdx][i] ) );
2054	}
2055	}
2056	vps.deriveLayerSetLayerIdList();
2057
2058	Int numAddOuputLayerSets = (Int) m_outputLayerSetIdx.size();
2059	// Additional output layer sets + profileLevelTierIdx
2060	vps.setDefaultOutputLayerIdc ( m_defaultOutputLayerIdc );
2061	if( vps.getNumIndependentLayers() == 0 && m_numAddLayerSets > 0 )
2062	{
2063	fprintf( stderr, "\nWarning: Ignoring additional layer sets since NumIndependentLayers is equal to 0.\n");
2064	}
2065	else
2066	{
2067	vps.setNumAddLayerSets( m_numAddLayerSets );
2068	if ( m_highestLayerIdxPlus1.size() < vps.getNumAddLayerSets() )
2069	{
2070	fprintf(stderr, "\nError: Number of highestLayerIdxPlus1 parameters must be greater than or equal to NumAddLayerSets\n");
2071	exit(EXIT_FAILURE);
2072	}
2073
2074	for (Int i = 0; i < vps.getNumAddLayerSets(); i++)
2075	{
2076	if ( m_highestLayerIdxPlus1[ i ].size() < vps.getNumIndependentLayers() )
2077	{
2078	fprintf(stderr, "Error: Number of elements in highestLayerIdxPlus1[ %d ] parameters must be greater than or equal to NumIndependentLayers(= %d)\n", i, vps.getNumIndependentLayers());
2079	exit(EXIT_FAILURE);
2080	}
2081
2082	for (Int j = 1; j < vps.getNumIndependentLayers(); j++)
2083	{
2084	if ( m_highestLayerIdxPlus1[ i ][ j ] < 0 \|\| m_highestLayerIdxPlus1[ i ][ j ] > vps.getNumLayersInTreePartition( j ) )
2085	{
2086	fprintf(stderr, "Error: highestLayerIdxPlus1[ %d ][ %d ] shall be in the range of 0 to NumLayersInTreePartition[ %d ] (= %d ), inclusive. \n", i, j, j, vps.getNumLayersInTreePartition( j ) );
2087	exit(EXIT_FAILURE);
2088	}
2089	vps.setHighestLayerIdxPlus1( i, j, m_highestLayerIdxPlus1[ i ][ j ] );
2090	}
2091	vps.deriveAddLayerSetLayerIdList( i );
2092	}
2093	}
2094	vps.setNumAddOlss ( numAddOuputLayerSets );
2095	vps.initTargetLayerIdLists();
2096
2097	for (Int olsIdx = 0; olsIdx < vps.getNumLayerSets() + numAddOuputLayerSets; olsIdx++)
2098	{
2099	Int addOutLsIdx = olsIdx - vps.getNumLayerSets();
2100	vps.setLayerSetIdxForOlsMinus1( olsIdx, ( ( addOutLsIdx < 0 ) ? olsIdx : m_outputLayerSetIdx[ addOutLsIdx ] ) - 1 );
2101
2102	Int lsIdx = vps.olsIdxToLsIdx( olsIdx );
2103	if (vps.getDefaultOutputLayerIdc() == 2 \|\| addOutLsIdx >= 0 )
2104	{
2105	for ( Int i = 0; i < vps.getNumLayersInIdList( lsIdx ); i++)
2106	{
2107	vps.setOutputLayerFlag( olsIdx, i, ( olsIdx == 0 && i == 0 ) ? vps.inferOutputLayerFlag(olsIdx, i ) : false ); // This is a software only fix for a bug in the spec. In spec outputLayerFlag neither present nor inferred for this case !
2108	}
2109
2110	std::vector<Int>& outLayerIdList = ( addOutLsIdx >= 0 ) ? m_layerIdsInAddOutputLayerSet[addOutLsIdx] : m_layerIdsInDefOutputLayerSet[olsIdx];
2111
2112	Bool outputLayerInLayerSetFlag = false;
2113	for (Int j = 0; j < outLayerIdList.size(); j++)
2114	{
2115	for ( Int i = 0; i < vps.getNumLayersInIdList( lsIdx ); i++)
2116	{
2117	if ( vps.getLayerSetLayerIdList( lsIdx, i ) == outLayerIdList[ j ] )
2118	{
2119	vps.setOutputLayerFlag( olsIdx, i, true );
2120	outputLayerInLayerSetFlag = true;
2121	break;
2122	}
2123	}
2124	if ( !outputLayerInLayerSetFlag )
2125	{
2126	fprintf(stderr, "Error: Output layer %d in output layer set %d not in corresponding layer set %d \n", outLayerIdList[ j ], olsIdx , lsIdx );
2127	exit(EXIT_FAILURE);
2128	}
2129	}
2130	}
2131	else
2132	{
2133	for ( Int i = 0; i < vps.getNumLayersInIdList( lsIdx ); i++)
2134	{
2135	vps.setOutputLayerFlag( olsIdx, i, vps.inferOutputLayerFlag( olsIdx, i ) );
2136	}
2137	}
2138
2139	vps.deriveNecessaryLayerFlags( olsIdx );
2140	vps.deriveTargetLayerIdList( olsIdx );
2141
2142	// SET profile_tier_level_index.
2143	if ( olsIdx == 0 )
2144	{
2145	vps.setProfileTierLevelIdx( 0, 0 , vps.getMaxLayersMinus1() > 0 ? 1 : 0 );
2146	}
2147	else
2148	{
2149	if( (Int) m_profileTierLevelIdx[ olsIdx ].size() < vps.getNumLayersInIdList( lsIdx ) )
2150	{
2151	fprintf( stderr, "Warning: Not enough profileTierLevelIdx values given for the %d-th OLS. Inferring default values.\n", olsIdx );
2152	}
2153	for (Int j = 0; j < vps.getNumLayersInIdList( lsIdx ); j++)
2154	{
2155	if( j < (Int) m_profileTierLevelIdx[ olsIdx ].size() )
2156	{
2157	vps.setProfileTierLevelIdx(olsIdx, j, m_profileTierLevelIdx[olsIdx][j] );
2158	if( !vps.getNecessaryLayerFlag(olsIdx,j) && m_profileTierLevelIdx[ olsIdx ][ j ] != -1 )
2159	{
2160	fprintf( stderr, "Warning: The %d-th layer in the %d-th OLS is not necessary such that profileTierLevelIdx[%d][%d] will be ignored. Set value to -1 to suppress warning.\n", j,olsIdx,olsIdx,j );
2161	}
2162	}
2163	else if ( vps.getNecessaryLayerFlag(olsIdx,j) )
2164	{
2165	// setting default values
2166	if ( j == 0 \|\| vps.getVpsNumProfileTierLevelMinus1() < 1 )
2167	{
2168	// set base layer as default
2169	vps.setProfileTierLevelIdx(olsIdx, j, 1 );
2170	}
2171	else
2172	{
2173	// set VpsProfileTierLevel[2] as default
2174	vps.setProfileTierLevelIdx(olsIdx, j, 2 );
2175	}
2176	}
2177	}
2178	}
2179
2180	if ( vps.getNumOutputLayersInOutputLayerSet( olsIdx ) == 1 &&
2181	vps.getNumDirectRefLayers( vps.getOlsHighestOutputLayerId( olsIdx ) ) )
2182	{
2183	vps.setAltOutputLayerFlag( olsIdx , m_altOutputLayerFlag[ olsIdx ]);
2184	}
2185	else
2186	{
2187	vps.setAltOutputLayerFlag( olsIdx , false );
2188	if ( m_altOutputLayerFlag[ olsIdx ] )
2189	{
2190	printf( "\nWarning: Ignoring AltOutputLayerFlag for output layer set %d, since more than one output layer or no dependent layers.\n", olsIdx );
2191	}
2192	}
2193	}
2194	}
2195
2196	Void TAppEncTop::xSetVPSVUI( TComVPS& vps )
2197	{
2198	vps.setVpsVuiPresentFlag( m_vpsVuiPresentFlag );
2199
2200	TComVPSVUI vpsVui;
2201	vpsVui.init(vps.getNumAddLayerSets(),vps.getMaxSubLayersMinus1() + 1, vps.getMaxLayersMinus1() + 1 );
2202
2203	if ( m_vpsVuiPresentFlag )
2204	{
2205	// All this stuff could actually be derived by the encoder,
2206	// however preliminary setting it from input parameters
2207
2208	vpsVui.setCrossLayerPicTypeAlignedFlag( m_crossLayerPicTypeAlignedFlag );
2209	vpsVui.setCrossLayerIrapAlignedFlag ( m_crossLayerIrapAlignedFlag );
2210	vpsVui.setAllLayersIdrAlignedFlag ( m_allLayersIdrAlignedFlag );
2211	vpsVui.setBitRatePresentVpsFlag( m_bitRatePresentVpsFlag );
2212	vpsVui.setPicRatePresentVpsFlag( m_picRatePresentVpsFlag );
2213
2214	if( vpsVui.getBitRatePresentVpsFlag( ) \|\| vpsVui.getPicRatePresentVpsFlag( ) )
2215	{
2216	for( Int i = 0; i < vps.getNumLayerSets(); i++ )
2217	{
2218	for( Int j = 0; j <= vps.getMaxTLayers(); j++ )
2219	{
2220	if( vpsVui.getBitRatePresentVpsFlag( ) && m_bitRatePresentFlag[i].size() > j )
2221	{
2222	vpsVui.setBitRatePresentFlag( i, j, m_bitRatePresentFlag[i][j] );
2223	}
2224	if( vpsVui.getPicRatePresentVpsFlag( ) && m_picRatePresentFlag[i].size() > j )
2225	{
2226	vpsVui.setPicRatePresentFlag( i, j, m_picRatePresentFlag[i][j] );
2227	}
2228	if( vpsVui.getBitRatePresentFlag( i, j ) && m_avgBitRate[i].size() > j )
2229	{
2230	vpsVui.setAvgBitRate( i, j, m_avgBitRate[i][j] );
2231	}
2232	if( vpsVui.getBitRatePresentFlag( i, j ) && m_maxBitRate[i].size() > j )
2233	{
2234	vpsVui.setMaxBitRate( i, j, m_maxBitRate[i][j] );
2235	}
2236	if( vpsVui.getPicRatePresentFlag( i, j ) && m_constantPicRateIdc[i].size() > j )
2237	{
2238	vpsVui.setConstantPicRateIdc( i, j, m_constantPicRateIdc[i][j] );
2239	}
2240	if( vpsVui.getPicRatePresentFlag( i, j ) && m_avgPicRate[i].size() > j )
2241	{
2242	vpsVui.setAvgPicRate( i, j, m_avgPicRate[i][j] );
2243	}
2244	}
2245	}
2246	}
2247
2248	vpsVui.setTilesNotInUseFlag( m_tilesNotInUseFlag );
2249
2250	if( !vpsVui.getTilesNotInUseFlag() )
2251	{
2252	for( Int i = 0; i <= vps.getMaxLayersMinus1(); i++ )
2253	{
2254	vpsVui.setTilesInUseFlag( i, m_tilesInUseFlag[ i ] );
2255	if( vpsVui.getTilesInUseFlag( i ) )
2256	{
2257	vpsVui.setLoopFilterNotAcrossTilesFlag( i, m_loopFilterNotAcrossTilesFlag[ i ] );
2258	}
2259	}
2260
2261	for( Int i = 1; i <= vps.getMaxLayersMinus1(); i++ )
2262	{
2263	for( Int j = 0; j < vps.getNumDirectRefLayers( vps.getLayerIdInNuh( i ) ) ; j++ )
2264	{
2265	Int layerIdx = vps.getLayerIdInVps( vps.getIdDirectRefLayer(vps.getLayerIdInNuh( i ) , j ));
2266	if( vpsVui.getTilesInUseFlag( i ) && vpsVui.getTilesInUseFlag( layerIdx ) )
2267	{
2268	vpsVui.setTileBoundariesAlignedFlag( i, j, m_tileBoundariesAlignedFlag[i][j] );
2269	}
2270	}
2271	}
2272	}
2273
2274	vpsVui.setWppNotInUseFlag( m_wppNotInUseFlag );
2275
2276	if( !vpsVui.getWppNotInUseFlag( ) )
2277	{
2278	for( Int i = 1; i <= vps.getMaxLayersMinus1(); i++ )
2279	{
2280	vpsVui.setWppInUseFlag( i, m_wppInUseFlag[ i ]);
2281	}
2282	}
2283
2284	vpsVui.setSingleLayerForNonIrapFlag( m_singleLayerForNonIrapFlag );
2285	vpsVui.setHigherLayerIrapSkipFlag( m_higherLayerIrapSkipFlag );
2286
2287	vpsVui.setIlpRestrictedRefLayersFlag( m_ilpRestrictedRefLayersFlag );
2288
2289	if( vpsVui.getIlpRestrictedRefLayersFlag( ) )
2290	{
2291	for( Int i = 1; i <= vps.getMaxLayersMinus1(); i++ )
2292	{
2293	for( Int j = 0; j < vps.getNumDirectRefLayers( vps.getLayerIdInNuh( i ) ); j++ )
2294	{
2295	if ( m_minSpatialSegmentOffsetPlus1[i].size() > j )
2296	{
2297	vpsVui.setMinSpatialSegmentOffsetPlus1( i, j, m_minSpatialSegmentOffsetPlus1[i][j] );
2298	}
2299	if( vpsVui.getMinSpatialSegmentOffsetPlus1( i, j ) > 0 )
2300	{
2301	if ( m_ctuBasedOffsetEnabledFlag[i].size() > j )
2302	{
2303	vpsVui.setCtuBasedOffsetEnabledFlag( i, j, m_ctuBasedOffsetEnabledFlag[i][j] );
2304	}
2305	if( vpsVui.getCtuBasedOffsetEnabledFlag( i, j ) )
2306	{
2307	if ( m_minHorizontalCtuOffsetPlus1[i].size() > j )
2308	{
2309	vpsVui.setMinHorizontalCtuOffsetPlus1( i, j, m_minHorizontalCtuOffsetPlus1[i][j] );
2310	}
2311	}
2312	}
2313	}
2314	}
2315	}
2316	vpsVui.setVideoSignalInfoIdxPresentFlag( true );
2317	vpsVui.setVpsNumVideoSignalInfoMinus1 ( 0 );
2318
2319	std::vector<TComVideoSignalInfo> videoSignalInfos;
2320	videoSignalInfos.resize( vpsVui.getVpsNumVideoSignalInfoMinus1() + 1 );
2321
2322	videoSignalInfos[0].setColourPrimariesVps ( m_colourPrimaries );
2323	videoSignalInfos[0].setMatrixCoeffsVps ( m_matrixCoefficients );
2324	videoSignalInfos[0].setTransferCharacteristicsVps( m_transferCharacteristics );
2325	videoSignalInfos[0].setVideoVpsFormat ( m_videoFormat );
2326	videoSignalInfos[0].setVideoFullRangeVpsFlag ( m_videoFullRangeFlag );
2327
2328	vpsVui.setVideoSignalInfo( videoSignalInfos );
2329
2330	for (Int i = 0; i < m_numberOfLayers; i++)
2331	{
2332	vpsVui.setVpsVideoSignalInfoIdx( i, 0 );
2333	}
2334	vpsVui.setVpsVuiBspHrdPresentFlag( false ); // TBD
2335	}
2336	else
2337	{
2338	//Default inference when not present.
2339	vpsVui.setCrossLayerIrapAlignedFlag ( false );
2340	}
2341	vps.setVPSVUI( vpsVui );
2342	}
2343
2344	#if NH_3D
2345	Void TAppEncTop::xSetCamPara ( TComVPS& vps )
2346	{
2347	vps.setCpPrecision( m_cCameraData.getCamParsCodedPrecision());
2348
2349	for ( Int n = 1; n < vps.getNumViews(); n++ )
2350	{
2351	Int i = vps.getViewOIdxList( n );
2352	Int iInVps = vps.getVoiInVps ( i );
2353	vps.setNumCp( iInVps, n);
2354
2355	if ( vps.getNumCp( iInVps ) > 0 )
2356	{
2357	vps.setCpInSliceSegmentHeaderFlag( iInVps, m_cCameraData.getVaryingCameraParameters() );
2358
2359	for( Int m = 0; m < vps.getNumCp( iInVps ); m++ )
2360	{
2361	vps.setCpRefVoi( iInVps, m, vps.getViewOIdxList( m ) );
2362	if( !vps.getCpInSliceSegmentHeaderFlag( iInVps ) )
2363	{
2364	Int j = vps.getCpRefVoi( iInVps, m );
2365	Int jInVps = vps.getVoiInVps( j );
2366
2367	vps.setVpsCpScale ( iInVps, jInVps, m_cCameraData.getCodedScale() [ jInVps ][ iInVps ] ) ;
2368	vps.setVpsCpInvScale( iInVps, jInVps, m_cCameraData.getCodedScale() [ iInVps ][ jInVps ] ) ;
2369	vps.setVpsCpOff ( iInVps, jInVps, m_cCameraData.getCodedOffset()[ jInVps ][ iInVps ] ) ;
2370	vps.setVpsCpInvOff ( iInVps, jInVps, m_cCameraData.getCodedOffset()[ iInVps ][ jInVps ] ) ;
2371	}
2372	}
2373	}
2374	}
2375	vps.deriveCpPresentFlag();
2376	}
2377	#endif
2378
2379
2380	Bool TAppEncTop::xLayerIdInTargetEncLayerIdList(Int nuhLayerId)
2381	{
2382	return ( std::find(m_targetEncLayerIdList.begin(), m_targetEncLayerIdList.end(), nuhLayerId) != m_targetEncLayerIdList.end()) ;
2383	}
2384
2385
2386	#endif
2387
2388
2389	#if NH_3D_DLT
2390	Void TAppEncTop::xDeriveDltArray( TComVPS& vps, TComDLT* dlt )
2391	{
2392	Int iNumDepthViews = 0;
2393	Bool bDltPresentFlag = false;
2394
2395	for ( Int layer = 0; layer <= vps.getMaxLayersMinus1(); layer++ )
2396	{
2397	Bool isDepth = ( vps.getDepthId( layer ) == 1 );
2398
2399	if ( isDepth )
2400	{
2401	iNumDepthViews++;
2402	}
2403
2404	dlt->setUseDLTFlag( layer , isDepth && m_useDLT );
2405	if( dlt->getUseDLTFlag( layer ) )
2406	{
2407	xAnalyzeInputBaseDepth(layer, max(m_iIntraPeriod[layer], 24), &vps, dlt);
2408	bDltPresentFlag = bDltPresentFlag \|\| dlt->getUseDLTFlag(layer);
2409	dlt->setInterViewDltPredEnableFlag(layer, (dlt->getUseDLTFlag(layer) && (layer>1)));
2410
2411	// ----------------------------- determine whether to use bit-map -----------------------------
2412	Bool bDltBitMapRepFlag = false;
2413	UInt uiNumBitsNonBitMap = 0;
2414	UInt uiNumBitsBitMap = 0;
2415
2416	UInt uiMaxDiff = 0;
2417	UInt uiMinDiff = MAX_INT;
2418	UInt uiLengthMinDiff = 0;
2419	UInt uiLengthDltDiffMinusMin = 0;
2420
2421	std::vector<Int> aiIdx2DepthValue_coded(256, 0);
2422	UInt uiNumDepthValues_coded = 0;
2423
2424	uiNumDepthValues_coded = dlt->getNumDepthValues(layer);
2425	for( UInt ui = 0; ui<uiNumDepthValues_coded; ui++ )
2426	{
2427	aiIdx2DepthValue_coded[ui] = dlt->idx2DepthValue(layer, ui);
2428	}
2429
2430	if( dlt->getInterViewDltPredEnableFlag( layer ) )
2431	{
2432	AOF( vps.getDepthId( 1 ) == 1 );
2433	AOF( layer > 1 );
2434	// assumes ref layer id to be 1
2435	std::vector<Int> piRefDLT = dlt->idx2DepthValue( 1 );
2436	UInt uiRefNum = dlt->getNumDepthValues( 1 );
2437	dlt->getDeltaDLT(layer, piRefDLT, uiRefNum, aiIdx2DepthValue_coded, uiNumDepthValues_coded);
2438	}
2439
2440	std::vector<UInt> puiDltDiffValues(uiNumDepthValues_coded, 0);
2441
2442	for (UInt d = 1; d < uiNumDepthValues_coded; d++)
2443	{
2444	puiDltDiffValues[d] = aiIdx2DepthValue_coded[d] - aiIdx2DepthValue_coded[d-1];
2445
2446	if ( uiMaxDiff < puiDltDiffValues[d] )
2447	{
2448	uiMaxDiff = puiDltDiffValues[d];
2449	}
2450
2451	if ( uiMinDiff > puiDltDiffValues[d] )
2452	{
2453	uiMinDiff = puiDltDiffValues[d];
2454	}
2455	}
2456
2457	// counting bits
2458	// diff coding branch
2459	uiNumBitsNonBitMap += 8; // u(v) bits for num_depth_values_in_dlt[layerId] (i.e. num_entry[ layerId ])
2460
2461	if ( uiNumDepthValues_coded > 1 )
2462	{
2463	uiNumBitsNonBitMap += 8; // u(v) bits for max_diff[ layerId ]
2464	}
2465
2466	if ( uiNumDepthValues_coded > 2 )
2467	{
2468	uiLengthMinDiff = (UInt) gCeilLog2(uiMaxDiff + 1);
2469	uiNumBitsNonBitMap += uiLengthMinDiff; // u(v) bits for min_diff[ layerId ]
2470	}
2471
2472	uiNumBitsNonBitMap += 8; // u(v) bits for dlt_depth_value0[ layerId ]
2473
2474	if (uiMaxDiff > uiMinDiff)
2475	{
2476	uiLengthDltDiffMinusMin = (UInt) gCeilLog2(uiMaxDiff - uiMinDiff + 1);
2477	uiNumBitsNonBitMap += uiLengthDltDiffMinusMin * (uiNumDepthValues_coded - 1); // u(v) bits for dlt_depth_value_diff_minus_min[ layerId ][ j ]
2478	}
2479
2480	// bit map branch
2481	uiNumBitsBitMap = 1 << m_inputBitDepth[CHANNEL_TYPE_LUMA];
2482
2483	// determine bDltBitMapFlag
2484	bDltBitMapRepFlag = (uiNumBitsBitMap > uiNumBitsNonBitMap) ? false : true;
2485
2486	dlt->setUseBitmapRep(layer, bDltBitMapRepFlag);
2487	}
2488	}
2489
2490	dlt->setDltPresentFlag( bDltPresentFlag );
2491	dlt->setNumDepthViews ( iNumDepthViews );
2492	dlt->setDepthViewBitDepth( m_inputBitDepth[CHANNEL_TYPE_LUMA] );
2493	}
2494	#endif
2495	//! \}

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-14.1-update-dev1/source/App/TAppEncoder/TAppEncTop.cpp @ 1399

Download in other formats: