Context navigation

TAppEncTop.cpp @ 1341

Visit:

Last change on this file since 1341 was 1328, checked in by tech, 9 years ago

Integrated general SEI changes and following SEIs:

Multiview view position SEI
Multiview acquisition information SEI
Multiview scene information SEI
Inter-layer constrained tile sets SEI

Property svn:eol-style set to native

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

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-15.1-dev0-Disney/source/App/TAppEncoder/TAppEncTop.cpp @ 1341

Download in other formats: