Context navigation

source: SHVCSoftware/trunk/source/Lib/TLibEncoder/TEncGOP.cpp @ 698

Visit:

Last change on this file since 698 was 644, checked in by seregin, 11 years ago
merge with SHM-5.1-dev branch
Property svn:eol-style set to `native`
File size: 147.6 KB

Line
1	/* The copyright in this software is being made available under the BSD
2	* License, included below. This software may be subject to other third party
3	* and contributor rights, including patent rights, and no such rights are
4	* granted under this license.
5	*
6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	* All rights reserved.
8	*
9	* Redistribution and use in source and binary forms, with or without
10	* modification, are permitted provided that the following conditions are met:
11	*
12	* * Redistributions of source code must retain the above copyright notice,
13	* this list of conditions and the following disclaimer.
14	* * Redistributions in binary form must reproduce the above copyright notice,
15	* this list of conditions and the following disclaimer in the documentation
16	* and/or other materials provided with the distribution.
17	* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18	* be used to endorse or promote products derived from this software without
19	* specific prior written permission.
20	*
21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31	* THE POSSIBILITY OF SUCH DAMAGE.
32	*/
33
34	/** \file TEncGOP.cpp
35	\brief GOP encoder class
36	*/
37
38	#include <list>
39	#include <algorithm>
40	#include <functional>
41
42	#include "TEncTop.h"
43	#include "TEncGOP.h"
44	#include "TEncAnalyze.h"
45	#include "libmd5/MD5.h"
46	#include "TLibCommon/SEI.h"
47	#include "TLibCommon/NAL.h"
48	#include "NALwrite.h"
49	#include <time.h>
50	#include <math.h>
51
52	using namespace std;
53	//! \ingroup TLibEncoder
54	//! \{
55
56	// ====================================================================================================================
57	// Constructor / destructor / initialization / destroy
58	// ====================================================================================================================
59	Int getLSB(Int poc, Int maxLSB)
60	{
61	if (poc >= 0)
62	{
63	return poc % maxLSB;
64	}
65	else
66	{
67	return (maxLSB - ((-poc) % maxLSB)) % maxLSB;
68	}
69	}
70
71	TEncGOP::TEncGOP()
72	{
73	m_iLastIDR = 0;
74	m_iGopSize = 0;
75	m_iNumPicCoded = 0; //Niko
76	m_bFirst = true;
77
78	m_pcCfg = NULL;
79	m_pcSliceEncoder = NULL;
80	m_pcListPic = NULL;
81
82	m_pcEntropyCoder = NULL;
83	m_pcCavlcCoder = NULL;
84	m_pcSbacCoder = NULL;
85	m_pcBinCABAC = NULL;
86
87	m_bSeqFirst = true;
88
89	m_bRefreshPending = 0;
90	m_pocCRA = 0;
91	m_numLongTermRefPicSPS = 0;
92	::memset(m_ltRefPicPocLsbSps, 0, sizeof(m_ltRefPicPocLsbSps));
93	::memset(m_ltRefPicUsedByCurrPicFlag, 0, sizeof(m_ltRefPicUsedByCurrPicFlag));
94	m_cpbRemovalDelay = 0;
95	m_lastBPSEI = 0;
96	xResetNonNestedSEIPresentFlags();
97	xResetNestedSEIPresentFlags();
98	#if FIX1172
99	m_associatedIRAPType = NAL_UNIT_CODED_SLICE_IDR_N_LP;
100	m_associatedIRAPPOC = 0;
101	#endif
102	#if SVC_UPSAMPLING
103	m_pcPredSearch = NULL;
104	#endif
105	return;
106	}
107
108	TEncGOP::~TEncGOP()
109	{
110	}
111
112	/** Create list to contain pointers to LCU start addresses of slice.
113	*/
114	#if SVC_EXTENSION
115	Void TEncGOP::create( UInt layerId )
116	{
117	m_bLongtermTestPictureHasBeenCoded = 0;
118	m_bLongtermTestPictureHasBeenCoded2 = 0;
119	m_layerId = layerId;
120	}
121	#else
122	Void TEncGOP::create()
123	{
124	m_bLongtermTestPictureHasBeenCoded = 0;
125	m_bLongtermTestPictureHasBeenCoded2 = 0;
126	}
127	#endif
128
129	Void TEncGOP::destroy()
130	{
131	}
132
133	Void TEncGOP::init ( TEncTop* pcTEncTop )
134	{
135	m_pcEncTop = pcTEncTop;
136	m_pcCfg = pcTEncTop;
137	m_pcSliceEncoder = pcTEncTop->getSliceEncoder();
138	m_pcListPic = pcTEncTop->getListPic();
139
140	m_pcEntropyCoder = pcTEncTop->getEntropyCoder();
141	m_pcCavlcCoder = pcTEncTop->getCavlcCoder();
142	m_pcSbacCoder = pcTEncTop->getSbacCoder();
143	m_pcBinCABAC = pcTEncTop->getBinCABAC();
144	m_pcLoopFilter = pcTEncTop->getLoopFilter();
145	m_pcBitCounter = pcTEncTop->getBitCounter();
146
147	//--Adaptive Loop filter
148	m_pcSAO = pcTEncTop->getSAO();
149	m_pcRateCtrl = pcTEncTop->getRateCtrl();
150	m_lastBPSEI = 0;
151	m_totalCoded = 0;
152
153	#if SVC_EXTENSION
154	m_ppcTEncTop = pcTEncTop->getLayerEnc();
155	#endif
156	#if SVC_UPSAMPLING
157	m_pcPredSearch = pcTEncTop->getPredSearch(); ///< encoder search class
158	#endif
159	}
160
161	SEIActiveParameterSets* TEncGOP::xCreateSEIActiveParameterSets (TComSPS *sps)
162	{
163	SEIActiveParameterSets *seiActiveParameterSets = new SEIActiveParameterSets();
164	seiActiveParameterSets->activeVPSId = m_pcCfg->getVPS()->getVPSId();
165	seiActiveParameterSets->m_fullRandomAccessFlag = false;
166	seiActiveParameterSets->m_noParamSetUpdateFlag = false;
167	seiActiveParameterSets->numSpsIdsMinus1 = 0;
168	seiActiveParameterSets->activeSeqParamSetId.resize(seiActiveParameterSets->numSpsIdsMinus1 + 1);
169	seiActiveParameterSets->activeSeqParamSetId[0] = sps->getSPSId();
170	return seiActiveParameterSets;
171	}
172
173
174	SEIFramePacking* TEncGOP::xCreateSEIFramePacking()
175	{
176	SEIFramePacking *seiFramePacking = new SEIFramePacking();
177	seiFramePacking->m_arrangementId = m_pcCfg->getFramePackingArrangementSEIId();
178	seiFramePacking->m_arrangementCancelFlag = 0;
179	seiFramePacking->m_arrangementType = m_pcCfg->getFramePackingArrangementSEIType();
180	assert((seiFramePacking->m_arrangementType > 2) && (seiFramePacking->m_arrangementType < 6) );
181	seiFramePacking->m_quincunxSamplingFlag = m_pcCfg->getFramePackingArrangementSEIQuincunx();
182	seiFramePacking->m_contentInterpretationType = m_pcCfg->getFramePackingArrangementSEIInterpretation();
183	seiFramePacking->m_spatialFlippingFlag = 0;
184	seiFramePacking->m_frame0FlippedFlag = 0;
185	seiFramePacking->m_fieldViewsFlag = (seiFramePacking->m_arrangementType == 2);
186	seiFramePacking->m_currentFrameIsFrame0Flag = ((seiFramePacking->m_arrangementType == 5) && m_iNumPicCoded&1);
187	seiFramePacking->m_frame0SelfContainedFlag = 0;
188	seiFramePacking->m_frame1SelfContainedFlag = 0;
189	seiFramePacking->m_frame0GridPositionX = 0;
190	seiFramePacking->m_frame0GridPositionY = 0;
191	seiFramePacking->m_frame1GridPositionX = 0;
192	seiFramePacking->m_frame1GridPositionY = 0;
193	seiFramePacking->m_arrangementReservedByte = 0;
194	seiFramePacking->m_arrangementPersistenceFlag = true;
195	seiFramePacking->m_upsampledAspectRatio = 0;
196	return seiFramePacking;
197	}
198
199	SEIDisplayOrientation* TEncGOP::xCreateSEIDisplayOrientation()
200	{
201	SEIDisplayOrientation *seiDisplayOrientation = new SEIDisplayOrientation();
202	seiDisplayOrientation->cancelFlag = false;
203	seiDisplayOrientation->horFlip = false;
204	seiDisplayOrientation->verFlip = false;
205	seiDisplayOrientation->anticlockwiseRotation = m_pcCfg->getDisplayOrientationSEIAngle();
206	return seiDisplayOrientation;
207	}
208
209	SEIToneMappingInfo* TEncGOP::xCreateSEIToneMappingInfo()
210	{
211	SEIToneMappingInfo *seiToneMappingInfo = new SEIToneMappingInfo();
212	seiToneMappingInfo->m_toneMapId = m_pcCfg->getTMISEIToneMapId();
213	seiToneMappingInfo->m_toneMapCancelFlag = m_pcCfg->getTMISEIToneMapCancelFlag();
214	seiToneMappingInfo->m_toneMapPersistenceFlag = m_pcCfg->getTMISEIToneMapPersistenceFlag();
215
216	seiToneMappingInfo->m_codedDataBitDepth = m_pcCfg->getTMISEICodedDataBitDepth();
217	assert(seiToneMappingInfo->m_codedDataBitDepth >= 8 && seiToneMappingInfo->m_codedDataBitDepth <= 14);
218	seiToneMappingInfo->m_targetBitDepth = m_pcCfg->getTMISEITargetBitDepth();
219	assert( seiToneMappingInfo->m_targetBitDepth >= 1 && seiToneMappingInfo->m_targetBitDepth <= 17 );
220	seiToneMappingInfo->m_modelId = m_pcCfg->getTMISEIModelID();
221	assert(seiToneMappingInfo->m_modelId >=0 &&seiToneMappingInfo->m_modelId<=4);
222
223	switch( seiToneMappingInfo->m_modelId)
224	{
225	case 0:
226	{
227	seiToneMappingInfo->m_minValue = m_pcCfg->getTMISEIMinValue();
228	seiToneMappingInfo->m_maxValue = m_pcCfg->getTMISEIMaxValue();
229	break;
230	}
231	case 1:
232	{
233	seiToneMappingInfo->m_sigmoidMidpoint = m_pcCfg->getTMISEISigmoidMidpoint();
234	seiToneMappingInfo->m_sigmoidWidth = m_pcCfg->getTMISEISigmoidWidth();
235	break;
236	}
237	case 2:
238	{
239	UInt num = 1u<<(seiToneMappingInfo->m_targetBitDepth);
240	seiToneMappingInfo->m_startOfCodedInterval.resize(num);
241	Int* ptmp = m_pcCfg->getTMISEIStartOfCodedInterva();
242	if(ptmp)
243	{
244	for(int i=0; i<num;i++)
245	{
246	seiToneMappingInfo->m_startOfCodedInterval[i] = ptmp[i];
247	}
248	}
249	break;
250	}
251	case 3:
252	{
253	seiToneMappingInfo->m_numPivots = m_pcCfg->getTMISEINumPivots();
254	seiToneMappingInfo->m_codedPivotValue.resize(seiToneMappingInfo->m_numPivots);
255	seiToneMappingInfo->m_targetPivotValue.resize(seiToneMappingInfo->m_numPivots);
256	Int* ptmpcoded = m_pcCfg->getTMISEICodedPivotValue();
257	Int* ptmptarget = m_pcCfg->getTMISEITargetPivotValue();
258	if(ptmpcoded&&ptmptarget)
259	{
260	for(int i=0; i<(seiToneMappingInfo->m_numPivots);i++)
261	{
262	seiToneMappingInfo->m_codedPivotValue[i]=ptmpcoded[i];
263	seiToneMappingInfo->m_targetPivotValue[i]=ptmptarget[i];
264	}
265	}
266	break;
267	}
268	case 4:
269	{
270	seiToneMappingInfo->m_cameraIsoSpeedIdc = m_pcCfg->getTMISEICameraIsoSpeedIdc();
271	seiToneMappingInfo->m_cameraIsoSpeedValue = m_pcCfg->getTMISEICameraIsoSpeedValue();
272	assert( seiToneMappingInfo->m_cameraIsoSpeedValue !=0 );
273	seiToneMappingInfo->m_exposureCompensationValueSignFlag = m_pcCfg->getTMISEIExposureCompensationValueSignFlag();
274	seiToneMappingInfo->m_exposureCompensationValueNumerator = m_pcCfg->getTMISEIExposureCompensationValueNumerator();
275	seiToneMappingInfo->m_exposureCompensationValueDenomIdc = m_pcCfg->getTMISEIExposureCompensationValueDenomIdc();
276	seiToneMappingInfo->m_refScreenLuminanceWhite = m_pcCfg->getTMISEIRefScreenLuminanceWhite();
277	seiToneMappingInfo->m_extendedRangeWhiteLevel = m_pcCfg->getTMISEIExtendedRangeWhiteLevel();
278	assert( seiToneMappingInfo->m_extendedRangeWhiteLevel >= 100 );
279	seiToneMappingInfo->m_nominalBlackLevelLumaCodeValue = m_pcCfg->getTMISEINominalBlackLevelLumaCodeValue();
280	seiToneMappingInfo->m_nominalWhiteLevelLumaCodeValue = m_pcCfg->getTMISEINominalWhiteLevelLumaCodeValue();
281	assert( seiToneMappingInfo->m_nominalWhiteLevelLumaCodeValue > seiToneMappingInfo->m_nominalBlackLevelLumaCodeValue );
282	seiToneMappingInfo->m_extendedWhiteLevelLumaCodeValue = m_pcCfg->getTMISEIExtendedWhiteLevelLumaCodeValue();
283	assert( seiToneMappingInfo->m_extendedWhiteLevelLumaCodeValue >= seiToneMappingInfo->m_nominalWhiteLevelLumaCodeValue );
284	break;
285	}
286	default:
287	{
288	assert(!"Undefined SEIToneMapModelId");
289	break;
290	}
291	}
292	return seiToneMappingInfo;
293	}
294
295	Void TEncGOP::xCreateLeadingSEIMessages (/SEIMessages seiMessages,/ AccessUnit &accessUnit, TComSPS *sps)
296	{
297	OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
298
299	if(m_pcCfg->getActiveParameterSetsSEIEnabled())
300	{
301	SEIActiveParameterSets *sei = xCreateSEIActiveParameterSets (sps);
302
303	//nalu = NALUnit(NAL_UNIT_SEI);
304	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
305	#if O0164_MULTI_LAYER_HRD
306	m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, m_pcEncTop->getVPS(), sps);
307	#else
308	m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
309	#endif
310	writeRBSPTrailingBits(nalu.m_Bitstream);
311	accessUnit.push_back(new NALUnitEBSP(nalu));
312	delete sei;
313	m_activeParameterSetSEIPresentInAU = true;
314	}
315
316	if(m_pcCfg->getFramePackingArrangementSEIEnabled())
317	{
318	SEIFramePacking *sei = xCreateSEIFramePacking ();
319
320	nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
321	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
322	#if O0164_MULTI_LAYER_HRD
323	m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, m_pcEncTop->getVPS(), sps);
324	#else
325	m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
326	#endif
327	writeRBSPTrailingBits(nalu.m_Bitstream);
328	accessUnit.push_back(new NALUnitEBSP(nalu));
329	delete sei;
330	}
331	if (m_pcCfg->getDisplayOrientationSEIAngle())
332	{
333	SEIDisplayOrientation *sei = xCreateSEIDisplayOrientation();
334
335	nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
336	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
337	#if O0164_MULTI_LAYER_HRD
338	m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, m_pcEncTop->getVPS(), sps);
339	#else
340	m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
341	#endif
342	writeRBSPTrailingBits(nalu.m_Bitstream);
343	accessUnit.push_back(new NALUnitEBSP(nalu));
344	delete sei;
345	}
346	if(m_pcCfg->getToneMappingInfoSEIEnabled())
347	{
348	SEIToneMappingInfo *sei = xCreateSEIToneMappingInfo ();
349
350	nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
351	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
352	#if O0164_MULTI_LAYER_HRD
353	m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, m_pcEncTop->getVPS(), sps);
354	#else
355	m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
356	#endif
357	writeRBSPTrailingBits(nalu.m_Bitstream);
358	accessUnit.push_back(new NALUnitEBSP(nalu));
359	delete sei;
360	}
361
362	#if SVC_EXTENSION
363	#if LAYERS_NOT_PRESENT_SEI
364	if(m_pcCfg->getLayersNotPresentSEIEnabled())
365	{
366	SEILayersNotPresent *sei = xCreateSEILayersNotPresent ();
367	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
368	#if O0164_MULTI_LAYER_HRD
369	m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, m_pcEncTop->getVPS(), sps);
370	#else
371	m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
372	#endif
373	writeRBSPTrailingBits(nalu.m_Bitstream);
374	accessUnit.push_back(new NALUnitEBSP(nalu));
375	delete sei;
376	}
377	#endif
378
379	#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
380	if(m_pcCfg->getInterLayerConstrainedTileSetsSEIEnabled())
381	{
382	SEIInterLayerConstrainedTileSets *sei = xCreateSEIInterLayerConstrainedTileSets ();
383
384	nalu = NALUnit(NAL_UNIT_PREFIX_SEI, 0, m_pcCfg->getNumLayer()-1); // For highest layer
385	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
386	#if O0164_MULTI_LAYER_HRD
387	m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, m_pcEncTop->getVPS(), sps);
388	#else
389	m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
390	#endif
391	writeRBSPTrailingBits(nalu.m_Bitstream);
392	accessUnit.push_back(new NALUnitEBSP(nalu));
393	delete sei;
394	}
395	#endif
396	#endif //SVC_EXTENSION
397	}
398
399	// ====================================================================================================================
400	// Public member functions
401	// ====================================================================================================================
402	#if SVC_EXTENSION
403	Void TEncGOP::compressGOP( Int iPicIdInGOP, Int iPOCLast, Int iNumPicRcvd, TComList<TComPic>& rcListPic, TComList<TComPicYuv>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsInGOP, Bool isField, Bool isTff)
404	#else
405	Void TEncGOP::compressGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic>& rcListPic, TComList<TComPicYuv>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsInGOP, Bool isField, Bool isTff)
406	#endif
407	{
408	TComPic* pcPic;
409	TComPicYuv* pcPicYuvRecOut;
410	TComSlice* pcSlice;
411	TComOutputBitstream *pcBitstreamRedirect;
412	pcBitstreamRedirect = new TComOutputBitstream;
413	AccessUnit::iterator itLocationToPushSliceHeaderNALU; // used to store location where NALU containing slice header is to be inserted
414	UInt uiOneBitstreamPerSliceLength = 0;
415	TEncSbac* pcSbacCoders = NULL;
416	TComOutputBitstream* pcSubstreamsOut = NULL;
417
418	xInitGOP( iPOCLast, iNumPicRcvd, rcListPic, rcListPicYuvRecOut, isField );
419
420	m_iNumPicCoded = 0;
421	SEIPictureTiming pictureTimingSEI;
422	Bool writeSOP = m_pcCfg->getSOPDescriptionSEIEnabled();
423	// Initialize Scalable Nesting SEI with single layer values
424	SEIScalableNesting scalableNestingSEI;
425	scalableNestingSEI.m_bitStreamSubsetFlag = 1; // If the nested SEI messages are picture buffereing SEI mesages, picure timing SEI messages or sub-picture timing SEI messages, bitstream_subset_flag shall be equal to 1
426	scalableNestingSEI.m_nestingOpFlag = 0;
427	scalableNestingSEI.m_nestingNumOpsMinus1 = 0; //nesting_num_ops_minus1
428	scalableNestingSEI.m_allLayersFlag = 0;
429	scalableNestingSEI.m_nestingNoOpMaxTemporalIdPlus1 = 6 + 1; //nesting_no_op_max_temporal_id_plus1
430	scalableNestingSEI.m_nestingNumLayersMinus1 = 1 - 1; //nesting_num_layers_minus1
431	scalableNestingSEI.m_nestingLayerId[0] = 0;
432	scalableNestingSEI.m_callerOwnsSEIs = true;
433	Int picSptDpbOutputDuDelay = 0;
434	UInt *accumBitsDU = NULL;
435	UInt *accumNalsDU = NULL;
436	SEIDecodingUnitInfo decodingUnitInfoSEI;
437	#if SVC_EXTENSION
438	for ( Int iGOPid=iPicIdInGOP; iGOPid < iPicIdInGOP+1; iGOPid++ )
439	#else
440	for ( Int iGOPid=0; iGOPid < m_iGopSize; iGOPid++ )
441	#endif
442	{
443	UInt uiColDir = 1;
444	//-- For time output for each slice
445	long iBeforeTime = clock();
446
447	//select uiColDir
448	Int iCloseLeft=1, iCloseRight=-1;
449	for(Int i = 0; i<m_pcCfg->getGOPEntry(iGOPid).m_numRefPics; i++)
450	{
451	Int iRef = m_pcCfg->getGOPEntry(iGOPid).m_referencePics[i];
452	if(iRef>0&&(iRef<iCloseRight\|\|iCloseRight==-1))
453	{
454	iCloseRight=iRef;
455	}
456	else if(iRef<0&&(iRef>iCloseLeft\|\|iCloseLeft==1))
457	{
458	iCloseLeft=iRef;
459	}
460	}
461	if(iCloseRight>-1)
462	{
463	iCloseRight=iCloseRight+m_pcCfg->getGOPEntry(iGOPid).m_POC-1;
464	}
465	if(iCloseLeft<1)
466	{
467	iCloseLeft=iCloseLeft+m_pcCfg->getGOPEntry(iGOPid).m_POC-1;
468	while(iCloseLeft<0)
469	{
470	iCloseLeft+=m_iGopSize;
471	}
472	}
473	Int iLeftQP=0, iRightQP=0;
474	for(Int i=0; i<m_iGopSize; i++)
475	{
476	if(m_pcCfg->getGOPEntry(i).m_POC==(iCloseLeft%m_iGopSize)+1)
477	{
478	iLeftQP= m_pcCfg->getGOPEntry(i).m_QPOffset;
479	}
480	if (m_pcCfg->getGOPEntry(i).m_POC==(iCloseRight%m_iGopSize)+1)
481	{
482	iRightQP=m_pcCfg->getGOPEntry(i).m_QPOffset;
483	}
484	}
485	if(iCloseRight>-1&&iRightQP<iLeftQP)
486	{
487	uiColDir=0;
488	}
489
490	/////////////////////////////////////////////////////////////////////////////////////////////////// Initial to start encoding
491	Int iTimeOffset;
492	Int pocCurr;
493
494	if(iPOCLast == 0) //case first frame or first top field
495	{
496	pocCurr=0;
497	iTimeOffset = 1;
498	}
499	else if(iPOCLast == 1 && isField) //case first bottom field, just like the first frame, the poc computation is not right anymore, we set the right value
500	{
501	pocCurr = 1;
502	iTimeOffset = 1;
503	}
504	else
505	{
506	pocCurr = iPOCLast - iNumPicRcvd + m_pcCfg->getGOPEntry(iGOPid).m_POC - isField;
507	iTimeOffset = m_pcCfg->getGOPEntry(iGOPid).m_POC;
508	}
509
510	if(pocCurr>=m_pcCfg->getFramesToBeEncoded())
511	{
512	continue;
513	}
514
515	#if M0040_ADAPTIVE_RESOLUTION_CHANGE
516	if (m_pcEncTop->getAdaptiveResolutionChange() > 0 && ((m_layerId == 1 && pocCurr < m_pcEncTop->getAdaptiveResolutionChange()) \|\|
517	(m_layerId == 0 && pocCurr > m_pcEncTop->getAdaptiveResolutionChange())) )
518	{
519	continue;
520	}
521	#endif
522
523	if( getNalUnitType(pocCurr, m_iLastIDR, isField) == NAL_UNIT_CODED_SLICE_IDR_W_RADL \|\| getNalUnitType(pocCurr, m_iLastIDR, isField) == NAL_UNIT_CODED_SLICE_IDR_N_LP )
524	{
525	m_iLastIDR = pocCurr;
526	}
527	// start a new access unit: create an entry in the list of output access units
528	accessUnitsInGOP.push_back(AccessUnit());
529	AccessUnit& accessUnit = accessUnitsInGOP.back();
530	xGetBuffer( rcListPic, rcListPicYuvRecOut, iNumPicRcvd, iTimeOffset, pcPic, pcPicYuvRecOut, pocCurr, isField);
531
532	// Slice data initialization
533	pcPic->clearSliceBuffer();
534	assert(pcPic->getNumAllocatedSlice() == 1);
535	m_pcSliceEncoder->setSliceIdx(0);
536	pcPic->setCurrSliceIdx(0);
537	#if SVC_EXTENSION
538	pcPic->setLayerId( m_layerId );
539	m_pcSliceEncoder->initEncSlice ( pcPic, iPOCLast, pocCurr, iNumPicRcvd, iGOPid, pcSlice, m_pcEncTop->getSPS(), m_pcEncTop->getPPS(), m_pcEncTop->getVPS(), isField );
540	#else
541	m_pcSliceEncoder->initEncSlice ( pcPic, iPOCLast, pocCurr, iNumPicRcvd, iGOPid, pcSlice, m_pcEncTop->getSPS(), m_pcEncTop->getPPS(), isField );
542	#endif
543
544	//Set Frame/Field coding
545	pcSlice->getPic()->setField(isField);
546
547	#if SVC_EXTENSION
548	#if POC_RESET_FLAG
549	if( !pcSlice->getPocResetFlag() ) // For picture that are not reset, we should adjust the value of POC calculated from the configuration files.
550	{
551	// Subtract POC adjustment value until now.
552	pcSlice->setPOC( pcSlice->getPOC() - m_pcEncTop->getPocAdjustmentValue() );
553	}
554	else
555	{
556	// Check if this is the first slice in the picture
557	// In the encoder, the POC values are copied along with copySliceInfo, so we only need
558	// to do this for the first slice.
559	Int pocAdjustValue = pcSlice->getPOC() - m_pcEncTop->getPocAdjustmentValue();
560	if( pcSlice->getSliceIdx() == 0 )
561	{
562	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
563
564	// Iterate through all picture in DPB
565	while( iterPic != rcListPic.end() )
566	{
567	TComPic dpbPic = iterPic;
568	if( dpbPic->getPOC() == pocCurr )
569	{
570	if( dpbPic->getReconMark() )
571	{
572	assert( !( dpbPic->getSlice(0)->isReferenced() ) && !( dpbPic->getOutputMark() ) );
573	}
574	}
575	// Check if the picture pointed to by iterPic is either used for reference or
576	// needed for output, are in the same layer, and not the current picture.
577	if( /* ( ( dpbPic->getSlice(0)->isReferenced() ) \|\| ( dpbPic->getOutputMark() ) )
578	&& */ ( dpbPic->getLayerId() == pcSlice->getLayerId() )
579	&& ( dpbPic->getReconMark() )
580	)
581	{
582	for(Int i = dpbPic->getNumAllocatedSlice()-1; i >= 0; i--)
583	{
584	TComSlice *slice = dpbPic->getSlice(i);
585	TComReferencePictureSet *rps = slice->getRPS();
586	slice->setPOC( dpbPic->getSlice(i)->getPOC() - pocAdjustValue );
587
588	// Also adjust the POC value stored in the RPS of each such slice
589	for(Int j = rps->getNumberOfPictures(); j >= 0; j--)
590	{
591	rps->setPOC( j, rps->getPOC(j) - pocAdjustValue );
592	}
593	// Also adjust the value of refPOC
594	for(Int k = 0; k < 2; k++) // For List 0 and List 1
595	{
596	RefPicList list = (k == 1) ? REF_PIC_LIST_1 : REF_PIC_LIST_0;
597	for(Int j = 0; j < slice->getNumRefIdx(list); j++)
598	{
599	slice->setRefPOC( slice->getRefPOC(list, j) - pocAdjustValue, list, j);
600	}
601	}
602	}
603	}
604	iterPic++;
605	}
606	m_pcEncTop->setPocAdjustmentValue( m_pcEncTop->getPocAdjustmentValue() + pocAdjustValue );
607	}
608	pcSlice->setPocValueBeforeReset( pcSlice->getPOC() - m_pcEncTop->getPocAdjustmentValue() + pocAdjustValue );
609	pcSlice->setPOC( 0 );
610	}
611	#endif
612	#if O0149_CROSS_LAYER_BLA_FLAG
613	if( m_layerId == 0 && (getNalUnitType(pocCurr, m_iLastIDR, isField) == NAL_UNIT_CODED_SLICE_IDR_W_RADL \|\| getNalUnitType(pocCurr, m_iLastIDR, isField) == NAL_UNIT_CODED_SLICE_IDR_N_LP) )
614	{
615	pcSlice->setCrossLayerBLAFlag(m_pcEncTop->getCrossLayerBLAFlag());
616	}
617	else
618	{
619	pcSlice->setCrossLayerBLAFlag(false);
620	}
621	#endif
622	#if NO_CLRAS_OUTPUT_FLAG
623	if (m_layerId == 0 &&
624	(pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
625	\|\| pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
626	\|\| pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
627	\|\| pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
628	\|\| pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP
629	\|\| pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA))
630	{
631	if (m_bFirst)
632	{
633	m_pcEncTop->setNoClrasOutputFlag(true);
634	}
635	else if (pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
636	\|\| pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
637	\|\| pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP)
638	{
639	m_pcEncTop->setNoClrasOutputFlag(true);
640	}
641	#if O0149_CROSS_LAYER_BLA_FLAG
642	else if ((pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL \|\| pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP) &&
643	pcSlice->getCrossLayerBLAFlag())
644	{
645	m_pcEncTop->setNoClrasOutputFlag(true);
646	}
647	#endif
648	else
649	{
650	m_pcEncTop->setNoClrasOutputFlag(false);
651	}
652	if (m_pcEncTop->getNoClrasOutputFlag())
653	{
654	for (UInt i = 0; i < m_pcCfg->getNumLayer(); i++)
655	{
656	m_ppcTEncTop[i]->setLayerInitializedFlag(false);
657	m_ppcTEncTop[i]->setFirstPicInLayerDecodedFlag(false);
658	}
659	}
660	}
661	#endif
662	#if M0040_ADAPTIVE_RESOLUTION_CHANGE
663	if (m_pcEncTop->getAdaptiveResolutionChange() > 0 && m_layerId == 1 && pocCurr > m_pcEncTop->getAdaptiveResolutionChange())
664	{
665	pcSlice->setActiveNumILRRefIdx(0);
666	pcSlice->setInterLayerPredEnabledFlag(false);
667	pcSlice->setMFMEnabledFlag(false);
668	}
669	#endif
670	#endif //SVC_EXTENSION
671
672	pcSlice->setLastIDR(m_iLastIDR);
673	pcSlice->setSliceIdx(0);
674	//set default slice level flag to the same as SPS level flag
675	pcSlice->setLFCrossSliceBoundaryFlag( pcSlice->getPPS()->getLoopFilterAcrossSlicesEnabledFlag() );
676	pcSlice->setScalingList ( m_pcEncTop->getScalingList() );
677	if(m_pcEncTop->getUseScalingListId() == SCALING_LIST_OFF)
678	{
679	m_pcEncTop->getTrQuant()->setFlatScalingList();
680	m_pcEncTop->getTrQuant()->setUseScalingList(false);
681	m_pcEncTop->getSPS()->setScalingListPresentFlag(false);
682	m_pcEncTop->getPPS()->setScalingListPresentFlag(false);
683	}
684	else if(m_pcEncTop->getUseScalingListId() == SCALING_LIST_DEFAULT)
685	{
686	#if SCALINGLIST_INFERRING
687	// inferring of the scaling list can be moved to the config file
688	UInt refLayerId = 0;
689	if( m_layerId > 0 && !m_pcEncTop->getVPS()->getAvcBaseLayerFlag() && m_pcEncTop->getVPS()->getRecursiveRefLayerFlag( m_layerId, refLayerId ) )
690	{
691	m_pcEncTop->getSPS()->setInferScalingListFlag( true );
692	m_pcEncTop->getSPS()->setScalingListRefLayerId( refLayerId );
693	m_pcEncTop->getSPS()->setScalingListPresentFlag( false );
694	m_pcEncTop->getPPS()->setInferScalingListFlag( false );
695	m_pcEncTop->getPPS()->setScalingListPresentFlag( false );
696
697	// infer the scaling list from the reference layer
698	pcSlice->setScalingList ( m_ppcTEncTop[refLayerId]->getScalingList() );
699	}
700	else
701	{
702	#endif
703	pcSlice->setDefaultScalingList ();
704	m_pcEncTop->getSPS()->setScalingListPresentFlag(false);
705	m_pcEncTop->getPPS()->setScalingListPresentFlag(false);
706
707	#if SCALINGLIST_INFERRING
708	}
709	#endif
710
711	m_pcEncTop->getTrQuant()->setScalingList(pcSlice->getScalingList());
712	m_pcEncTop->getTrQuant()->setUseScalingList(true);
713	}
714	else if(m_pcEncTop->getUseScalingListId() == SCALING_LIST_FILE_READ)
715	{
716	#if SCALINGLIST_INFERRING
717	// inferring of the scaling list can be moved to the config file
718	UInt refLayerId = 0;
719	if( m_layerId > 0 && !m_pcEncTop->getVPS()->getAvcBaseLayerFlag() && m_pcEncTop->getVPS()->getRecursiveRefLayerFlag( m_layerId, refLayerId ) )
720	{
721	m_pcEncTop->getSPS()->setInferScalingListFlag( true );
722	m_pcEncTop->getSPS()->setScalingListRefLayerId( refLayerId );
723	m_pcEncTop->getSPS()->setScalingListPresentFlag( false );
724	m_pcEncTop->getPPS()->setInferScalingListFlag( false );
725	m_pcEncTop->getPPS()->setScalingListPresentFlag( false );
726
727	// infer the scaling list from the reference layer
728	pcSlice->setScalingList ( m_ppcTEncTop[refLayerId]->getScalingList() );
729	}
730	else
731	{
732	#endif
733
734	if(pcSlice->getScalingList()->xParseScalingList(m_pcCfg->getScalingListFile()))
735	{
736	pcSlice->setDefaultScalingList ();
737	}
738	pcSlice->getScalingList()->checkDcOfMatrix();
739	m_pcEncTop->getSPS()->setScalingListPresentFlag(pcSlice->checkDefaultScalingList());
740	m_pcEncTop->getPPS()->setScalingListPresentFlag(false);
741
742	#if SCALINGLIST_INFERRING
743	}
744	#endif
745
746	m_pcEncTop->getTrQuant()->setScalingList(pcSlice->getScalingList());
747	m_pcEncTop->getTrQuant()->setUseScalingList(true);
748	}
749	else
750	{
751	printf("error : ScalingList == %d no support\n",m_pcEncTop->getUseScalingListId());
752	assert(0);
753	}
754
755	if(pcSlice->getSliceType()==B_SLICE&&m_pcCfg->getGOPEntry(iGOPid).m_sliceType=='P')
756	{
757	pcSlice->setSliceType(P_SLICE);
758	}
759	if(pcSlice->getSliceType()==B_SLICE&&m_pcCfg->getGOPEntry(iGOPid).m_sliceType=='I')
760	{
761	pcSlice->setSliceType(I_SLICE);
762	}
763
764	// Set the nal unit type
765	pcSlice->setNalUnitType(getNalUnitType(pocCurr, m_iLastIDR, isField));
766	#if SVC_EXTENSION
767	if (m_layerId > 0)
768	{
769	Int interLayerPredLayerIdcTmp[MAX_VPS_LAYER_ID_PLUS1];
770	Int activeNumILRRefIdxTmp = 0;
771
772	for( Int i = 0; i < pcSlice->getActiveNumILRRefIdx(); i++ )
773	{
774	UInt refLayerIdc = pcSlice->getInterLayerPredLayerIdc(i);
775	#if VPS_EXTN_DIRECT_REF_LAYERS
776	TComList<TComPic> cListPic = m_ppcTEncTop[m_layerId]->getRefLayerEnc(refLayerIdc)->getListPic();
777	#else
778	TComList<TComPic> cListPic = m_ppcTEncTop[m_layerId-1]->getListPic();
779	#endif
780	pcSlice->setBaseColPic( *cListPic, refLayerIdc );
781
782	// Apply temporal layer restriction to inter-layer prediction
783	#if O0225_MAX_TID_FOR_REF_LAYERS
784	Int maxTidIlRefPicsPlus1 = m_pcEncTop->getVPS()->getMaxTidIlRefPicsPlus1(pcSlice->getBaseColPic(refLayerIdc)->getSlice(0)->getLayerId(),m_layerId);
785	#else
786	Int maxTidIlRefPicsPlus1 = m_pcEncTop->getVPS()->getMaxTidIlRefPicsPlus1(pcSlice->getBaseColPic(refLayerIdc)->getSlice(0)->getLayerId());
787	#endif
788	if( ((Int)(pcSlice->getBaseColPic(refLayerIdc)->getSlice(0)->getTLayer())<=maxTidIlRefPicsPlus1-1) \|\| (maxTidIlRefPicsPlus1==0 && pcSlice->getBaseColPic(refLayerIdc)->getSlice(0)->getRapPicFlag()) )
789	{
790	interLayerPredLayerIdcTmp[activeNumILRRefIdxTmp++] = refLayerIdc; // add picture to the list of valid inter-layer pictures
791	}
792	else
793	{
794	continue; // ILP is not valid due to temporal layer restriction
795	}
796
797	#if O0098_SCALED_REF_LAYER_ID
798	const Window &scalEL = m_pcEncTop->getScaledRefLayerWindowForLayer(pcSlice->getVPS()->getRefLayerId(m_layerId, refLayerIdc));
799	#else
800	const Window &scalEL = m_pcEncTop->getScaledRefLayerWindow(refLayerIdc);
801	#endif
802
803	Int widthBL = pcSlice->getBaseColPic(refLayerIdc)->getPicYuvRec()->getWidth();
804	Int heightBL = pcSlice->getBaseColPic(refLayerIdc)->getPicYuvRec()->getHeight();
805
806	Int widthEL = pcPic->getPicYuvRec()->getWidth() - scalEL.getWindowLeftOffset() - scalEL.getWindowRightOffset();
807	Int heightEL = pcPic->getPicYuvRec()->getHeight() - scalEL.getWindowTopOffset() - scalEL.getWindowBottomOffset();
808
809	g_mvScalingFactor[refLayerIdc][0] = widthEL == widthBL ? 4096 : Clip3(-4096, 4095, ((widthEL << 8) + (widthBL >> 1)) / widthBL);
810	g_mvScalingFactor[refLayerIdc][1] = heightEL == heightBL ? 4096 : Clip3(-4096, 4095, ((heightEL << 8) + (heightBL >> 1)) / heightBL);
811
812	g_posScalingFactor[refLayerIdc][0] = ((widthBL << 16) + (widthEL >> 1)) / widthEL;
813	g_posScalingFactor[refLayerIdc][1] = ((heightBL << 16) + (heightEL >> 1)) / heightEL;
814
815	#if SVC_UPSAMPLING
816	if( pcPic->isSpatialEnhLayer(refLayerIdc))
817	{
818	/*#if O0098_SCALED_REF_LAYER_ID
819	Window scalEL = pcSlice->getSPS()->getScaledRefLayerWindowForLayer(pcSlice->getVPS()->getRefLayerId(m_layerId, refLayerIdc));
820	#else
821	Window scalEL = pcSlice->getSPS()->getScaledRefLayerWindow(refLayerIdc);
822	#endif*/
823	#if P0312_VERT_PHASE_ADJ
824	//when PhasePositionEnableFlag is equal to 1, set vertPhasePositionFlag to 0 if BL is top field and 1 if bottom
825	if( scalEL.getVertPhasePositionEnableFlag() )
826	{
827	pcSlice->setVertPhasePositionFlag( pcSlice->getPOC()%2, refLayerIdc );
828	}
829	#endif
830	#if O0215_PHASE_ALIGNMENT
831	#if O0194_JOINT_US_BITSHIFT
832	m_pcPredSearch->upsampleBasePic( pcSlice, refLayerIdc, pcPic->getFullPelBaseRec(refLayerIdc), pcSlice->getBaseColPic(refLayerIdc)->getPicYuvRec(), pcPic->getPicYuvRec(), scalEL, pcSlice->getVPS()->getPhaseAlignFlag() );
833	#else
834	m_pcPredSearch->upsampleBasePic( refLayerIdc, pcPic->getFullPelBaseRec(refLayerIdc), pcSlice->getBaseColPic(refLayerIdc)->getPicYuvRec(), pcPic->getPicYuvRec(), scalEL, pcSlice->getVPS()->getPhaseAlignFlag() );
835	#endif
836	#else
837	#if O0194_JOINT_US_BITSHIFT
838	m_pcPredSearch->upsampleBasePic( pcSlice, refLayerIdc, pcPic->getFullPelBaseRec(refLayerIdc), pcSlice->getBaseColPic(refLayerIdc)->getPicYuvRec(), pcPic->getPicYuvRec(), scalEL );
839	#else
840	m_pcPredSearch->upsampleBasePic( refLayerIdc, pcPic->getFullPelBaseRec(refLayerIdc), pcSlice->getBaseColPic(refLayerIdc)->getPicYuvRec(), pcPic->getPicYuvRec(), scalEL );
841	#endif
842	#endif
843	}
844	else
845	{
846	pcPic->setFullPelBaseRec( refLayerIdc, pcSlice->getBaseColPic(refLayerIdc)->getPicYuvRec() );
847	}
848	pcSlice->setFullPelBaseRec ( refLayerIdc, pcPic->getFullPelBaseRec(refLayerIdc) );
849	#endif
850	}
851
852	// Update the list of active inter-layer pictures
853	for ( Int i = 0; i < activeNumILRRefIdxTmp; i++)
854	{
855	pcSlice->setInterLayerPredLayerIdc( interLayerPredLayerIdcTmp[i], i );
856	}
857
858	#if !O0225_TID_BASED_IL_RPS_DERIV
859	pcSlice->setActiveNumILRRefIdx( activeNumILRRefIdxTmp );
860	#endif
861	if ( pcSlice->getActiveNumILRRefIdx() == 0 )
862	{
863	// No valid inter-layer pictures -> disable inter-layer prediction
864	pcSlice->setInterLayerPredEnabledFlag(false);
865	}
866
867	if( pocCurr % m_pcCfg->getIntraPeriod() == 0 )
868	{
869	#if N0147_IRAP_ALIGN_FLAG
870	if(pcSlice->getVPS()->getCrossLayerIrapAlignFlag())
871	{
872	TComList<TComPic> cListPic = m_ppcTEncTop[m_layerId]->getRefLayerEnc(0)->getListPic();
873	TComPic* picLayer0 = pcSlice->getRefPic(*cListPic, pcSlice->getPOC() );
874	if(picLayer0)
875	{
876	pcSlice->setNalUnitType(picLayer0->getSlice(0)->getNalUnitType());
877	}
878	else
879	{
880	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_CRA);
881	}
882	}
883	else
884	#endif
885	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_CRA);
886
887	#if IDR_ALIGNMENT
888	TComList<TComPic> cListPic = m_ppcTEncTop[m_layerId]->getRefLayerEnc(0)->getListPic();
889	TComPic* picLayer0 = pcSlice->getRefPic(*cListPic, pcSlice->getPOC() );
890	if( picLayer0->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL \|\| picLayer0->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP )
891	{
892	pcSlice->setNalUnitType(picLayer0->getSlice(0)->getNalUnitType());
893	}
894	else
895	{
896	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_CRA);
897	}
898	#endif
899	}
900
901	if( pcSlice->getActiveNumILRRefIdx() == 0 && pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA )
902	{
903	pcSlice->setSliceType(I_SLICE);
904	}
905	else if( !m_pcEncTop->getElRapSliceTypeB() )
906	{
907	if( (pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP) &&
908	(pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA) &&
909	pcSlice->getSliceType() == B_SLICE )
910	{
911	pcSlice->setSliceType(P_SLICE);
912	}
913	}
914	}
915	#endif //#if SVC_EXTENSION
916	if(pcSlice->getTemporalLayerNonReferenceFlag())
917	{
918	if (pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_TRAIL_R &&
919	!(m_iGopSize == 1 && pcSlice->getSliceType() == I_SLICE))
920	// Add this condition to avoid POC issues with encoder_intra_main.cfg configuration (see #1127 in bug tracker)
921	{
922	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TRAIL_N);
923	}
924	if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_RADL_R)
925	{
926	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_RADL_N);
927	}
928	if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_RASL_R)
929	{
930	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_RASL_N);
931	}
932	}
933
934	// Do decoding refresh marking if any
935	#if NO_CLRAS_OUTPUT_FLAG
936	pcSlice->decodingRefreshMarking(m_pocCRA, m_bRefreshPending, rcListPic, m_pcEncTop->getNoClrasOutputFlag());
937	#else
938	pcSlice->decodingRefreshMarking(m_pocCRA, m_bRefreshPending, rcListPic);
939	#endif
940	m_pcEncTop->selectReferencePictureSet(pcSlice, pocCurr, iGOPid);
941	pcSlice->getRPS()->setNumberOfLongtermPictures(0);
942	#if FIX1172
943	if ( pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
944	\|\| pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
945	\|\| pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
946	\|\| pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
947	\|\| pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP
948	\|\| pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA ) // IRAP picture
949	{
950	m_associatedIRAPType = pcSlice->getNalUnitType();
951	m_associatedIRAPPOC = pocCurr;
952	}
953	pcSlice->setAssociatedIRAPType(m_associatedIRAPType);
954	pcSlice->setAssociatedIRAPPOC(m_associatedIRAPPOC);
955	#endif
956
957	if ((pcSlice->checkThatAllRefPicsAreAvailable(rcListPic, pcSlice->getRPS(), false) != 0) \|\| (pcSlice->isIRAP()))
958	{
959	pcSlice->createExplicitReferencePictureSetFromReference(rcListPic, pcSlice->getRPS(), pcSlice->isIRAP());
960	}
961	#if ALIGNED_BUMPING
962	pcSlice->checkLeadingPictureRestrictions(rcListPic);
963	#endif
964	pcSlice->applyReferencePictureSet(rcListPic, pcSlice->getRPS());
965
966	if(pcSlice->getTLayer() > 0
967	&& !( pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N // Check if not a leading picture
968	\|\| pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_R
969	\|\| pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N
970	\|\| pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_R )
971	)
972	{
973	if(pcSlice->isTemporalLayerSwitchingPoint(rcListPic) \|\| pcSlice->getSPS()->getTemporalIdNestingFlag())
974	{
975	#if ALIGN_TSA_STSA_PICS
976	if( pcSlice->getLayerId() > 0 )
977	{
978	Bool oneRefLayerTSA = false, oneRefLayerNotTSA = false;
979	for( Int i = 0; i < pcSlice->getLayerId(); i++)
980	{
981	TComList<TComPic > cListPic = m_ppcTEncTop[i]->getListPic();
982	TComPic lowerLayerPic = pcSlice->getRefPic(cListPic, pcSlice->getPOC());
983	if( lowerLayerPic && pcSlice->getVPS()->getDirectDependencyFlag(pcSlice->getLayerId(), i) )
984	{
985	if( ( lowerLayerPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N ) \|\|
986	( lowerLayerPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_R )
987	)
988	{
989	if(pcSlice->getTemporalLayerNonReferenceFlag() )
990	{
991	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TSA_N);
992	}
993	else
994	{
995	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TSA_R );
996	}
997	oneRefLayerTSA = true;
998	}
999	else
1000	{
1001	oneRefLayerNotTSA = true;
1002	}
1003	}
1004	}
1005	assert( !( oneRefLayerNotTSA && oneRefLayerTSA ) ); // Only one variable should be true - failure of this assert means
1006	// that two independent reference layers that are not dependent on
1007	// each other, but are reference for current layer have inconsistency
1008	if( oneRefLayerNotTSA /&& !oneRefLayerTSA/ ) // No reference layer is TSA - set current as TRAIL
1009	{
1010	if(pcSlice->getTemporalLayerNonReferenceFlag() )
1011	{
1012	pcSlice->setNalUnitType( NAL_UNIT_CODED_SLICE_TRAIL_N );
1013	}
1014	else
1015	{
1016	pcSlice->setNalUnitType( NAL_UNIT_CODED_SLICE_TRAIL_R );
1017	}
1018	}
1019	else // This means there is no reference layer picture for current picture in this AU
1020	{
1021	if(pcSlice->getTemporalLayerNonReferenceFlag() )
1022	{
1023	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TSA_N);
1024	}
1025	else
1026	{
1027	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TSA_R );
1028	}
1029	}
1030	}
1031	#else
1032	if(pcSlice->getTemporalLayerNonReferenceFlag())
1033	{
1034	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TSA_N);
1035	}
1036	else
1037	{
1038	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TSA_R);
1039	}
1040	#endif
1041	}
1042	else if(pcSlice->isStepwiseTemporalLayerSwitchingPointCandidate(rcListPic))
1043	{
1044	Bool isSTSA=true;
1045	for(Int ii=iGOPid+1;(ii<m_pcCfg->getGOPSize() && isSTSA==true);ii++)
1046	{
1047	Int lTid= m_pcCfg->getGOPEntry(ii).m_temporalId;
1048	if(lTid==pcSlice->getTLayer())
1049	{
1050	TComReferencePictureSet* nRPS = pcSlice->getSPS()->getRPSList()->getReferencePictureSet(ii);
1051	for(Int jj=0;jj<nRPS->getNumberOfPictures();jj++)
1052	{
1053	if(nRPS->getUsed(jj))
1054	{
1055	Int tPoc=m_pcCfg->getGOPEntry(ii).m_POC+nRPS->getDeltaPOC(jj);
1056	Int kk=0;
1057	for(kk=0;kk<m_pcCfg->getGOPSize();kk++)
1058	{
1059	if(m_pcCfg->getGOPEntry(kk).m_POC==tPoc)
1060	break;
1061	}
1062	Int tTid=m_pcCfg->getGOPEntry(kk).m_temporalId;
1063	if(tTid >= pcSlice->getTLayer())
1064	{
1065	isSTSA=false;
1066	break;
1067	}
1068	}
1069	}
1070	}
1071	}
1072	if(isSTSA==true)
1073	{
1074	#if ALIGN_TSA_STSA_PICS
1075	if( pcSlice->getLayerId() > 0 )
1076	{
1077	Bool oneRefLayerSTSA = false, oneRefLayerNotSTSA = false;
1078	for( Int i = 0; i < pcSlice->getLayerId(); i++)
1079	{
1080	TComList<TComPic > cListPic = m_ppcTEncTop[i]->getListPic();
1081	TComPic lowerLayerPic = pcSlice->getRefPic(cListPic, pcSlice->getPOC());
1082	if( lowerLayerPic && pcSlice->getVPS()->getDirectDependencyFlag(pcSlice->getLayerId(), i) )
1083	{
1084	if( ( lowerLayerPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_STSA_N ) \|\|
1085	( lowerLayerPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_STSA_R )
1086	)
1087	{
1088	if(pcSlice->getTemporalLayerNonReferenceFlag() )
1089	{
1090	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_STSA_N);
1091	}
1092	else
1093	{
1094	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_STSA_R );
1095	}
1096	oneRefLayerSTSA = true;
1097	}
1098	else
1099	{
1100	oneRefLayerNotSTSA = true;
1101	}
1102	}
1103	}
1104	assert( !( oneRefLayerNotSTSA && oneRefLayerSTSA ) ); // Only one variable should be true - failure of this assert means
1105	// that two independent reference layers that are not dependent on
1106	// each other, but are reference for current layer have inconsistency
1107	if( oneRefLayerNotSTSA /&& !oneRefLayerSTSA/ ) // No reference layer is STSA - set current as TRAIL
1108	{
1109	if(pcSlice->getTemporalLayerNonReferenceFlag() )
1110	{
1111	pcSlice->setNalUnitType( NAL_UNIT_CODED_SLICE_TRAIL_N );
1112	}
1113	else
1114	{
1115	pcSlice->setNalUnitType( NAL_UNIT_CODED_SLICE_TRAIL_R );
1116	}
1117	}
1118	else // This means there is no reference layer picture for current picture in this AU
1119	{
1120	if(pcSlice->getTemporalLayerNonReferenceFlag() )
1121	{
1122	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_STSA_N);
1123	}
1124	else
1125	{
1126	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_STSA_R );
1127	}
1128	}
1129	}
1130	#else
1131	if(pcSlice->getTemporalLayerNonReferenceFlag())
1132	{
1133	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_STSA_N);
1134	}
1135	else
1136	{
1137	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_STSA_R);
1138	}
1139	#endif
1140	}
1141	}
1142	}
1143	arrangeLongtermPicturesInRPS(pcSlice, rcListPic);
1144	TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
1145	refPicListModification->setRefPicListModificationFlagL0(0);
1146	refPicListModification->setRefPicListModificationFlagL1(0);
1147	pcSlice->setNumRefIdx(REF_PIC_LIST_0,min(m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive,pcSlice->getRPS()->getNumberOfPictures()));
1148	pcSlice->setNumRefIdx(REF_PIC_LIST_1,min(m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive,pcSlice->getRPS()->getNumberOfPictures()));
1149
1150	#if SVC_EXTENSION
1151	if( m_layerId > 0 && pcSlice->getActiveNumILRRefIdx() )
1152	{
1153	#if POC_RESET_FLAG
1154	if ( pocCurr > 0 && pcSlice->isRADL() && pcPic->getSlice(0)->getBaseColPic(pcPic->getSlice(0)->getInterLayerPredLayerIdc(0))->getSlice(0)->isRASL())
1155	#else
1156	if (pcSlice->getPOC()>0 && pcSlice->isRADL() && pcPic->getSlice(0)->getBaseColPic(pcPic->getSlice(0)->getInterLayerPredLayerIdc(0))->getSlice(0)->isRASL())
1157	#endif
1158	{
1159	pcSlice->setActiveNumILRRefIdx(0);
1160	pcSlice->setInterLayerPredEnabledFlag(0);
1161	}
1162	if( pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA )
1163	{
1164	pcSlice->setNumRefIdx(REF_PIC_LIST_0, pcSlice->getActiveNumILRRefIdx());
1165	pcSlice->setNumRefIdx(REF_PIC_LIST_1, pcSlice->getActiveNumILRRefIdx());
1166	}
1167	else
1168	{
1169	pcSlice->setNumRefIdx(REF_PIC_LIST_0, pcSlice->getNumRefIdx(REF_PIC_LIST_0)+pcSlice->getActiveNumILRRefIdx());
1170	pcSlice->setNumRefIdx(REF_PIC_LIST_1, pcSlice->getNumRefIdx(REF_PIC_LIST_1)+pcSlice->getActiveNumILRRefIdx());
1171	}
1172	}
1173	#endif //SVC_EXTENSION
1174
1175	#if ADAPTIVE_QP_SELECTION
1176	pcSlice->setTrQuant( m_pcEncTop->getTrQuant() );
1177	#endif
1178
1179	#if SVC_EXTENSION
1180	if( pcSlice->getSliceType() == B_SLICE )
1181	{
1182	pcSlice->setColFromL0Flag(1-uiColDir);
1183	}
1184
1185	// Set reference list
1186	if(m_layerId == 0 \|\| ( m_layerId > 0 && pcSlice->getActiveNumILRRefIdx() == 0 ) )
1187	{
1188	pcSlice->setRefPicList( rcListPic);
1189	}
1190
1191	if( m_layerId > 0 && pcSlice->getActiveNumILRRefIdx() )
1192	{
1193	pcSlice->setILRPic( m_pcEncTop->getIlpList() );
1194	#if REF_IDX_MFM
1195	if( pcSlice->getMFMEnabledFlag() )
1196	{
1197	pcSlice->setRefPOCListILP(m_pcEncTop->getIlpList(), pcSlice->getBaseColPic());
1198	}
1199	#else
1200	// Set reference list
1201	pcSlice->setRefPicList ( rcListPic );
1202	#endif //SVC_EXTENSION
1203	pcSlice->setRefPicListModificationSvc();
1204	pcSlice->setRefPicList( rcListPic, false, m_pcEncTop->getIlpList());
1205
1206	#if REF_IDX_MFM
1207	if( pcSlice->getMFMEnabledFlag() )
1208	{
1209	Bool found = false;
1210	UInt ColFromL0Flag = pcSlice->getColFromL0Flag();
1211	UInt ColRefIdx = pcSlice->getColRefIdx();
1212
1213	for(Int colIdx = 0; colIdx < pcSlice->getNumRefIdx( RefPicList(1 - ColFromL0Flag) ); colIdx++)
1214	{
1215	if( pcSlice->getRefPic( RefPicList(1 - ColFromL0Flag), colIdx)->isILR(m_layerId)
1216	#if MFM_ENCCONSTRAINT
1217	&& pcSlice->getBaseColPic( *m_ppcTEncTop[pcSlice->getRefPic( RefPicList(1 - ColFromL0Flag), colIdx)->getLayerId()]->getListPic() )->checkSameRefInfo() == true
1218	#endif
1219	)
1220	{
1221	ColRefIdx = colIdx;
1222	found = true;
1223	break;
1224	}
1225	}
1226
1227	if( found == false )
1228	{
1229	ColFromL0Flag = 1 - ColFromL0Flag;
1230	for(Int colIdx = 0; colIdx < pcSlice->getNumRefIdx( RefPicList(1 - ColFromL0Flag) ); colIdx++)
1231	{
1232	if( pcSlice->getRefPic( RefPicList(1 - ColFromL0Flag), colIdx)->isILR(m_layerId)
1233	#if MFM_ENCCONSTRAINT
1234	&& pcSlice->getBaseColPic( *m_ppcTEncTop[pcSlice->getRefPic( RefPicList(1 - ColFromL0Flag), colIdx)->getLayerId()]->getListPic() )->checkSameRefInfo() == true
1235	#endif
1236	)
1237	{
1238	ColRefIdx = colIdx;
1239	found = true;
1240	break;
1241	}
1242	}
1243	}
1244
1245	if(found == true)
1246	{
1247	pcSlice->setColFromL0Flag(ColFromL0Flag);
1248	pcSlice->setColRefIdx(ColRefIdx);
1249	}
1250	}
1251	#endif
1252	}
1253	#else //SVC_EXTENSION
1254	// Set reference list
1255	pcSlice->setRefPicList ( rcListPic );
1256	#endif //#if SVC_EXTENSION
1257
1258	// Slice info. refinement
1259	if ( (pcSlice->getSliceType() == B_SLICE) && (pcSlice->getNumRefIdx(REF_PIC_LIST_1) == 0) )
1260	{
1261	pcSlice->setSliceType ( P_SLICE );
1262	}
1263
1264	if (pcSlice->getSliceType() == B_SLICE)
1265	{
1266	#if !SVC_EXTENSION
1267	pcSlice->setColFromL0Flag(1-uiColDir);
1268	#endif
1269	Bool bLowDelay = true;
1270	Int iCurrPOC = pcSlice->getPOC();
1271	Int iRefIdx = 0;
1272
1273	for (iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_0) && bLowDelay; iRefIdx++)
1274	{
1275	if ( pcSlice->getRefPic(REF_PIC_LIST_0, iRefIdx)->getPOC() > iCurrPOC )
1276	{
1277	bLowDelay = false;
1278	}
1279	}
1280	for (iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_1) && bLowDelay; iRefIdx++)
1281	{
1282	if ( pcSlice->getRefPic(REF_PIC_LIST_1, iRefIdx)->getPOC() > iCurrPOC )
1283	{
1284	bLowDelay = false;
1285	}
1286	}
1287
1288	pcSlice->setCheckLDC(bLowDelay);
1289	}
1290	else
1291	{
1292	pcSlice->setCheckLDC(true);
1293	}
1294
1295	uiColDir = 1-uiColDir;
1296
1297	//-------------------------------------------------------------
1298	pcSlice->setRefPOCList();
1299
1300	pcSlice->setList1IdxToList0Idx();
1301
1302	if (m_pcEncTop->getTMVPModeId() == 2)
1303	{
1304	if (iGOPid == 0) // first picture in SOP (i.e. forward B)
1305	{
1306	pcSlice->setEnableTMVPFlag(0);
1307	}
1308	else
1309	{
1310	// Note: pcSlice->getColFromL0Flag() is assumed to be always 0 and getcolRefIdx() is always 0.
1311	pcSlice->setEnableTMVPFlag(1);
1312	}
1313	pcSlice->getSPS()->setTMVPFlagsPresent(1);
1314	}
1315	else if (m_pcEncTop->getTMVPModeId() == 1)
1316	{
1317	pcSlice->getSPS()->setTMVPFlagsPresent(1);
1318	#if SVC_EXTENSION
1319	if( pcSlice->getIdrPicFlag() )
1320	{
1321	pcSlice->setEnableTMVPFlag(0);
1322	}
1323	else
1324	#endif
1325	pcSlice->setEnableTMVPFlag(1);
1326	}
1327	else
1328	{
1329	pcSlice->getSPS()->setTMVPFlagsPresent(0);
1330	pcSlice->setEnableTMVPFlag(0);
1331	}
1332	/////////////////////////////////////////////////////////////////////////////////////////////////// Compress a slice
1333	// Slice compression
1334	if (m_pcCfg->getUseASR())
1335	{
1336	m_pcSliceEncoder->setSearchRange(pcSlice);
1337	}
1338
1339	Bool bGPBcheck=false;
1340	if ( pcSlice->getSliceType() == B_SLICE)
1341	{
1342	if ( pcSlice->getNumRefIdx(RefPicList( 0 ) ) == pcSlice->getNumRefIdx(RefPicList( 1 ) ) )
1343	{
1344	bGPBcheck=true;
1345	Int i;
1346	for ( i=0; i < pcSlice->getNumRefIdx(RefPicList( 1 ) ); i++ )
1347	{
1348	if ( pcSlice->getRefPOC(RefPicList(1), i) != pcSlice->getRefPOC(RefPicList(0), i) )
1349	{
1350	bGPBcheck=false;
1351	break;
1352	}
1353	}
1354	}
1355	}
1356	if(bGPBcheck)
1357	{
1358	pcSlice->setMvdL1ZeroFlag(true);
1359	}
1360	else
1361	{
1362	pcSlice->setMvdL1ZeroFlag(false);
1363	}
1364	pcPic->getSlice(pcSlice->getSliceIdx())->setMvdL1ZeroFlag(pcSlice->getMvdL1ZeroFlag());
1365
1366	Double lambda = 0.0;
1367	Int actualHeadBits = 0;
1368	Int actualTotalBits = 0;
1369	Int estimatedBits = 0;
1370	Int tmpBitsBeforeWriting = 0;
1371	if ( m_pcCfg->getUseRateCtrl() )
1372	{
1373	Int frameLevel = m_pcRateCtrl->getRCSeq()->getGOPID2Level( iGOPid );
1374	if ( pcPic->getSlice(0)->getSliceType() == I_SLICE )
1375	{
1376	frameLevel = 0;
1377	}
1378	m_pcRateCtrl->initRCPic( frameLevel );
1379	estimatedBits = m_pcRateCtrl->getRCPic()->getTargetBits();
1380
1381	Int sliceQP = m_pcCfg->getInitialQP();
1382	#if POC_RESET_FLAG
1383	if ( ( pocCurr == 0 && m_pcCfg->getInitialQP() > 0 ) \|\| ( frameLevel == 0 && m_pcCfg->getForceIntraQP() ) ) // QP is specified
1384	#else
1385	if ( ( pcSlice->getPOC() == 0 && m_pcCfg->getInitialQP() > 0 ) \|\| ( frameLevel == 0 && m_pcCfg->getForceIntraQP() ) ) // QP is specified
1386	#endif
1387	{
1388	Int NumberBFrames = ( m_pcCfg->getGOPSize() - 1 );
1389	Double dLambda_scale = 1.0 - Clip3( 0.0, 0.5, 0.05*(Double)NumberBFrames );
1390	Double dQPFactor = 0.57*dLambda_scale;
1391	Int SHIFT_QP = 12;
1392	Int bitdepth_luma_qp_scale = 0;
1393	Double qp_temp = (Double) sliceQP + bitdepth_luma_qp_scale - SHIFT_QP;
1394	lambda = dQPFactor*pow( 2.0, qp_temp/3.0 );
1395	}
1396	else if ( frameLevel == 0 ) // intra case, but use the model
1397	{
1398	m_pcSliceEncoder->calCostSliceI(pcPic);
1399	if ( m_pcCfg->getIntraPeriod() != 1 ) // do not refine allocated bits for all intra case
1400	{
1401	Int bits = m_pcRateCtrl->getRCSeq()->getLeftAverageBits();
1402	bits = m_pcRateCtrl->getRCPic()->getRefineBitsForIntra( bits );
1403	if ( bits < 200 )
1404	{
1405	bits = 200;
1406	}
1407	m_pcRateCtrl->getRCPic()->setTargetBits( bits );
1408	}
1409
1410	list<TEncRCPic*> listPreviousPicture = m_pcRateCtrl->getPicList();
1411	m_pcRateCtrl->getRCPic()->getLCUInitTargetBits();
1412	lambda = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture, pcSlice->getSliceType());
1413	sliceQP = m_pcRateCtrl->getRCPic()->estimatePicQP( lambda, listPreviousPicture );
1414	}
1415	else // normal case
1416	{
1417	list<TEncRCPic*> listPreviousPicture = m_pcRateCtrl->getPicList();
1418	lambda = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture, pcSlice->getSliceType());
1419	sliceQP = m_pcRateCtrl->getRCPic()->estimatePicQP( lambda, listPreviousPicture );
1420	}
1421
1422	#if REPN_FORMAT_IN_VPS
1423	sliceQP = Clip3( -pcSlice->getQpBDOffsetY(), MAX_QP, sliceQP );
1424	#else
1425	sliceQP = Clip3( -pcSlice->getSPS()->getQpBDOffsetY(), MAX_QP, sliceQP );
1426	#endif
1427	m_pcRateCtrl->getRCPic()->setPicEstQP( sliceQP );
1428
1429	m_pcSliceEncoder->resetQP( pcPic, sliceQP, lambda );
1430	}
1431
1432	UInt uiNumSlices = 1;
1433
1434	UInt uiInternalAddress = pcPic->getNumPartInCU()-4;
1435	UInt uiExternalAddress = pcPic->getPicSym()->getNumberOfCUsInFrame()-1;
1436	UInt uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
1437	UInt uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
1438	#if REPN_FORMAT_IN_VPS
1439	UInt uiWidth = pcSlice->getPicWidthInLumaSamples();
1440	UInt uiHeight = pcSlice->getPicHeightInLumaSamples();
1441	#else
1442	UInt uiWidth = pcSlice->getSPS()->getPicWidthInLumaSamples();
1443	UInt uiHeight = pcSlice->getSPS()->getPicHeightInLumaSamples();
1444	#endif
1445	while(uiPosX>=uiWidth\|\|uiPosY>=uiHeight)
1446	{
1447	uiInternalAddress--;
1448	uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
1449	uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
1450	}
1451	uiInternalAddress++;
1452	if(uiInternalAddress==pcPic->getNumPartInCU())
1453	{
1454	uiInternalAddress = 0;
1455	uiExternalAddress++;
1456	}
1457	UInt uiRealEndAddress = uiExternalAddress*pcPic->getNumPartInCU()+uiInternalAddress;
1458
1459	UInt uiCummulativeTileWidth;
1460	UInt uiCummulativeTileHeight;
1461	Int p, j;
1462	UInt uiEncCUAddr;
1463
1464	//set NumColumnsMinus1 and NumRowsMinus1
1465	pcPic->getPicSym()->setNumColumnsMinus1( pcSlice->getPPS()->getNumColumnsMinus1() );
1466	pcPic->getPicSym()->setNumRowsMinus1( pcSlice->getPPS()->getNumRowsMinus1() );
1467
1468	//create the TComTileArray
1469	pcPic->getPicSym()->xCreateTComTileArray();
1470
1471	if( pcSlice->getPPS()->getUniformSpacingFlag() == 1 )
1472	{
1473	//set the width for each tile
1474	for(j=0; j < pcPic->getPicSym()->getNumRowsMinus1()+1; j++)
1475	{
1476	for(p=0; p < pcPic->getPicSym()->getNumColumnsMinus1()+1; p++)
1477	{
1478	pcPic->getPicSym()->getTComTile( j * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + p )->
1479	setTileWidth( (p+1)*pcPic->getPicSym()->getFrameWidthInCU()/(pcPic->getPicSym()->getNumColumnsMinus1()+1)
1480	- (p*pcPic->getPicSym()->getFrameWidthInCU())/(pcPic->getPicSym()->getNumColumnsMinus1()+1) );
1481	}
1482	}
1483
1484	//set the height for each tile
1485	for(j=0; j < pcPic->getPicSym()->getNumColumnsMinus1()+1; j++)
1486	{
1487	for(p=0; p < pcPic->getPicSym()->getNumRowsMinus1()+1; p++)
1488	{
1489	pcPic->getPicSym()->getTComTile( p * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + j )->
1490	setTileHeight( (p+1)*pcPic->getPicSym()->getFrameHeightInCU()/(pcPic->getPicSym()->getNumRowsMinus1()+1)
1491	- (p*pcPic->getPicSym()->getFrameHeightInCU())/(pcPic->getPicSym()->getNumRowsMinus1()+1) );
1492	}
1493	}
1494	}
1495	else
1496	{
1497	//set the width for each tile
1498	for(j=0; j < pcPic->getPicSym()->getNumRowsMinus1()+1; j++)
1499	{
1500	uiCummulativeTileWidth = 0;
1501	for(p=0; p < pcPic->getPicSym()->getNumColumnsMinus1(); p++)
1502	{
1503	pcPic->getPicSym()->getTComTile( j * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + p )->setTileWidth( pcSlice->getPPS()->getColumnWidth(p) );
1504	uiCummulativeTileWidth += pcSlice->getPPS()->getColumnWidth(p);
1505	}
1506	pcPic->getPicSym()->getTComTile(j * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + p)->setTileWidth( pcPic->getPicSym()->getFrameWidthInCU()-uiCummulativeTileWidth );
1507	}
1508
1509	//set the height for each tile
1510	for(j=0; j < pcPic->getPicSym()->getNumColumnsMinus1()+1; j++)
1511	{
1512	uiCummulativeTileHeight = 0;
1513	for(p=0; p < pcPic->getPicSym()->getNumRowsMinus1(); p++)
1514	{
1515	pcPic->getPicSym()->getTComTile( p * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + j )->setTileHeight( pcSlice->getPPS()->getRowHeight(p) );
1516	uiCummulativeTileHeight += pcSlice->getPPS()->getRowHeight(p);
1517	}
1518	pcPic->getPicSym()->getTComTile(p * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + j)->setTileHeight( pcPic->getPicSym()->getFrameHeightInCU()-uiCummulativeTileHeight );
1519	}
1520	}
1521	//intialize each tile of the current picture
1522	pcPic->getPicSym()->xInitTiles();
1523
1524	#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
1525	if (m_pcCfg->getInterLayerConstrainedTileSetsSEIEnabled())
1526	{
1527	xBuildTileSetsMap(pcPic->getPicSym());
1528	}
1529	#endif
1530
1531	// Allocate some coders, now we know how many tiles there are.
1532	Int iNumSubstreams = pcSlice->getPPS()->getNumSubstreams();
1533
1534	//generate the Coding Order Map and Inverse Coding Order Map
1535	for(p=0, uiEncCUAddr=0; p<pcPic->getPicSym()->getNumberOfCUsInFrame(); p++, uiEncCUAddr = pcPic->getPicSym()->xCalculateNxtCUAddr(uiEncCUAddr))
1536	{
1537	pcPic->getPicSym()->setCUOrderMap(p, uiEncCUAddr);
1538	pcPic->getPicSym()->setInverseCUOrderMap(uiEncCUAddr, p);
1539	}
1540	pcPic->getPicSym()->setCUOrderMap(pcPic->getPicSym()->getNumberOfCUsInFrame(), pcPic->getPicSym()->getNumberOfCUsInFrame());
1541	pcPic->getPicSym()->setInverseCUOrderMap(pcPic->getPicSym()->getNumberOfCUsInFrame(), pcPic->getPicSym()->getNumberOfCUsInFrame());
1542
1543	// Allocate some coders, now we know how many tiles there are.
1544	m_pcEncTop->createWPPCoders(iNumSubstreams);
1545	pcSbacCoders = m_pcEncTop->getSbacCoders();
1546	pcSubstreamsOut = new TComOutputBitstream[iNumSubstreams];
1547
1548	UInt startCUAddrSliceIdx = 0; // used to index "m_uiStoredStartCUAddrForEncodingSlice" containing locations of slice boundaries
1549	UInt startCUAddrSlice = 0; // used to keep track of current slice's starting CU addr.
1550	pcSlice->setSliceCurStartCUAddr( startCUAddrSlice ); // Setting "start CU addr" for current slice
1551	m_storedStartCUAddrForEncodingSlice.clear();
1552
1553	UInt startCUAddrSliceSegmentIdx = 0; // used to index "m_uiStoredStartCUAddrForEntropyEncodingSlice" containing locations of slice boundaries
1554	UInt startCUAddrSliceSegment = 0; // used to keep track of current Dependent slice's starting CU addr.
1555	pcSlice->setSliceSegmentCurStartCUAddr( startCUAddrSliceSegment ); // Setting "start CU addr" for current Dependent slice
1556
1557	m_storedStartCUAddrForEncodingSliceSegment.clear();
1558	UInt nextCUAddr = 0;
1559	m_storedStartCUAddrForEncodingSlice.push_back (nextCUAddr);
1560	startCUAddrSliceIdx++;
1561	m_storedStartCUAddrForEncodingSliceSegment.push_back(nextCUAddr);
1562	startCUAddrSliceSegmentIdx++;
1563	#if AVC_BASE
1564	if( m_layerId == 0 && m_pcEncTop->getVPS()->getAvcBaseLayerFlag() )
1565	{
1566	pcPic->getPicYuvOrg()->copyToPic( pcPic->getPicYuvRec() );
1567	#if O0194_WEIGHTED_PREDICTION_CGS
1568	// Calculate for the base layer to be used in EL as Inter layer reference
1569	if( m_pcEncTop->getInterLayerWeightedPredFlag() )
1570	{
1571	m_pcSliceEncoder->estimateILWpParam( pcSlice );
1572	}
1573	#endif
1574	#if AVC_SYNTAX
1575	pcPic->readBLSyntax( m_ppcTEncTop[0]->getBLSyntaxFile(), SYNTAX_BYTES );
1576	#endif
1577	return;
1578	}
1579	#endif
1580
1581	while(nextCUAddr<uiRealEndAddress) // determine slice boundaries
1582	{
1583	pcSlice->setNextSlice ( false );
1584	pcSlice->setNextSliceSegment( false );
1585	assert(pcPic->getNumAllocatedSlice() == startCUAddrSliceIdx);
1586	m_pcSliceEncoder->precompressSlice( pcPic );
1587	m_pcSliceEncoder->compressSlice ( pcPic );
1588
1589	Bool bNoBinBitConstraintViolated = (!pcSlice->isNextSlice() && !pcSlice->isNextSliceSegment());
1590	if (pcSlice->isNextSlice() \|\| (bNoBinBitConstraintViolated && m_pcCfg->getSliceMode()==FIXED_NUMBER_OF_LCU))
1591	{
1592	startCUAddrSlice = pcSlice->getSliceCurEndCUAddr();
1593	// Reconstruction slice
1594	m_storedStartCUAddrForEncodingSlice.push_back(startCUAddrSlice);
1595	startCUAddrSliceIdx++;
1596	// Dependent slice
1597	if (startCUAddrSliceSegmentIdx>0 && m_storedStartCUAddrForEncodingSliceSegment[startCUAddrSliceSegmentIdx-1] != startCUAddrSlice)
1598	{
1599	m_storedStartCUAddrForEncodingSliceSegment.push_back(startCUAddrSlice);
1600	startCUAddrSliceSegmentIdx++;
1601	}
1602
1603	if (startCUAddrSlice < uiRealEndAddress)
1604	{
1605	pcPic->allocateNewSlice();
1606	pcPic->setCurrSliceIdx ( startCUAddrSliceIdx-1 );
1607	m_pcSliceEncoder->setSliceIdx ( startCUAddrSliceIdx-1 );
1608	pcSlice = pcPic->getSlice ( startCUAddrSliceIdx-1 );
1609	pcSlice->copySliceInfo ( pcPic->getSlice(0) );
1610	pcSlice->setSliceIdx ( startCUAddrSliceIdx-1 );
1611	pcSlice->setSliceCurStartCUAddr ( startCUAddrSlice );
1612	pcSlice->setSliceSegmentCurStartCUAddr ( startCUAddrSlice );
1613	pcSlice->setSliceBits(0);
1614	#if SVC_EXTENSION
1615	// copy reference list modification info from the first slice, assuming that this information is the same across all slices in the picture
1616	memcpy( pcSlice->getRefPicListModification(), pcPic->getSlice(0)->getRefPicListModification(), sizeof(TComRefPicListModification) );
1617	#endif
1618	uiNumSlices ++;
1619	}
1620	}
1621	else if (pcSlice->isNextSliceSegment() \|\| (bNoBinBitConstraintViolated && m_pcCfg->getSliceSegmentMode()==FIXED_NUMBER_OF_LCU))
1622	{
1623	startCUAddrSliceSegment = pcSlice->getSliceSegmentCurEndCUAddr();
1624	m_storedStartCUAddrForEncodingSliceSegment.push_back(startCUAddrSliceSegment);
1625	startCUAddrSliceSegmentIdx++;
1626	pcSlice->setSliceSegmentCurStartCUAddr( startCUAddrSliceSegment );
1627	}
1628	else
1629	{
1630	startCUAddrSlice = pcSlice->getSliceCurEndCUAddr();
1631	startCUAddrSliceSegment = pcSlice->getSliceSegmentCurEndCUAddr();
1632	}
1633
1634	nextCUAddr = (startCUAddrSlice > startCUAddrSliceSegment) ? startCUAddrSlice : startCUAddrSliceSegment;
1635	}
1636	m_storedStartCUAddrForEncodingSlice.push_back( pcSlice->getSliceCurEndCUAddr());
1637	startCUAddrSliceIdx++;
1638	m_storedStartCUAddrForEncodingSliceSegment.push_back(pcSlice->getSliceCurEndCUAddr());
1639	startCUAddrSliceSegmentIdx++;
1640
1641	pcSlice = pcPic->getSlice(0);
1642
1643	// SAO parameter estimation using non-deblocked pixels for LCU bottom and right boundary areas
1644	if( pcSlice->getSPS()->getUseSAO() && m_pcCfg->getSaoLcuBoundary() )
1645	{
1646	m_pcSAO->getPreDBFStatistics(pcPic);
1647	}
1648	//-- Loop filter
1649	Bool bLFCrossTileBoundary = pcSlice->getPPS()->getLoopFilterAcrossTilesEnabledFlag();
1650	m_pcLoopFilter->setCfg(bLFCrossTileBoundary);
1651	if ( m_pcCfg->getDeblockingFilterMetric() )
1652	{
1653	dblMetric(pcPic, uiNumSlices);
1654	}
1655	m_pcLoopFilter->loopFilterPic( pcPic );
1656
1657	/////////////////////////////////////////////////////////////////////////////////////////////////// File writing
1658	// Set entropy coder
1659	m_pcEntropyCoder->setEntropyCoder ( m_pcCavlcCoder, pcSlice );
1660
1661	/* write various header sets. */
1662	if ( m_bSeqFirst )
1663	{
1664	#if SVC_EXTENSION
1665	#if VPS_NUH_LAYER_ID
1666	OutputNALUnit nalu(NAL_UNIT_VPS, 0, 0 ); // The value of nuh_layer_id of VPS NAL unit shall be equal to 0.
1667	#else
1668	OutputNALUnit nalu(NAL_UNIT_VPS, 0, m_layerId);
1669	#endif
1670	#if AVC_BASE
1671	if( ( m_layerId == 1 && m_pcEncTop->getVPS()->getAvcBaseLayerFlag() ) \|\| ( m_layerId == 0 && !m_pcEncTop->getVPS()->getAvcBaseLayerFlag() ) )
1672	#else
1673	if( m_layerId == 0 )
1674	#endif
1675	{
1676	#else
1677	OutputNALUnit nalu(NAL_UNIT_VPS);
1678	#endif
1679	#if VPS_VUI_OFFSET
1680	// The following code also calculates the VPS VUI offset
1681	#endif
1682	#if !P0125_REVERT_VPS_EXTN_OFFSET_TO_RESERVED
1683	#if VPS_EXTN_OFFSET_CALC
1684	OutputNALUnit tempNalu(NAL_UNIT_VPS, 0, 0 ); // The value of nuh_layer_id of VPS NAL unit shall be equal to 0.
1685	m_pcEntropyCoder->setBitstream(&tempNalu.m_Bitstream);
1686	m_pcEntropyCoder->encodeVPS(m_pcEncTop->getVPS()); // Use to calculate the VPS extension offset
1687	#endif
1688	#endif
1689	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1690	m_pcEntropyCoder->encodeVPS(m_pcEncTop->getVPS());
1691	writeRBSPTrailingBits(nalu.m_Bitstream);
1692	accessUnit.push_back(new NALUnitEBSP(nalu));
1693	actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;
1694	#if SVC_EXTENSION
1695	}
1696	#endif
1697
1698	#if SVC_EXTENSION
1699	nalu = NALUnit(NAL_UNIT_SPS, 0, m_layerId);
1700	#else
1701	nalu = NALUnit(NAL_UNIT_SPS);
1702	#endif
1703	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1704	if (m_bSeqFirst)
1705	{
1706	pcSlice->getSPS()->setNumLongTermRefPicSPS(m_numLongTermRefPicSPS);
1707	for (Int k = 0; k < m_numLongTermRefPicSPS; k++)
1708	{
1709	pcSlice->getSPS()->setLtRefPicPocLsbSps(k, m_ltRefPicPocLsbSps[k]);
1710	pcSlice->getSPS()->setUsedByCurrPicLtSPSFlag(k, m_ltRefPicUsedByCurrPicFlag[k]);
1711	}
1712	}
1713	if( m_pcCfg->getPictureTimingSEIEnabled() \|\| m_pcCfg->getDecodingUnitInfoSEIEnabled() )
1714	{
1715	UInt maxCU = m_pcCfg->getSliceArgument() >> ( pcSlice->getSPS()->getMaxCUDepth() << 1);
1716	UInt numDU = ( m_pcCfg->getSliceMode() == 1 ) ? ( pcPic->getNumCUsInFrame() / maxCU ) : ( 0 );
1717	if( pcPic->getNumCUsInFrame() % maxCU != 0 \|\| numDU == 0 )
1718	{
1719	numDU ++;
1720	}
1721	pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->setNumDU( numDU );
1722	pcSlice->getSPS()->setHrdParameters( m_pcCfg->getFrameRate(), numDU, m_pcCfg->getTargetBitrate(), ( m_pcCfg->getIntraPeriod() > 0 ) );
1723	}
1724	if( m_pcCfg->getBufferingPeriodSEIEnabled() \|\| m_pcCfg->getPictureTimingSEIEnabled() \|\| m_pcCfg->getDecodingUnitInfoSEIEnabled() )
1725	{
1726	pcSlice->getSPS()->getVuiParameters()->setHrdParametersPresentFlag( true );
1727	}
1728	#if O0092_0094_DEPENDENCY_CONSTRAINT
1729	assert( pcSlice->getSPS()->getLayerId() == 0 \|\| pcSlice->getSPS()->getLayerId() == m_layerId \|\| m_pcEncTop->getVPS()->getRecursiveRefLayerFlag(m_layerId, pcSlice->getSPS()->getLayerId()) );
1730	#endif
1731	m_pcEntropyCoder->encodeSPS(pcSlice->getSPS());
1732	writeRBSPTrailingBits(nalu.m_Bitstream);
1733	accessUnit.push_back(new NALUnitEBSP(nalu));
1734	actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;
1735
1736	#if SVC_EXTENSION
1737	nalu = NALUnit(NAL_UNIT_PPS, 0, m_layerId);
1738	#else
1739	nalu = NALUnit(NAL_UNIT_PPS);
1740	#endif
1741	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1742	#if O0092_0094_DEPENDENCY_CONSTRAINT
1743	assert( pcSlice->getPPS()->getPPSId() == 0 \|\| pcSlice->getPPS()->getPPSId() == m_layerId \|\| m_pcEncTop->getVPS()->getRecursiveRefLayerFlag(m_layerId, pcSlice->getPPS()->getPPSId()) );
1744	#endif
1745	m_pcEntropyCoder->encodePPS(pcSlice->getPPS());
1746	writeRBSPTrailingBits(nalu.m_Bitstream);
1747	accessUnit.push_back(new NALUnitEBSP(nalu));
1748	actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;
1749
1750	xCreateLeadingSEIMessages(accessUnit, pcSlice->getSPS());
1751
1752	#if O0164_MULTI_LAYER_HRD
1753	if (pcSlice->getLayerId() == 0 && m_pcEncTop->getVPS()->getVpsVuiBspHrdPresentFlag())
1754	{
1755	nalu = NALUnit(NAL_UNIT_PREFIX_SEI, 0, 1);
1756	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
1757	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1758	SEIScalableNesting *scalableBspNestingSei = xCreateBspNestingSEI(pcSlice);
1759	m_seiWriter.writeSEImessage(nalu.m_Bitstream, *scalableBspNestingSei, m_pcEncTop->getVPS(), pcSlice->getSPS());
1760	writeRBSPTrailingBits(nalu.m_Bitstream);
1761
1762	UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
1763	UInt offsetPosition = m_activeParameterSetSEIPresentInAU
1764	+ m_bufferingPeriodSEIPresentInAU
1765	+ m_pictureTimingSEIPresentInAU
1766	+ m_nestedPictureTimingSEIPresentInAU; // Insert SEI after APS, BP and PT SEI
1767	AccessUnit::iterator it;
1768	for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
1769	{
1770	it++;
1771	}
1772	accessUnit.insert(it, new NALUnitEBSP(nalu));
1773	}
1774	#endif
1775
1776	m_bSeqFirst = false;
1777	}
1778
1779	if (writeSOP) // write SOP description SEI (if enabled) at the beginning of GOP
1780	{
1781	Int SOPcurrPOC = pocCurr;
1782
1783	OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
1784	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
1785	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1786
1787	SEISOPDescription SOPDescriptionSEI;
1788	SOPDescriptionSEI.m_sopSeqParameterSetId = pcSlice->getSPS()->getSPSId();
1789
1790	UInt i = 0;
1791	UInt prevEntryId = iGOPid;
1792	for (j = iGOPid; j < m_iGopSize; j++)
1793	{
1794	Int deltaPOC = m_pcCfg->getGOPEntry(j).m_POC - m_pcCfg->getGOPEntry(prevEntryId).m_POC;
1795	if ((SOPcurrPOC + deltaPOC) < m_pcCfg->getFramesToBeEncoded())
1796	{
1797	SOPcurrPOC += deltaPOC;
1798	SOPDescriptionSEI.m_sopDescVclNaluType[i] = getNalUnitType(SOPcurrPOC, m_iLastIDR, isField);
1799	SOPDescriptionSEI.m_sopDescTemporalId[i] = m_pcCfg->getGOPEntry(j).m_temporalId;
1800	SOPDescriptionSEI.m_sopDescStRpsIdx[i] = m_pcEncTop->getReferencePictureSetIdxForSOP(pcSlice, SOPcurrPOC, j);
1801	SOPDescriptionSEI.m_sopDescPocDelta[i] = deltaPOC;
1802
1803	prevEntryId = j;
1804	i++;
1805	}
1806	}
1807
1808	SOPDescriptionSEI.m_numPicsInSopMinus1 = i - 1;
1809
1810	#if O0164_MULTI_LAYER_HRD
1811	m_seiWriter.writeSEImessage( nalu.m_Bitstream, SOPDescriptionSEI, m_pcEncTop->getVPS(), pcSlice->getSPS());
1812	#else
1813	m_seiWriter.writeSEImessage( nalu.m_Bitstream, SOPDescriptionSEI, pcSlice->getSPS());
1814	#endif
1815	writeRBSPTrailingBits(nalu.m_Bitstream);
1816	accessUnit.push_back(new NALUnitEBSP(nalu));
1817
1818	writeSOP = false;
1819	}
1820
1821	if( ( m_pcCfg->getPictureTimingSEIEnabled() \|\| m_pcCfg->getDecodingUnitInfoSEIEnabled() ) &&
1822	( pcSlice->getSPS()->getVuiParametersPresentFlag() ) &&
1823	( ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNalHrdParametersPresentFlag() )
1824	\|\| ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getVclHrdParametersPresentFlag() ) ) )
1825	{
1826	if( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getSubPicCpbParamsPresentFlag() )
1827	{
1828	UInt numDU = pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNumDU();
1829	pictureTimingSEI.m_numDecodingUnitsMinus1 = ( numDU - 1 );
1830	pictureTimingSEI.m_duCommonCpbRemovalDelayFlag = false;
1831
1832	if( pictureTimingSEI.m_numNalusInDuMinus1 == NULL )
1833	{
1834	pictureTimingSEI.m_numNalusInDuMinus1 = new UInt[ numDU ];
1835	}
1836	if( pictureTimingSEI.m_duCpbRemovalDelayMinus1 == NULL )
1837	{
1838	pictureTimingSEI.m_duCpbRemovalDelayMinus1 = new UInt[ numDU ];
1839	}
1840	if( accumBitsDU == NULL )
1841	{
1842	accumBitsDU = new UInt[ numDU ];
1843	}
1844	if( accumNalsDU == NULL )
1845	{
1846	accumNalsDU = new UInt[ numDU ];
1847	}
1848	}
1849	pictureTimingSEI.m_auCpbRemovalDelay = std::min<Int>(std::max<Int>(1, m_totalCoded - m_lastBPSEI), static_cast<Int>(pow(2, static_cast<double>(pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getCpbRemovalDelayLengthMinus1()+1)))); // Syntax element signalled as minus, hence the .
1850	#if POC_RESET_FLAG
1851	pictureTimingSEI.m_picDpbOutputDelay = pcSlice->getSPS()->getNumReorderPics(0) + pocCurr - m_totalCoded;
1852	#else
1853	pictureTimingSEI.m_picDpbOutputDelay = pcSlice->getSPS()->getNumReorderPics(0) + pcSlice->getPOC() - m_totalCoded;
1854	#endif
1855	Int factor = pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getTickDivisorMinus2() + 2;
1856	pictureTimingSEI.m_picDpbOutputDuDelay = factor * pictureTimingSEI.m_picDpbOutputDelay;
1857	if( m_pcCfg->getDecodingUnitInfoSEIEnabled() )
1858	{
1859	picSptDpbOutputDuDelay = factor * pictureTimingSEI.m_picDpbOutputDelay;
1860	}
1861	}
1862
1863	if( ( m_pcCfg->getBufferingPeriodSEIEnabled() ) && ( pcSlice->getSliceType() == I_SLICE ) &&
1864	( pcSlice->getSPS()->getVuiParametersPresentFlag() ) &&
1865	( ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNalHrdParametersPresentFlag() )
1866	\|\| ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getVclHrdParametersPresentFlag() ) ) )
1867	{
1868	OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
1869	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
1870	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1871
1872	SEIBufferingPeriod sei_buffering_period;
1873
1874	UInt uiInitialCpbRemovalDelay = (90000/2); // 0.5 sec
1875	sei_buffering_period.m_initialCpbRemovalDelay [0][0] = uiInitialCpbRemovalDelay;
1876	sei_buffering_period.m_initialCpbRemovalDelayOffset[0][0] = uiInitialCpbRemovalDelay;
1877	sei_buffering_period.m_initialCpbRemovalDelay [0][1] = uiInitialCpbRemovalDelay;
1878	sei_buffering_period.m_initialCpbRemovalDelayOffset[0][1] = uiInitialCpbRemovalDelay;
1879
1880	Double dTmp = (Double)pcSlice->getSPS()->getVuiParameters()->getTimingInfo()->getNumUnitsInTick() / (Double)pcSlice->getSPS()->getVuiParameters()->getTimingInfo()->getTimeScale();
1881
1882	UInt uiTmp = (UInt)( dTmp * 90000.0 );
1883	uiInitialCpbRemovalDelay -= uiTmp;
1884	uiInitialCpbRemovalDelay -= uiTmp / ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getTickDivisorMinus2() + 2 );
1885	sei_buffering_period.m_initialAltCpbRemovalDelay [0][0] = uiInitialCpbRemovalDelay;
1886	sei_buffering_period.m_initialAltCpbRemovalDelayOffset[0][0] = uiInitialCpbRemovalDelay;
1887	sei_buffering_period.m_initialAltCpbRemovalDelay [0][1] = uiInitialCpbRemovalDelay;
1888	sei_buffering_period.m_initialAltCpbRemovalDelayOffset[0][1] = uiInitialCpbRemovalDelay;
1889
1890	sei_buffering_period.m_rapCpbParamsPresentFlag = 0;
1891	//for the concatenation, it can be set to one during splicing.
1892	sei_buffering_period.m_concatenationFlag = 0;
1893	//since the temporal layer HRD is not ready, we assumed it is fixed
1894	sei_buffering_period.m_auCpbRemovalDelayDelta = 1;
1895	sei_buffering_period.m_cpbDelayOffset = 0;
1896	sei_buffering_period.m_dpbDelayOffset = 0;
1897
1898	#if O0164_MULTI_LAYER_HRD
1899	m_seiWriter.writeSEImessage( nalu.m_Bitstream, sei_buffering_period, m_pcEncTop->getVPS(), pcSlice->getSPS());
1900	#else
1901	m_seiWriter.writeSEImessage( nalu.m_Bitstream, sei_buffering_period, pcSlice->getSPS());
1902	#endif
1903	writeRBSPTrailingBits(nalu.m_Bitstream);
1904	{
1905	UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
1906	UInt offsetPosition = m_activeParameterSetSEIPresentInAU; // Insert BP SEI after APS SEI
1907	AccessUnit::iterator it;
1908	for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
1909	{
1910	it++;
1911	}
1912	accessUnit.insert(it, new NALUnitEBSP(nalu));
1913	m_bufferingPeriodSEIPresentInAU = true;
1914	}
1915
1916	if (m_pcCfg->getScalableNestingSEIEnabled())
1917	{
1918	OutputNALUnit naluTmp(NAL_UNIT_PREFIX_SEI);
1919	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
1920	m_pcEntropyCoder->setBitstream(&naluTmp.m_Bitstream);
1921	scalableNestingSEI.m_nestedSEIs.clear();
1922	scalableNestingSEI.m_nestedSEIs.push_back(&sei_buffering_period);
1923	#if O0164_MULTI_LAYER_HRD
1924	m_seiWriter.writeSEImessage( naluTmp.m_Bitstream, scalableNestingSEI, m_pcEncTop->getVPS(), pcSlice->getSPS());
1925	#else
1926	m_seiWriter.writeSEImessage( naluTmp.m_Bitstream, scalableNestingSEI, pcSlice->getSPS());
1927	#endif
1928	writeRBSPTrailingBits(naluTmp.m_Bitstream);
1929	UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
1930	UInt offsetPosition = m_activeParameterSetSEIPresentInAU + m_bufferingPeriodSEIPresentInAU + m_pictureTimingSEIPresentInAU; // Insert BP SEI after non-nested APS, BP and PT SEIs
1931	AccessUnit::iterator it;
1932	for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
1933	{
1934	it++;
1935	}
1936	accessUnit.insert(it, new NALUnitEBSP(naluTmp));
1937	m_nestedBufferingPeriodSEIPresentInAU = true;
1938	}
1939
1940	m_lastBPSEI = m_totalCoded;
1941	m_cpbRemovalDelay = 0;
1942	}
1943	m_cpbRemovalDelay ++;
1944	if( ( m_pcEncTop->getRecoveryPointSEIEnabled() ) && ( pcSlice->getSliceType() == I_SLICE ) )
1945	{
1946	if( m_pcEncTop->getGradualDecodingRefreshInfoEnabled() && !pcSlice->getRapPicFlag() )
1947	{
1948	// Gradual decoding refresh SEI
1949	OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
1950	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
1951	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1952
1953	SEIGradualDecodingRefreshInfo seiGradualDecodingRefreshInfo;
1954	seiGradualDecodingRefreshInfo.m_gdrForegroundFlag = true; // Indicating all "foreground"
1955
1956	#if O0164_MULTI_LAYER_HRD
1957	m_seiWriter.writeSEImessage( nalu.m_Bitstream, seiGradualDecodingRefreshInfo, m_pcEncTop->getVPS(), pcSlice->getSPS() );
1958	#else
1959	m_seiWriter.writeSEImessage( nalu.m_Bitstream, seiGradualDecodingRefreshInfo, pcSlice->getSPS() );
1960	#endif
1961	writeRBSPTrailingBits(nalu.m_Bitstream);
1962	accessUnit.push_back(new NALUnitEBSP(nalu));
1963	}
1964	// Recovery point SEI
1965	OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
1966	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
1967	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1968
1969	SEIRecoveryPoint sei_recovery_point;
1970	sei_recovery_point.m_recoveryPocCnt = 0;
1971	#if POC_RESET_FLAG
1972	sei_recovery_point.m_exactMatchingFlag = ( pocCurr == 0 ) ? (true) : (false);
1973	#else
1974	sei_recovery_point.m_exactMatchingFlag = ( pcSlice->getPOC() == 0 ) ? (true) : (false);
1975	#endif
1976	sei_recovery_point.m_brokenLinkFlag = false;
1977
1978	#if O0164_MULTI_LAYER_HRD
1979	m_seiWriter.writeSEImessage( nalu.m_Bitstream, sei_recovery_point, m_pcEncTop->getVPS(), pcSlice->getSPS() );
1980	#else
1981	m_seiWriter.writeSEImessage( nalu.m_Bitstream, sei_recovery_point, pcSlice->getSPS() );
1982	#endif
1983	writeRBSPTrailingBits(nalu.m_Bitstream);
1984	accessUnit.push_back(new NALUnitEBSP(nalu));
1985	}
1986
1987	/* use the main bitstream buffer for storing the marshalled picture */
1988	m_pcEntropyCoder->setBitstream(NULL);
1989
1990	startCUAddrSliceIdx = 0;
1991	startCUAddrSlice = 0;
1992
1993	startCUAddrSliceSegmentIdx = 0;
1994	startCUAddrSliceSegment = 0;
1995	nextCUAddr = 0;
1996	pcSlice = pcPic->getSlice(startCUAddrSliceIdx);
1997
1998	Int processingState = (pcSlice->getSPS()->getUseSAO())?(EXECUTE_INLOOPFILTER):(ENCODE_SLICE);
1999	Bool skippedSlice=false;
2000	while (nextCUAddr < uiRealEndAddress) // Iterate over all slices
2001	{
2002	switch(processingState)
2003	{
2004	case ENCODE_SLICE:
2005	{
2006	pcSlice->setNextSlice ( false );
2007	pcSlice->setNextSliceSegment( false );
2008	if (nextCUAddr == m_storedStartCUAddrForEncodingSlice[startCUAddrSliceIdx])
2009	{
2010	pcSlice = pcPic->getSlice(startCUAddrSliceIdx);
2011	if(startCUAddrSliceIdx > 0 && pcSlice->getSliceType()!= I_SLICE)
2012	{
2013	pcSlice->checkColRefIdx(startCUAddrSliceIdx, pcPic);
2014	}
2015	pcPic->setCurrSliceIdx(startCUAddrSliceIdx);
2016	m_pcSliceEncoder->setSliceIdx(startCUAddrSliceIdx);
2017	assert(startCUAddrSliceIdx == pcSlice->getSliceIdx());
2018	// Reconstruction slice
2019	pcSlice->setSliceCurStartCUAddr( nextCUAddr ); // to be used in encodeSlice() + context restriction
2020	pcSlice->setSliceCurEndCUAddr ( m_storedStartCUAddrForEncodingSlice[startCUAddrSliceIdx+1 ] );
2021	// Dependent slice
2022	pcSlice->setSliceSegmentCurStartCUAddr( nextCUAddr ); // to be used in encodeSlice() + context restriction
2023	pcSlice->setSliceSegmentCurEndCUAddr ( m_storedStartCUAddrForEncodingSliceSegment[startCUAddrSliceSegmentIdx+1 ] );
2024
2025	pcSlice->setNextSlice ( true );
2026
2027	startCUAddrSliceIdx++;
2028	startCUAddrSliceSegmentIdx++;
2029	}
2030	else if (nextCUAddr == m_storedStartCUAddrForEncodingSliceSegment[startCUAddrSliceSegmentIdx])
2031	{
2032	// Dependent slice
2033	pcSlice->setSliceSegmentCurStartCUAddr( nextCUAddr ); // to be used in encodeSlice() + context restriction
2034	pcSlice->setSliceSegmentCurEndCUAddr ( m_storedStartCUAddrForEncodingSliceSegment[startCUAddrSliceSegmentIdx+1 ] );
2035
2036	pcSlice->setNextSliceSegment( true );
2037
2038	startCUAddrSliceSegmentIdx++;
2039	}
2040	#if SVC_EXTENSION
2041	pcSlice->setNumMotionPredRefLayers(m_pcEncTop->getNumMotionPredRefLayers());
2042	#endif
2043	pcSlice->setRPS(pcPic->getSlice(0)->getRPS());
2044	pcSlice->setRPSidx(pcPic->getSlice(0)->getRPSidx());
2045	UInt uiDummyStartCUAddr;
2046	UInt uiDummyBoundingCUAddr;
2047	m_pcSliceEncoder->xDetermineStartAndBoundingCUAddr(uiDummyStartCUAddr,uiDummyBoundingCUAddr,pcPic,true);
2048
2049	uiInternalAddress = pcPic->getPicSym()->getPicSCUAddr(pcSlice->getSliceSegmentCurEndCUAddr()-1) % pcPic->getNumPartInCU();
2050	uiExternalAddress = pcPic->getPicSym()->getPicSCUAddr(pcSlice->getSliceSegmentCurEndCUAddr()-1) / pcPic->getNumPartInCU();
2051	uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
2052	uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
2053
2054	#if REPN_FORMAT_IN_VPS
2055	uiWidth = pcSlice->getPicWidthInLumaSamples();
2056	uiHeight = pcSlice->getPicHeightInLumaSamples();
2057	#else
2058	uiWidth = pcSlice->getSPS()->getPicWidthInLumaSamples();
2059	uiHeight = pcSlice->getSPS()->getPicHeightInLumaSamples();
2060	#endif
2061	while(uiPosX>=uiWidth\|\|uiPosY>=uiHeight)
2062	{
2063	uiInternalAddress--;
2064	uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
2065	uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
2066	}
2067	uiInternalAddress++;
2068	if(uiInternalAddress==pcPic->getNumPartInCU())
2069	{
2070	uiInternalAddress = 0;
2071	uiExternalAddress = pcPic->getPicSym()->getCUOrderMap(pcPic->getPicSym()->getInverseCUOrderMap(uiExternalAddress)+1);
2072	}
2073	UInt endAddress = pcPic->getPicSym()->getPicSCUEncOrder(uiExternalAddress*pcPic->getNumPartInCU()+uiInternalAddress);
2074	if(endAddress<=pcSlice->getSliceSegmentCurStartCUAddr())
2075	{
2076	UInt boundingAddrSlice, boundingAddrSliceSegment;
2077	boundingAddrSlice = m_storedStartCUAddrForEncodingSlice[startCUAddrSliceIdx];
2078	boundingAddrSliceSegment = m_storedStartCUAddrForEncodingSliceSegment[startCUAddrSliceSegmentIdx];
2079	nextCUAddr = min(boundingAddrSlice, boundingAddrSliceSegment);
2080	if(pcSlice->isNextSlice())
2081	{
2082	skippedSlice=true;
2083	}
2084	continue;
2085	}
2086	if(skippedSlice)
2087	{
2088	pcSlice->setNextSlice ( true );
2089	pcSlice->setNextSliceSegment( false );
2090	}
2091	skippedSlice=false;
2092	pcSlice->allocSubstreamSizes( iNumSubstreams );
2093	for ( UInt ui = 0 ; ui < iNumSubstreams; ui++ )
2094	{
2095	pcSubstreamsOut[ui].clear();
2096	}
2097
2098	m_pcEntropyCoder->setEntropyCoder ( m_pcCavlcCoder, pcSlice );
2099	m_pcEntropyCoder->resetEntropy ();
2100	/* start slice NALunit */
2101	#if SVC_EXTENSION
2102	OutputNALUnit nalu( pcSlice->getNalUnitType(), pcSlice->getTLayer(), m_layerId );
2103	#else
2104	OutputNALUnit nalu( pcSlice->getNalUnitType(), pcSlice->getTLayer() );
2105	#endif
2106	Bool sliceSegment = (!pcSlice->isNextSlice());
2107	if (!sliceSegment)
2108	{
2109	uiOneBitstreamPerSliceLength = 0; // start of a new slice
2110	}
2111	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
2112	tmpBitsBeforeWriting = m_pcEntropyCoder->getNumberOfWrittenBits();
2113	m_pcEntropyCoder->encodeSliceHeader(pcSlice);
2114	actualHeadBits += ( m_pcEntropyCoder->getNumberOfWrittenBits() - tmpBitsBeforeWriting );
2115
2116	// is it needed?
2117	{
2118	if (!sliceSegment)
2119	{
2120	pcBitstreamRedirect->writeAlignOne();
2121	}
2122	else
2123	{
2124	// We've not completed our slice header info yet, do the alignment later.
2125	}
2126	m_pcSbacCoder->init( (TEncBinIf*)m_pcBinCABAC );
2127	m_pcEntropyCoder->setEntropyCoder ( m_pcSbacCoder, pcSlice );
2128	m_pcEntropyCoder->resetEntropy ();
2129	for ( UInt ui = 0 ; ui < pcSlice->getPPS()->getNumSubstreams() ; ui++ )
2130	{
2131	m_pcEntropyCoder->setEntropyCoder ( &pcSbacCoders[ui], pcSlice );
2132	m_pcEntropyCoder->resetEntropy ();
2133	}
2134	}
2135
2136	if(pcSlice->isNextSlice())
2137	{
2138	// set entropy coder for writing
2139	m_pcSbacCoder->init( (TEncBinIf*)m_pcBinCABAC );
2140	{
2141	for ( UInt ui = 0 ; ui < pcSlice->getPPS()->getNumSubstreams() ; ui++ )
2142	{
2143	m_pcEntropyCoder->setEntropyCoder ( &pcSbacCoders[ui], pcSlice );
2144	m_pcEntropyCoder->resetEntropy ();
2145	}
2146	pcSbacCoders[0].load(m_pcSbacCoder);
2147	m_pcEntropyCoder->setEntropyCoder ( &pcSbacCoders[0], pcSlice ); //ALF is written in substream #0 with CABAC coder #0 (see ALF param encoding below)
2148	}
2149	m_pcEntropyCoder->resetEntropy ();
2150	// File writing
2151	if (!sliceSegment)
2152	{
2153	m_pcEntropyCoder->setBitstream(pcBitstreamRedirect);
2154	}
2155	else
2156	{
2157	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
2158	}
2159	// for now, override the TILES_DECODER setting in order to write substreams.
2160	m_pcEntropyCoder->setBitstream ( &pcSubstreamsOut[0] );
2161
2162	}
2163	pcSlice->setFinalized(true);
2164
2165	m_pcSbacCoder->load( &pcSbacCoders[0] );
2166
2167	pcSlice->setTileOffstForMultES( uiOneBitstreamPerSliceLength );
2168	pcSlice->setTileLocationCount ( 0 );
2169	m_pcSliceEncoder->encodeSlice(pcPic, pcSubstreamsOut);
2170
2171	{
2172	// Construct the final bitstream by flushing and concatenating substreams.
2173	// The final bitstream is either nalu.m_Bitstream or pcBitstreamRedirect;
2174	UInt* puiSubstreamSizes = pcSlice->getSubstreamSizes();
2175	UInt uiTotalCodedSize = 0; // for padding calcs.
2176	UInt uiNumSubstreamsPerTile = iNumSubstreams;
2177	if (iNumSubstreams > 1)
2178	{
2179	uiNumSubstreamsPerTile /= pcPic->getPicSym()->getNumTiles();
2180	}
2181	for ( UInt ui = 0 ; ui < iNumSubstreams; ui++ )
2182	{
2183	// Flush all substreams -- this includes empty ones.
2184	// Terminating bit and flush.
2185	m_pcEntropyCoder->setEntropyCoder ( &pcSbacCoders[ui], pcSlice );
2186	m_pcEntropyCoder->setBitstream ( &pcSubstreamsOut[ui] );
2187	m_pcEntropyCoder->encodeTerminatingBit( 1 );
2188	m_pcEntropyCoder->encodeSliceFinish();
2189
2190	pcSubstreamsOut[ui].writeByteAlignment(); // Byte-alignment in slice_data() at end of sub-stream
2191	// Byte alignment is necessary between tiles when tiles are independent.
2192	uiTotalCodedSize += pcSubstreamsOut[ui].getNumberOfWrittenBits();
2193
2194	Bool bNextSubstreamInNewTile = ((ui+1) < iNumSubstreams)&& ((ui+1)%uiNumSubstreamsPerTile == 0);
2195	if (bNextSubstreamInNewTile)
2196	{
2197	pcSlice->setTileLocation(ui/uiNumSubstreamsPerTile, pcSlice->getTileOffstForMultES()+(uiTotalCodedSize>>3));
2198	}
2199	if (ui+1 < pcSlice->getPPS()->getNumSubstreams())
2200	{
2201	puiSubstreamSizes[ui] = pcSubstreamsOut[ui].getNumberOfWrittenBits() + (pcSubstreamsOut[ui].countStartCodeEmulations()<<3);
2202	}
2203	}
2204
2205	// Complete the slice header info.
2206	m_pcEntropyCoder->setEntropyCoder ( m_pcCavlcCoder, pcSlice );
2207	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
2208	#if !POC_RESET_IDC_SIGNALLING
2209	m_pcEntropyCoder->encodeTilesWPPEntryPoint( pcSlice );
2210	#else
2211	tmpBitsBeforeWriting = m_pcEntropyCoder->getNumberOfWrittenBits();
2212	m_pcEntropyCoder->encodeTilesWPPEntryPoint( pcSlice );
2213	actualHeadBits += ( m_pcEntropyCoder->getNumberOfWrittenBits() - tmpBitsBeforeWriting );
2214	m_pcEntropyCoder->encodeSliceHeaderExtn( pcSlice, actualHeadBits );
2215	#endif
2216
2217	// Substreams...
2218	TComOutputBitstream *pcOut = pcBitstreamRedirect;
2219	Int offs = 0;
2220	Int nss = pcSlice->getPPS()->getNumSubstreams();
2221	if (pcSlice->getPPS()->getEntropyCodingSyncEnabledFlag())
2222	{
2223	// 1st line present for WPP.
2224	offs = pcSlice->getSliceSegmentCurStartCUAddr()/pcSlice->getPic()->getNumPartInCU()/pcSlice->getPic()->getFrameWidthInCU();
2225	nss = pcSlice->getNumEntryPointOffsets()+1;
2226	}
2227	for ( UInt ui = 0 ; ui < nss; ui++ )
2228	{
2229	pcOut->addSubstream(&pcSubstreamsOut[ui+offs]);
2230	}
2231	}
2232
2233	UInt boundingAddrSlice, boundingAddrSliceSegment;
2234	boundingAddrSlice = m_storedStartCUAddrForEncodingSlice[startCUAddrSliceIdx];
2235	boundingAddrSliceSegment = m_storedStartCUAddrForEncodingSliceSegment[startCUAddrSliceSegmentIdx];
2236	nextCUAddr = min(boundingAddrSlice, boundingAddrSliceSegment);
2237	// If current NALU is the first NALU of slice (containing slice header) and more NALUs exist (due to multiple dependent slices) then buffer it.
2238	// If current NALU is the last NALU of slice and a NALU was buffered, then (a) Write current NALU (b) Update an write buffered NALU at approproate location in NALU list.
2239	Bool bNALUAlignedWrittenToList = false; // used to ensure current NALU is not written more than once to the NALU list.
2240	xAttachSliceDataToNalUnit(nalu, pcBitstreamRedirect);
2241	accessUnit.push_back(new NALUnitEBSP(nalu));
2242	actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;
2243	bNALUAlignedWrittenToList = true;
2244	uiOneBitstreamPerSliceLength += nalu.m_Bitstream.getNumberOfWrittenBits(); // length of bitstream after byte-alignment
2245
2246	if (!bNALUAlignedWrittenToList)
2247	{
2248	{
2249	nalu.m_Bitstream.writeAlignZero();
2250	}
2251	accessUnit.push_back(new NALUnitEBSP(nalu));
2252	uiOneBitstreamPerSliceLength += nalu.m_Bitstream.getNumberOfWrittenBits() + 24; // length of bitstream after byte-alignment + 3 byte startcode 0x000001
2253	}
2254
2255	if( ( m_pcCfg->getPictureTimingSEIEnabled() \|\| m_pcCfg->getDecodingUnitInfoSEIEnabled() ) &&
2256	( pcSlice->getSPS()->getVuiParametersPresentFlag() ) &&
2257	( ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNalHrdParametersPresentFlag() )
2258	\|\| ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getVclHrdParametersPresentFlag() ) ) &&
2259	( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getSubPicCpbParamsPresentFlag() ) )
2260	{
2261	UInt numNalus = 0;
2262	UInt numRBSPBytes = 0;
2263	for (AccessUnit::const_iterator it = accessUnit.begin(); it != accessUnit.end(); it++)
2264	{
2265	UInt numRBSPBytes_nal = UInt((*it)->m_nalUnitData.str().size());
2266	if ((it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI)
2267	{
2268	numRBSPBytes += numRBSPBytes_nal;
2269	numNalus ++;
2270	}
2271	}
2272	accumBitsDU[ pcSlice->getSliceIdx() ] = ( numRBSPBytes << 3 );
2273	accumNalsDU[ pcSlice->getSliceIdx() ] = numNalus; // SEI not counted for bit count; hence shouldn't be counted for # of NALUs - only for consistency
2274	}
2275	processingState = ENCODE_SLICE;
2276	}
2277	break;
2278	case EXECUTE_INLOOPFILTER:
2279	{
2280	// set entropy coder for RD
2281	m_pcEntropyCoder->setEntropyCoder ( m_pcSbacCoder, pcSlice );
2282	#if HIGHER_LAYER_IRAP_SKIP_FLAG
2283	if ( pcSlice->getSPS()->getUseSAO() && !( m_pcEncTop->getSkipPictureAtArcSwitch() && m_pcEncTop->getAdaptiveResolutionChange() > 0 && pcSlice->getLayerId() == 1 && pcSlice->getPOC() == m_pcEncTop->getAdaptiveResolutionChange()) )
2284	#else
2285	if ( pcSlice->getSPS()->getUseSAO() )
2286	#endif
2287	{
2288	m_pcEntropyCoder->resetEntropy();
2289	m_pcEntropyCoder->setBitstream( m_pcBitCounter );
2290	Bool sliceEnabled[NUM_SAO_COMPONENTS];
2291	m_pcSAO->initRDOCabacCoder(m_pcEncTop->getRDGoOnSbacCoder(), pcSlice);
2292	m_pcSAO->SAOProcess(pcPic
2293	, sliceEnabled
2294	, pcPic->getSlice(0)->getLambdas()
2295	#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
2296	, m_pcCfg->getSaoLcuBoundary()
2297	#endif
2298	);
2299	m_pcSAO->PCMLFDisableProcess(pcPic);
2300
2301	//assign SAO slice header
2302	for(Int s=0; s< uiNumSlices; s++)
2303	{
2304	pcPic->getSlice(s)->setSaoEnabledFlag(sliceEnabled[SAO_Y]);
2305	assert(sliceEnabled[SAO_Cb] == sliceEnabled[SAO_Cr]);
2306	pcPic->getSlice(s)->setSaoEnabledFlagChroma(sliceEnabled[SAO_Cb]);
2307	}
2308	}
2309	processingState = ENCODE_SLICE;
2310	}
2311	break;
2312	default:
2313	{
2314	printf("Not a supported encoding state\n");
2315	assert(0);
2316	exit(-1);
2317	}
2318	}
2319	} // end iteration over slices
2320	pcPic->compressMotion();
2321
2322	//-- For time output for each slice
2323	Double dEncTime = (Double)(clock()-iBeforeTime) / CLOCKS_PER_SEC;
2324
2325	const Char* digestStr = NULL;
2326	if (m_pcCfg->getDecodedPictureHashSEIEnabled())
2327	{
2328	/* calculate MD5sum for entire reconstructed picture */
2329	SEIDecodedPictureHash sei_recon_picture_digest;
2330	if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 1)
2331	{
2332	sei_recon_picture_digest.method = SEIDecodedPictureHash::MD5;
2333	calcMD5(*pcPic->getPicYuvRec(), sei_recon_picture_digest.digest);
2334	digestStr = digestToString(sei_recon_picture_digest.digest, 16);
2335	}
2336	else if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 2)
2337	{
2338	sei_recon_picture_digest.method = SEIDecodedPictureHash::CRC;
2339	calcCRC(*pcPic->getPicYuvRec(), sei_recon_picture_digest.digest);
2340	digestStr = digestToString(sei_recon_picture_digest.digest, 2);
2341	}
2342	else if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 3)
2343	{
2344	sei_recon_picture_digest.method = SEIDecodedPictureHash::CHECKSUM;
2345	calcChecksum(*pcPic->getPicYuvRec(), sei_recon_picture_digest.digest);
2346	digestStr = digestToString(sei_recon_picture_digest.digest, 4);
2347	}
2348	#if SVC_EXTENSION
2349	OutputNALUnit nalu(NAL_UNIT_SUFFIX_SEI, pcSlice->getTLayer(), m_layerId);
2350	#else
2351	OutputNALUnit nalu(NAL_UNIT_SUFFIX_SEI, pcSlice->getTLayer());
2352	#endif
2353
2354	/* write the SEI messages */
2355	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
2356	#if O0164_MULTI_LAYER_HRD
2357	m_seiWriter.writeSEImessage(nalu.m_Bitstream, sei_recon_picture_digest, m_pcEncTop->getVPS(), pcSlice->getSPS());
2358	#else
2359	m_seiWriter.writeSEImessage(nalu.m_Bitstream, sei_recon_picture_digest, pcSlice->getSPS());
2360	#endif
2361	writeRBSPTrailingBits(nalu.m_Bitstream);
2362
2363	accessUnit.insert(accessUnit.end(), new NALUnitEBSP(nalu));
2364	}
2365	if (m_pcCfg->getTemporalLevel0IndexSEIEnabled())
2366	{
2367	SEITemporalLevel0Index sei_temporal_level0_index;
2368	if (pcSlice->getRapPicFlag())
2369	{
2370	m_tl0Idx = 0;
2371	m_rapIdx = (m_rapIdx + 1) & 0xFF;
2372	}
2373	else
2374	{
2375	m_tl0Idx = (m_tl0Idx + (pcSlice->getTLayer() ? 0 : 1)) & 0xFF;
2376	}
2377	sei_temporal_level0_index.tl0Idx = m_tl0Idx;
2378	sei_temporal_level0_index.rapIdx = m_rapIdx;
2379
2380	OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
2381
2382	/* write the SEI messages */
2383	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
2384	#if O0164_MULTI_LAYER_HRD
2385	m_seiWriter.writeSEImessage(nalu.m_Bitstream, sei_temporal_level0_index, m_pcEncTop->getVPS(), pcSlice->getSPS());
2386	#else
2387	m_seiWriter.writeSEImessage(nalu.m_Bitstream, sei_temporal_level0_index, pcSlice->getSPS());
2388	#endif
2389	writeRBSPTrailingBits(nalu.m_Bitstream);
2390
2391	/* insert the SEI message NALUnit before any Slice NALUnits */
2392	AccessUnit::iterator it = find_if(accessUnit.begin(), accessUnit.end(), mem_fun(&NALUnit::isSlice));
2393	accessUnit.insert(it, new NALUnitEBSP(nalu));
2394	}
2395
2396	xCalculateAddPSNR( pcPic, pcPic->getPicYuvRec(), accessUnit, dEncTime );
2397
2398	//In case of field coding, compute the interlaced PSNR for both fields
2399	if (isField && ((!pcPic->isTopField() && isTff) \|\| (pcPic->isTopField() && !isTff)) && (pcPic->getPOC()%m_iGopSize != 1))
2400	{
2401	//get complementary top field
2402	TComPic* pcPicTop;
2403	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
2404	while ((*iterPic)->getPOC() != pcPic->getPOC()-1)
2405	{
2406	iterPic ++;
2407	}
2408	pcPicTop = *(iterPic);
2409	xCalculateInterlacedAddPSNR(pcPicTop, pcPic, pcPicTop->getPicYuvRec(), pcPic->getPicYuvRec(), accessUnit, dEncTime );
2410	}
2411	else if (isField && pcPic->getPOC()!= 0 && (pcPic->getPOC()%m_iGopSize == 0))
2412	{
2413	//get complementary bottom field
2414	TComPic* pcPicBottom;
2415	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
2416	while ((*iterPic)->getPOC() != pcPic->getPOC()+1)
2417	{
2418	iterPic ++;
2419	}
2420	pcPicBottom = *(iterPic);
2421	xCalculateInterlacedAddPSNR(pcPic, pcPicBottom, pcPic->getPicYuvRec(), pcPicBottom->getPicYuvRec(), accessUnit, dEncTime );
2422	}
2423
2424	if (digestStr)
2425	{
2426	if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 1)
2427	{
2428	printf(" [MD5:%s]", digestStr);
2429	}
2430	else if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 2)
2431	{
2432	printf(" [CRC:%s]", digestStr);
2433	}
2434	else if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 3)
2435	{
2436	printf(" [Checksum:%s]", digestStr);
2437	}
2438	}
2439	if ( m_pcCfg->getUseRateCtrl() )
2440	{
2441	Double avgQP = m_pcRateCtrl->getRCPic()->calAverageQP();
2442	Double avgLambda = m_pcRateCtrl->getRCPic()->calAverageLambda();
2443	if ( avgLambda < 0.0 )
2444	{
2445	avgLambda = lambda;
2446	}
2447	m_pcRateCtrl->getRCPic()->updateAfterPicture( actualHeadBits, actualTotalBits, avgQP, avgLambda, pcSlice->getSliceType());
2448	m_pcRateCtrl->getRCPic()->addToPictureLsit( m_pcRateCtrl->getPicList() );
2449
2450	m_pcRateCtrl->getRCSeq()->updateAfterPic( actualTotalBits );
2451	if ( pcSlice->getSliceType() != I_SLICE )
2452	{
2453	m_pcRateCtrl->getRCGOP()->updateAfterPicture( actualTotalBits );
2454	}
2455	else // for intra picture, the estimated bits are used to update the current status in the GOP
2456	{
2457	m_pcRateCtrl->getRCGOP()->updateAfterPicture( estimatedBits );
2458	}
2459	}
2460
2461	if( ( m_pcCfg->getPictureTimingSEIEnabled() \|\| m_pcCfg->getDecodingUnitInfoSEIEnabled() ) &&
2462	( pcSlice->getSPS()->getVuiParametersPresentFlag() ) &&
2463	( ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNalHrdParametersPresentFlag() )
2464	\|\| ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getVclHrdParametersPresentFlag() ) ) )
2465	{
2466	TComVUI *vui = pcSlice->getSPS()->getVuiParameters();
2467	TComHRD *hrd = vui->getHrdParameters();
2468
2469	if( hrd->getSubPicCpbParamsPresentFlag() )
2470	{
2471	Int i;
2472	UInt64 ui64Tmp;
2473	UInt uiPrev = 0;
2474	UInt numDU = ( pictureTimingSEI.m_numDecodingUnitsMinus1 + 1 );
2475	UInt *pCRD = &pictureTimingSEI.m_duCpbRemovalDelayMinus1[0];
2476	UInt maxDiff = ( hrd->getTickDivisorMinus2() + 2 ) - 1;
2477
2478	for( i = 0; i < numDU; i ++ )
2479	{
2480	pictureTimingSEI.m_numNalusInDuMinus1[ i ] = ( i == 0 ) ? ( accumNalsDU[ i ] - 1 ) : ( accumNalsDU[ i ] - accumNalsDU[ i - 1] - 1 );
2481	}
2482
2483	if( numDU == 1 )
2484	{
2485	pCRD[ 0 ] = 0; /* don't care */
2486	}
2487	else
2488	{
2489	pCRD[ numDU - 1 ] = 0;/* by definition */
2490	UInt tmp = 0;
2491	UInt accum = 0;
2492
2493	for( i = ( numDU - 2 ); i >= 0; i -- )
2494	{
2495	ui64Tmp = ( ( ( accumBitsDU[ numDU - 1 ] - accumBitsDU[ i ] ) * ( vui->getTimingInfo()->getTimeScale() / vui->getTimingInfo()->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
2496	if( (UInt)ui64Tmp > maxDiff )
2497	{
2498	tmp ++;
2499	}
2500	}
2501	uiPrev = 0;
2502
2503	UInt flag = 0;
2504	for( i = ( numDU - 2 ); i >= 0; i -- )
2505	{
2506	flag = 0;
2507	ui64Tmp = ( ( ( accumBitsDU[ numDU - 1 ] - accumBitsDU[ i ] ) * ( vui->getTimingInfo()->getTimeScale() / vui->getTimingInfo()->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
2508
2509	if( (UInt)ui64Tmp > maxDiff )
2510	{
2511	if(uiPrev >= maxDiff - tmp)
2512	{
2513	ui64Tmp = uiPrev + 1;
2514	flag = 1;
2515	}
2516	else ui64Tmp = maxDiff - tmp + 1;
2517	}
2518	pCRD[ i ] = (UInt)ui64Tmp - uiPrev - 1;
2519	if( (Int)pCRD[ i ] < 0 )
2520	{
2521	pCRD[ i ] = 0;
2522	}
2523	else if (tmp > 0 && flag == 1)
2524	{
2525	tmp --;
2526	}
2527	accum += pCRD[ i ] + 1;
2528	uiPrev = accum;
2529	}
2530	}
2531	}
2532	if( m_pcCfg->getPictureTimingSEIEnabled() )
2533	{
2534	{
2535	OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, pcSlice->getTLayer());
2536	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
2537	pictureTimingSEI.m_picStruct = (isField && pcSlice->getPic()->isTopField())? 1 : isField? 2 : 0;
2538	#if O0164_MULTI_LAYER_HRD
2539	m_seiWriter.writeSEImessage(nalu.m_Bitstream, pictureTimingSEI, m_pcEncTop->getVPS(), pcSlice->getSPS());
2540	#else
2541	m_seiWriter.writeSEImessage(nalu.m_Bitstream, pictureTimingSEI, pcSlice->getSPS());
2542	#endif
2543	writeRBSPTrailingBits(nalu.m_Bitstream);
2544	UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
2545	UInt offsetPosition = m_activeParameterSetSEIPresentInAU
2546	+ m_bufferingPeriodSEIPresentInAU; // Insert PT SEI after APS and BP SEI
2547	AccessUnit::iterator it;
2548	for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
2549	{
2550	it++;
2551	}
2552	accessUnit.insert(it, new NALUnitEBSP(nalu));
2553	m_pictureTimingSEIPresentInAU = true;
2554	}
2555	if ( m_pcCfg->getScalableNestingSEIEnabled() ) // put picture timing SEI into scalable nesting SEI
2556	{
2557	OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, pcSlice->getTLayer());
2558	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
2559	scalableNestingSEI.m_nestedSEIs.clear();
2560	scalableNestingSEI.m_nestedSEIs.push_back(&pictureTimingSEI);
2561	#if O0164_MULTI_LAYER_HRD
2562	m_seiWriter.writeSEImessage(nalu.m_Bitstream, scalableNestingSEI, m_pcEncTop->getVPS(), pcSlice->getSPS());
2563	#else
2564	m_seiWriter.writeSEImessage(nalu.m_Bitstream, scalableNestingSEI, pcSlice->getSPS());
2565	#endif
2566	writeRBSPTrailingBits(nalu.m_Bitstream);
2567	UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
2568	UInt offsetPosition = m_activeParameterSetSEIPresentInAU
2569	+ m_bufferingPeriodSEIPresentInAU + m_pictureTimingSEIPresentInAU + m_nestedBufferingPeriodSEIPresentInAU; // Insert PT SEI after APS and BP SEI
2570	AccessUnit::iterator it;
2571	for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
2572	{
2573	it++;
2574	}
2575	accessUnit.insert(it, new NALUnitEBSP(nalu));
2576	m_nestedPictureTimingSEIPresentInAU = true;
2577	}
2578	}
2579	if( m_pcCfg->getDecodingUnitInfoSEIEnabled() && hrd->getSubPicCpbParamsPresentFlag() )
2580	{
2581	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
2582	for( Int i = 0; i < ( pictureTimingSEI.m_numDecodingUnitsMinus1 + 1 ); i ++ )
2583	{
2584	OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, pcSlice->getTLayer());
2585
2586	SEIDecodingUnitInfo tempSEI;
2587	tempSEI.m_decodingUnitIdx = i;
2588	tempSEI.m_duSptCpbRemovalDelay = pictureTimingSEI.m_duCpbRemovalDelayMinus1[i] + 1;
2589	tempSEI.m_dpbOutputDuDelayPresentFlag = false;
2590	tempSEI.m_picSptDpbOutputDuDelay = picSptDpbOutputDuDelay;
2591
2592	AccessUnit::iterator it;
2593	// Insert the first one in the right location, before the first slice
2594	if(i == 0)
2595	{
2596	// Insert before the first slice.
2597	#if O0164_MULTI_LAYER_HRD
2598	m_seiWriter.writeSEImessage(nalu.m_Bitstream, tempSEI, m_pcEncTop->getVPS(), pcSlice->getSPS());
2599	#else
2600	m_seiWriter.writeSEImessage(nalu.m_Bitstream, tempSEI, pcSlice->getSPS());
2601	#endif
2602	writeRBSPTrailingBits(nalu.m_Bitstream);
2603
2604	UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
2605	UInt offsetPosition = m_activeParameterSetSEIPresentInAU
2606	+ m_bufferingPeriodSEIPresentInAU
2607	+ m_pictureTimingSEIPresentInAU; // Insert DU info SEI after APS, BP and PT SEI
2608	for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
2609	{
2610	it++;
2611	}
2612	accessUnit.insert(it, new NALUnitEBSP(nalu));
2613	}
2614	else
2615	{
2616	Int ctr;
2617	// For the second decoding unit onwards we know how many NALUs are present
2618	for (ctr = 0, it = accessUnit.begin(); it != accessUnit.end(); it++)
2619	{
2620	if(ctr == accumNalsDU[ i - 1 ])
2621	{
2622	// Insert before the first slice.
2623	#if O0164_MULTI_LAYER_HRD
2624	m_seiWriter.writeSEImessage(nalu.m_Bitstream, tempSEI, m_pcEncTop->getVPS(), pcSlice->getSPS());
2625	#else
2626	m_seiWriter.writeSEImessage(nalu.m_Bitstream, tempSEI, pcSlice->getSPS());
2627	#endif
2628	writeRBSPTrailingBits(nalu.m_Bitstream);
2629
2630	accessUnit.insert(it, new NALUnitEBSP(nalu));
2631	break;
2632	}
2633	if ((it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI)
2634	{
2635	ctr++;
2636	}
2637	}
2638	}
2639	}
2640	}
2641	}
2642	xResetNonNestedSEIPresentFlags();
2643	xResetNestedSEIPresentFlags();
2644	pcPic->getPicYuvRec()->copyToPic(pcPicYuvRecOut);
2645
2646	#if M0040_ADAPTIVE_RESOLUTION_CHANGE
2647	pcPicYuvRecOut->setReconstructed(true);
2648	#endif
2649
2650	pcPic->setReconMark ( true );
2651	m_bFirst = false;
2652	m_iNumPicCoded++;
2653	m_totalCoded ++;
2654	/* logging: insert a newline at end of picture period */
2655	printf("\n");
2656	fflush(stdout);
2657
2658	delete[] pcSubstreamsOut;
2659	}
2660	delete pcBitstreamRedirect;
2661
2662	if( accumBitsDU != NULL) delete accumBitsDU;
2663	if( accumNalsDU != NULL) delete accumNalsDU;
2664
2665	#if SVC_EXTENSION
2666	assert ( m_iNumPicCoded <= 1 \|\| (isField && iPOCLast == 1) );
2667	#else
2668	assert ( (m_iNumPicCoded == iNumPicRcvd) \|\| (isField && iPOCLast == 1) );
2669	#endif
2670	}
2671
2672	#if !SVC_EXTENSION
2673	Void TEncGOP::printOutSummary(UInt uiNumAllPicCoded, Bool isField)
2674	{
2675	assert (uiNumAllPicCoded == m_gcAnalyzeAll.getNumPic());
2676
2677
2678	//--CFG_KDY
2679	if(isField)
2680	{
2681	m_gcAnalyzeAll.setFrmRate( m_pcCfg->getFrameRate() * 2);
2682	m_gcAnalyzeI.setFrmRate( m_pcCfg->getFrameRate() * 2);
2683	m_gcAnalyzeP.setFrmRate( m_pcCfg->getFrameRate() * 2);
2684	m_gcAnalyzeB.setFrmRate( m_pcCfg->getFrameRate() * 2);
2685	}
2686	else
2687	{
2688	m_gcAnalyzeAll.setFrmRate( m_pcCfg->getFrameRate() );
2689	m_gcAnalyzeI.setFrmRate( m_pcCfg->getFrameRate() );
2690	m_gcAnalyzeP.setFrmRate( m_pcCfg->getFrameRate() );
2691	m_gcAnalyzeB.setFrmRate( m_pcCfg->getFrameRate() );
2692	}
2693
2694	//-- all
2695	printf( "\n\nSUMMARY --------------------------------------------------------\n" );
2696	m_gcAnalyzeAll.printOut('a');
2697
2698	printf( "\n\nI Slices--------------------------------------------------------\n" );
2699	m_gcAnalyzeI.printOut('i');
2700
2701	printf( "\n\nP Slices--------------------------------------------------------\n" );
2702	m_gcAnalyzeP.printOut('p');
2703
2704	printf( "\n\nB Slices--------------------------------------------------------\n" );
2705	m_gcAnalyzeB.printOut('b');
2706
2707	#if _SUMMARY_OUT_
2708	m_gcAnalyzeAll.printSummaryOut();
2709	#endif
2710	#if _SUMMARY_PIC_
2711	m_gcAnalyzeI.printSummary('I');
2712	m_gcAnalyzeP.printSummary('P');
2713	m_gcAnalyzeB.printSummary('B');
2714	#endif
2715
2716	if(isField)
2717	{
2718	//-- interlaced summary
2719	m_gcAnalyzeAll_in.setFrmRate( m_pcCfg->getFrameRate());
2720	printf( "\n\nSUMMARY INTERLACED ---------------------------------------------\n" );
2721	m_gcAnalyzeAll_in.printOutInterlaced('a', m_gcAnalyzeAll.getBits());
2722
2723	#if _SUMMARY_OUT_
2724	m_gcAnalyzeAll_in.printSummaryOutInterlaced();
2725	#endif
2726	}
2727
2728	printf("\nRVM: %.3lf\n" , xCalculateRVM());
2729	}
2730	#endif
2731
2732	Void TEncGOP::preLoopFilterPicAll( TComPic* pcPic, UInt64& ruiDist, UInt64& ruiBits )
2733	{
2734	TComSlice* pcSlice = pcPic->getSlice(pcPic->getCurrSliceIdx());
2735	Bool bCalcDist = false;
2736	m_pcLoopFilter->setCfg(m_pcCfg->getLFCrossTileBoundaryFlag());
2737	m_pcLoopFilter->loopFilterPic( pcPic );
2738
2739	m_pcEntropyCoder->setEntropyCoder ( m_pcEncTop->getRDGoOnSbacCoder(), pcSlice );
2740	m_pcEntropyCoder->resetEntropy ();
2741	m_pcEntropyCoder->setBitstream ( m_pcBitCounter );
2742	m_pcEntropyCoder->resetEntropy ();
2743	ruiBits += m_pcEntropyCoder->getNumberOfWrittenBits();
2744
2745	if (!bCalcDist)
2746	ruiDist = xFindDistortionFrame(pcPic->getPicYuvOrg(), pcPic->getPicYuvRec());
2747	}
2748
2749	// ====================================================================================================================
2750	// Protected member functions
2751	// ====================================================================================================================
2752
2753
2754	Void TEncGOP::xInitGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic>& rcListPic, TComList<TComPicYuv>& rcListPicYuvRecOut, Bool isField )
2755	{
2756	assert( iNumPicRcvd > 0 );
2757	// Exception for the first frames
2758	if ( ( isField && (iPOCLast == 0 \|\| iPOCLast == 1) ) \|\| (!isField && (iPOCLast == 0)) )
2759	{
2760	m_iGopSize = 1;
2761	}
2762	else
2763	{
2764	m_iGopSize = m_pcCfg->getGOPSize();
2765	}
2766	assert (m_iGopSize > 0);
2767
2768	return;
2769	}
2770
2771	Void TEncGOP::xInitGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic>& rcListPic, TComList<TComPicYuv>& rcListPicYuvRecOut )
2772	{
2773	assert( iNumPicRcvd > 0 );
2774	// Exception for the first frame
2775	if ( iPOCLast == 0 )
2776	{
2777	m_iGopSize = 1;
2778	}
2779	else
2780	m_iGopSize = m_pcCfg->getGOPSize();
2781
2782	assert (m_iGopSize > 0);
2783
2784	return;
2785	}
2786
2787	Void TEncGOP::xGetBuffer( TComList<TComPic*>& rcListPic,
2788	TComList<TComPicYuv*>& rcListPicYuvRecOut,
2789	Int iNumPicRcvd,
2790	Int iTimeOffset,
2791	TComPic*& rpcPic,
2792	TComPicYuv*& rpcPicYuvRecOut,
2793	Int pocCurr,
2794	Bool isField)
2795	{
2796	Int i;
2797	// Rec. output
2798	TComList<TComPicYuv*>::iterator iterPicYuvRec = rcListPicYuvRecOut.end();
2799
2800	if (isField)
2801	{
2802	for ( i = 0; i < ( (pocCurr == 0 ) \|\| (pocCurr == 1 ) ? (iNumPicRcvd - iTimeOffset + 1) : (iNumPicRcvd - iTimeOffset + 2) ); i++ )
2803	{
2804	iterPicYuvRec--;
2805	}
2806	}
2807	else
2808	{
2809	for ( i = 0; i < (iNumPicRcvd - iTimeOffset + 1); i++ )
2810	{
2811	iterPicYuvRec--;
2812	}
2813
2814	}
2815
2816	if (isField)
2817	{
2818	if(pocCurr == 1)
2819	{
2820	iterPicYuvRec++;
2821	}
2822	}
2823	rpcPicYuvRecOut = *(iterPicYuvRec);
2824
2825	// Current pic.
2826	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
2827	while (iterPic != rcListPic.end())
2828	{
2829	rpcPic = *(iterPic);
2830	rpcPic->setCurrSliceIdx(0);
2831	if (rpcPic->getPOC() == pocCurr)
2832	{
2833	break;
2834	}
2835	iterPic++;
2836	}
2837
2838	assert( rpcPic != NULL );
2839	assert( rpcPic->getPOC() == pocCurr );
2840
2841	return;
2842	}
2843
2844	UInt64 TEncGOP::xFindDistortionFrame (TComPicYuv* pcPic0, TComPicYuv* pcPic1)
2845	{
2846	Int x, y;
2847	Pel* pSrc0 = pcPic0 ->getLumaAddr();
2848	Pel* pSrc1 = pcPic1 ->getLumaAddr();
2849	UInt uiShift = 2 * DISTORTION_PRECISION_ADJUSTMENT(g_bitDepthY-8);
2850	Int iTemp;
2851
2852	Int iStride = pcPic0->getStride();
2853	Int iWidth = pcPic0->getWidth();
2854	Int iHeight = pcPic0->getHeight();
2855
2856	UInt64 uiTotalDiff = 0;
2857
2858	for( y = 0; y < iHeight; y++ )
2859	{
2860	for( x = 0; x < iWidth; x++ )
2861	{
2862	iTemp = pSrc0[x] - pSrc1[x]; uiTotalDiff += (iTemp*iTemp) >> uiShift;
2863	}
2864	pSrc0 += iStride;
2865	pSrc1 += iStride;
2866	}
2867
2868	uiShift = 2 * DISTORTION_PRECISION_ADJUSTMENT(g_bitDepthC-8);
2869	iHeight >>= 1;
2870	iWidth >>= 1;
2871	iStride >>= 1;
2872
2873	pSrc0 = pcPic0->getCbAddr();
2874	pSrc1 = pcPic1->getCbAddr();
2875
2876	for( y = 0; y < iHeight; y++ )
2877	{
2878	for( x = 0; x < iWidth; x++ )
2879	{
2880	iTemp = pSrc0[x] - pSrc1[x]; uiTotalDiff += (iTemp*iTemp) >> uiShift;
2881	}
2882	pSrc0 += iStride;
2883	pSrc1 += iStride;
2884	}
2885
2886	pSrc0 = pcPic0->getCrAddr();
2887	pSrc1 = pcPic1->getCrAddr();
2888
2889	for( y = 0; y < iHeight; y++ )
2890	{
2891	for( x = 0; x < iWidth; x++ )
2892	{
2893	iTemp = pSrc0[x] - pSrc1[x]; uiTotalDiff += (iTemp*iTemp) >> uiShift;
2894	}
2895	pSrc0 += iStride;
2896	pSrc1 += iStride;
2897	}
2898
2899	return uiTotalDiff;
2900	}
2901
2902	#if VERBOSE_RATE
2903	static const Char* nalUnitTypeToString(NalUnitType type)
2904	{
2905	switch (type)
2906	{
2907	case NAL_UNIT_CODED_SLICE_TRAIL_R: return "TRAIL_R";
2908	case NAL_UNIT_CODED_SLICE_TRAIL_N: return "TRAIL_N";
2909	case NAL_UNIT_CODED_SLICE_TSA_R: return "TSA_R";
2910	case NAL_UNIT_CODED_SLICE_TSA_N: return "TSA_N";
2911	case NAL_UNIT_CODED_SLICE_STSA_R: return "STSA_R";
2912	case NAL_UNIT_CODED_SLICE_STSA_N: return "STSA_N";
2913	case NAL_UNIT_CODED_SLICE_BLA_W_LP: return "BLA_W_LP";
2914	case NAL_UNIT_CODED_SLICE_BLA_W_RADL: return "BLA_W_RADL";
2915	case NAL_UNIT_CODED_SLICE_BLA_N_LP: return "BLA_N_LP";
2916	case NAL_UNIT_CODED_SLICE_IDR_W_RADL: return "IDR_W_RADL";
2917	case NAL_UNIT_CODED_SLICE_IDR_N_LP: return "IDR_N_LP";
2918	case NAL_UNIT_CODED_SLICE_CRA: return "CRA";
2919	case NAL_UNIT_CODED_SLICE_RADL_R: return "RADL_R";
2920	case NAL_UNIT_CODED_SLICE_RASL_R: return "RASL_R";
2921	case NAL_UNIT_VPS: return "VPS";
2922	case NAL_UNIT_SPS: return "SPS";
2923	case NAL_UNIT_PPS: return "PPS";
2924	case NAL_UNIT_ACCESS_UNIT_DELIMITER: return "AUD";
2925	case NAL_UNIT_EOS: return "EOS";
2926	case NAL_UNIT_EOB: return "EOB";
2927	case NAL_UNIT_FILLER_DATA: return "FILLER";
2928	case NAL_UNIT_PREFIX_SEI: return "SEI";
2929	case NAL_UNIT_SUFFIX_SEI: return "SEI";
2930	default: return "UNK";
2931	}
2932	}
2933	#endif
2934
2935	Void TEncGOP::xCalculateAddPSNR( TComPic* pcPic, TComPicYuv* pcPicD, const AccessUnit& accessUnit, Double dEncTime )
2936	{
2937	Int x, y;
2938	UInt64 uiSSDY = 0;
2939	UInt64 uiSSDU = 0;
2940	UInt64 uiSSDV = 0;
2941
2942	Double dYPSNR = 0.0;
2943	Double dUPSNR = 0.0;
2944	Double dVPSNR = 0.0;
2945
2946	//===== calculate PSNR =====
2947	Pel* pOrg = pcPic ->getPicYuvOrg()->getLumaAddr();
2948	Pel* pRec = pcPicD->getLumaAddr();
2949	Int iStride = pcPicD->getStride();
2950
2951	Int iWidth;
2952	Int iHeight;
2953
2954	iWidth = pcPicD->getWidth () - m_pcEncTop->getPad(0);
2955	iHeight = pcPicD->getHeight() - m_pcEncTop->getPad(1);
2956
2957	Int iSize = iWidth*iHeight;
2958
2959	for( y = 0; y < iHeight; y++ )
2960	{
2961	for( x = 0; x < iWidth; x++ )
2962	{
2963	Int iDiff = (Int)( pOrg[x] - pRec[x] );
2964	uiSSDY += iDiff * iDiff;
2965	}
2966	pOrg += iStride;
2967	pRec += iStride;
2968	}
2969
2970	iHeight >>= 1;
2971	iWidth >>= 1;
2972	iStride >>= 1;
2973	pOrg = pcPic ->getPicYuvOrg()->getCbAddr();
2974	pRec = pcPicD->getCbAddr();
2975
2976	for( y = 0; y < iHeight; y++ )
2977	{
2978	for( x = 0; x < iWidth; x++ )
2979	{
2980	Int iDiff = (Int)( pOrg[x] - pRec[x] );
2981	uiSSDU += iDiff * iDiff;
2982	}
2983	pOrg += iStride;
2984	pRec += iStride;
2985	}
2986
2987	pOrg = pcPic ->getPicYuvOrg()->getCrAddr();
2988	pRec = pcPicD->getCrAddr();
2989
2990	for( y = 0; y < iHeight; y++ )
2991	{
2992	for( x = 0; x < iWidth; x++ )
2993	{
2994	Int iDiff = (Int)( pOrg[x] - pRec[x] );
2995	uiSSDV += iDiff * iDiff;
2996	}
2997	pOrg += iStride;
2998	pRec += iStride;
2999	}
3000
3001	Int maxvalY = 255 << (g_bitDepthY-8);
3002	Int maxvalC = 255 << (g_bitDepthC-8);
3003	Double fRefValueY = (Double) maxvalY * maxvalY * iSize;
3004	Double fRefValueC = (Double) maxvalC * maxvalC * iSize / 4.0;
3005	dYPSNR = ( uiSSDY ? 10.0 * log10( fRefValueY / (Double)uiSSDY ) : 99.99 );
3006	dUPSNR = ( uiSSDU ? 10.0 * log10( fRefValueC / (Double)uiSSDU ) : 99.99 );
3007	dVPSNR = ( uiSSDV ? 10.0 * log10( fRefValueC / (Double)uiSSDV ) : 99.99 );
3008
3009	/* calculate the size of the access unit, excluding:
3010	* - any AnnexB contributions (start_code_prefix, zero_byte, etc.,)
3011	* - SEI NAL units
3012	*/
3013	UInt numRBSPBytes = 0;
3014	for (AccessUnit::const_iterator it = accessUnit.begin(); it != accessUnit.end(); it++)
3015	{
3016	UInt numRBSPBytes_nal = UInt((*it)->m_nalUnitData.str().size());
3017	#if VERBOSE_RATE
3018	printf("*** %6s numBytesInNALunit: %u\n", nalUnitTypeToString((*it)->m_nalUnitType), numRBSPBytes_nal);
3019	#endif
3020	if ((it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI)
3021	{
3022	numRBSPBytes += numRBSPBytes_nal;
3023	}
3024	}
3025
3026	UInt uibits = numRBSPBytes * 8;
3027	m_vRVM_RP.push_back( uibits );
3028
3029	//===== add PSNR =====
3030	#if SVC_EXTENSION
3031	m_gcAnalyzeAll[m_layerId].addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
3032	TComSlice* pcSlice = pcPic->getSlice(0);
3033	if (pcSlice->isIntra())
3034	{
3035	m_gcAnalyzeI[m_layerId].addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
3036	}
3037	if (pcSlice->isInterP())
3038	{
3039	m_gcAnalyzeP[m_layerId].addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
3040	}
3041	if (pcSlice->isInterB())
3042	{
3043	m_gcAnalyzeB[m_layerId].addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
3044	}
3045	#else
3046	m_gcAnalyzeAll.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
3047	TComSlice* pcSlice = pcPic->getSlice(0);
3048	if (pcSlice->isIntra())
3049	{
3050	m_gcAnalyzeI.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
3051	}
3052	if (pcSlice->isInterP())
3053	{
3054	m_gcAnalyzeP.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
3055	}
3056	if (pcSlice->isInterB())
3057	{
3058	m_gcAnalyzeB.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
3059	}
3060	#endif
3061
3062	Char c = (pcSlice->isIntra() ? 'I' : pcSlice->isInterP() ? 'P' : 'B');
3063	if (!pcSlice->isReferenced()) c += 32;
3064
3065	#if SVC_EXTENSION
3066	#if ADAPTIVE_QP_SELECTION
3067	printf("POC %4d LId: %1d TId: %1d ( %c-SLICE %s, nQP %d QP %d ) %10d bits",
3068	pcSlice->getPOC(),
3069	pcSlice->getLayerId(),
3070	pcSlice->getTLayer(),
3071	c,
3072	NaluToStr( pcSlice->getNalUnitType() ).data(),
3073	pcSlice->getSliceQpBase(),
3074	pcSlice->getSliceQp(),
3075	uibits );
3076	#else
3077	printf("POC %4d LId: %1d TId: %1d ( %c-SLICE %s, QP %d ) %10d bits",
3078	pcSlice->getPOC()-pcSlice->getLastIDR(),
3079	pcSlice->getLayerId(),
3080	pcSlice->getTLayer(),
3081	c,
3082	NaluToStr( pcSlice->getNalUnitType() ).data().
3083	pcSlice->getSliceQp(),
3084	uibits );
3085	#endif
3086	#else
3087	#if ADAPTIVE_QP_SELECTION
3088	printf("POC %4d TId: %1d ( %c-SLICE, nQP %d QP %d ) %10d bits",
3089	pcSlice->getPOC(),
3090	pcSlice->getTLayer(),
3091	c,
3092	pcSlice->getSliceQpBase(),
3093	pcSlice->getSliceQp(),
3094	uibits );
3095	#else
3096	printf("POC %4d TId: %1d ( %c-SLICE, QP %d ) %10d bits",
3097	pcSlice->getPOC()-pcSlice->getLastIDR(),
3098	pcSlice->getTLayer(),
3099	c,
3100	pcSlice->getSliceQp(),
3101	uibits );
3102	#endif
3103	#endif
3104
3105	printf(" [Y %6.4lf dB U %6.4lf dB V %6.4lf dB]", dYPSNR, dUPSNR, dVPSNR );
3106	printf(" [ET %5.0f ]", dEncTime );
3107
3108	for (Int iRefList = 0; iRefList < 2; iRefList++)
3109	{
3110	printf(" [L%d ", iRefList);
3111	for (Int iRefIndex = 0; iRefIndex < pcSlice->getNumRefIdx(RefPicList(iRefList)); iRefIndex++)
3112	{
3113	#if SVC_EXTENSION
3114	#if VPS_EXTN_DIRECT_REF_LAYERS
3115	if( pcSlice->getRefPic(RefPicList(iRefList), iRefIndex)->isILR(m_layerId) )
3116	{
3117	printf( "%d(%d)", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex)-pcSlice->getLastIDR(), pcSlice->getRefPic(RefPicList(iRefList), iRefIndex)->getLayerId() );
3118	}
3119	else
3120	{
3121	printf ("%d", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex)-pcSlice->getLastIDR());
3122	}
3123	#endif
3124	if( pcSlice->getEnableTMVPFlag() && iRefList == 1 - pcSlice->getColFromL0Flag() && iRefIndex == pcSlice->getColRefIdx() )
3125	{
3126	printf( "c" );
3127	}
3128
3129	printf( " " );
3130	#else
3131	printf ("%d ", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex)-pcSlice->getLastIDR());
3132	#endif
3133	}
3134	printf("]");
3135	}
3136	}
3137
3138
3139	Void reinterlace(Pel* top, Pel* bottom, Pel* dst, UInt stride, UInt width, UInt height, Bool isTff)
3140	{
3141
3142	for (Int y = 0; y < height; y++)
3143	{
3144	for (Int x = 0; x < width; x++)
3145	{
3146	dst[x] = isTff ? top[x] : bottom[x];
3147	dst[stride+x] = isTff ? bottom[x] : top[x];
3148	}
3149	top += stride;
3150	bottom += stride;
3151	dst += stride*2;
3152	}
3153	}
3154
3155	Void TEncGOP::xCalculateInterlacedAddPSNR( TComPic* pcPicOrgTop, TComPic* pcPicOrgBottom, TComPicYuv* pcPicRecTop, TComPicYuv* pcPicRecBottom, const AccessUnit& accessUnit, Double dEncTime )
3156	{
3157	Int x, y;
3158
3159	UInt64 uiSSDY_in = 0;
3160	UInt64 uiSSDU_in = 0;
3161	UInt64 uiSSDV_in = 0;
3162
3163	Double dYPSNR_in = 0.0;
3164	Double dUPSNR_in = 0.0;
3165	Double dVPSNR_in = 0.0;
3166
3167	/------ INTERLACED PSNR -----------/
3168
3169	/* Luma */
3170
3171	Pel* pOrgTop = pcPicOrgTop->getPicYuvOrg()->getLumaAddr();
3172	Pel* pOrgBottom = pcPicOrgBottom->getPicYuvOrg()->getLumaAddr();
3173	Pel* pRecTop = pcPicRecTop->getLumaAddr();
3174	Pel* pRecBottom = pcPicRecBottom->getLumaAddr();
3175
3176	Int iWidth;
3177	Int iHeight;
3178	Int iStride;
3179
3180	iWidth = pcPicOrgTop->getPicYuvOrg()->getWidth () - m_pcEncTop->getPad(0);
3181	iHeight = pcPicOrgTop->getPicYuvOrg()->getHeight() - m_pcEncTop->getPad(1);
3182	iStride = pcPicOrgTop->getPicYuvOrg()->getStride();
3183	Int iSize = iWidth*iHeight;
3184	bool isTff = pcPicOrgTop->isTopField();
3185
3186	TComPicYuv* pcOrgInterlaced = new TComPicYuv;
3187	#if AUXILIARY_PICTURES
3188	pcOrgInterlaced->create( iWidth, iHeight << 1, pcPicOrgTop->getChromaFormat(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
3189	#else
3190	pcOrgInterlaced->create( iWidth, iHeight << 1, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
3191	#endif
3192
3193	TComPicYuv* pcRecInterlaced = new TComPicYuv;
3194	#if AUXILIARY_PICTURES
3195	pcRecInterlaced->create( iWidth, iHeight << 1, pcPicOrgTop->getChromaFormat(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
3196	#else
3197	pcRecInterlaced->create( iWidth, iHeight << 1, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
3198	#endif
3199
3200	Pel* pOrgInterlaced = pcOrgInterlaced->getLumaAddr();
3201	Pel* pRecInterlaced = pcRecInterlaced->getLumaAddr();
3202
3203	//=== Interlace fields ====
3204	reinterlace(pOrgTop, pOrgBottom, pOrgInterlaced, iStride, iWidth, iHeight, isTff);
3205	reinterlace(pRecTop, pRecBottom, pRecInterlaced, iStride, iWidth, iHeight, isTff);
3206
3207	//===== calculate PSNR =====
3208	for( y = 0; y < iHeight << 1; y++ )
3209	{
3210	for( x = 0; x < iWidth; x++ )
3211	{
3212	Int iDiff = (Int)( pOrgInterlaced[x] - pRecInterlaced[x] );
3213	uiSSDY_in += iDiff * iDiff;
3214	}
3215	pOrgInterlaced += iStride;
3216	pRecInterlaced += iStride;
3217	}
3218
3219	/Chroma/
3220
3221	iHeight >>= 1;
3222	iWidth >>= 1;
3223	iStride >>= 1;
3224
3225	pOrgTop = pcPicOrgTop->getPicYuvOrg()->getCbAddr();
3226	pOrgBottom = pcPicOrgBottom->getPicYuvOrg()->getCbAddr();
3227	pRecTop = pcPicRecTop->getCbAddr();
3228	pRecBottom = pcPicRecBottom->getCbAddr();
3229	pOrgInterlaced = pcOrgInterlaced->getCbAddr();
3230	pRecInterlaced = pcRecInterlaced->getCbAddr();
3231
3232	//=== Interlace fields ====
3233	reinterlace(pOrgTop, pOrgBottom, pOrgInterlaced, iStride, iWidth, iHeight, isTff);
3234	reinterlace(pRecTop, pRecBottom, pRecInterlaced, iStride, iWidth, iHeight, isTff);
3235
3236	//===== calculate PSNR =====
3237	for( y = 0; y < iHeight << 1; y++ )
3238	{
3239	for( x = 0; x < iWidth; x++ )
3240	{
3241	Int iDiff = (Int)( pOrgInterlaced[x] - pRecInterlaced[x] );
3242	uiSSDU_in += iDiff * iDiff;
3243	}
3244	pOrgInterlaced += iStride;
3245	pRecInterlaced += iStride;
3246	}
3247
3248	pOrgTop = pcPicOrgTop->getPicYuvOrg()->getCrAddr();
3249	pOrgBottom = pcPicOrgBottom->getPicYuvOrg()->getCrAddr();
3250	pRecTop = pcPicRecTop->getCrAddr();
3251	pRecBottom = pcPicRecBottom->getCrAddr();
3252	pOrgInterlaced = pcOrgInterlaced->getCrAddr();
3253	pRecInterlaced = pcRecInterlaced->getCrAddr();
3254
3255	//=== Interlace fields ====
3256	reinterlace(pOrgTop, pOrgBottom, pOrgInterlaced, iStride, iWidth, iHeight, isTff);
3257	reinterlace(pRecTop, pRecBottom, pRecInterlaced, iStride, iWidth, iHeight, isTff);
3258
3259	//===== calculate PSNR =====
3260	for( y = 0; y < iHeight << 1; y++ )
3261	{
3262	for( x = 0; x < iWidth; x++ )
3263	{
3264	Int iDiff = (Int)( pOrgInterlaced[x] - pRecInterlaced[x] );
3265	uiSSDV_in += iDiff * iDiff;
3266	}
3267	pOrgInterlaced += iStride;
3268	pRecInterlaced += iStride;
3269	}
3270
3271	Int maxvalY = 255 << (g_bitDepthY-8);
3272	Int maxvalC = 255 << (g_bitDepthC-8);
3273	Double fRefValueY = (Double) maxvalY * maxvalY * iSize*2;
3274	Double fRefValueC = (Double) maxvalC * maxvalC * iSize*2 / 4.0;
3275	dYPSNR_in = ( uiSSDY_in ? 10.0 * log10( fRefValueY / (Double)uiSSDY_in ) : 99.99 );
3276	dUPSNR_in = ( uiSSDU_in ? 10.0 * log10( fRefValueC / (Double)uiSSDU_in ) : 99.99 );
3277	dVPSNR_in = ( uiSSDV_in ? 10.0 * log10( fRefValueC / (Double)uiSSDV_in ) : 99.99 );
3278
3279	/* calculate the size of the access unit, excluding:
3280	* - any AnnexB contributions (start_code_prefix, zero_byte, etc.,)
3281	* - SEI NAL units
3282	*/
3283	UInt numRBSPBytes = 0;
3284	for (AccessUnit::const_iterator it = accessUnit.begin(); it != accessUnit.end(); it++)
3285	{
3286	UInt numRBSPBytes_nal = UInt((*it)->m_nalUnitData.str().size());
3287
3288	if ((it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI)
3289	numRBSPBytes += numRBSPBytes_nal;
3290	}
3291
3292	UInt uibits = numRBSPBytes * 8 ;
3293
3294	//===== add PSNR =====
3295	m_gcAnalyzeAll_in.addResult (dYPSNR_in, dUPSNR_in, dVPSNR_in, (Double)uibits);
3296
3297	printf("\n Interlaced frame %d: [Y %6.4lf dB U %6.4lf dB V %6.4lf dB]", pcPicOrgBottom->getPOC()/2 , dYPSNR_in, dUPSNR_in, dVPSNR_in );
3298
3299	pcOrgInterlaced->destroy();
3300	delete pcOrgInterlaced;
3301	pcRecInterlaced->destroy();
3302	delete pcRecInterlaced;
3303	}
3304
3305
3306
3307	/** Function for deciding the nal_unit_type.
3308	* \param pocCurr POC of the current picture
3309	* \returns the nal unit type of the picture
3310	* This function checks the configuration and returns the appropriate nal_unit_type for the picture.
3311	*/
3312	NalUnitType TEncGOP::getNalUnitType(Int pocCurr, Int lastIDR, Bool isField)
3313	{
3314	if (pocCurr == 0)
3315	{
3316	return NAL_UNIT_CODED_SLICE_IDR_W_RADL;
3317	}
3318	if ((pocCurr - isField) % m_pcCfg->getIntraPeriod() == 0)
3319	{
3320	if (m_pcCfg->getDecodingRefreshType() == 1)
3321	{
3322	return NAL_UNIT_CODED_SLICE_CRA;
3323	}
3324	else if (m_pcCfg->getDecodingRefreshType() == 2)
3325	{
3326	return NAL_UNIT_CODED_SLICE_IDR_W_RADL;
3327	}
3328	}
3329	if(m_pocCRA>0)
3330	{
3331	if(pocCurr<m_pocCRA)
3332	{
3333	// All leading pictures are being marked as TFD pictures here since current encoder uses all
3334	// reference pictures while encoding leading pictures. An encoder can ensure that a leading
3335	// picture can be still decodable when random accessing to a CRA/CRANT/BLA/BLANT picture by
3336	// controlling the reference pictures used for encoding that leading picture. Such a leading
3337	// picture need not be marked as a TFD picture.
3338	return NAL_UNIT_CODED_SLICE_RASL_R;
3339	}
3340	}
3341	if (lastIDR>0)
3342	{
3343	if (pocCurr < lastIDR)
3344	{
3345	return NAL_UNIT_CODED_SLICE_RADL_R;
3346	}
3347	}
3348	return NAL_UNIT_CODED_SLICE_TRAIL_R;
3349	}
3350
3351	Double TEncGOP::xCalculateRVM()
3352	{
3353	Double dRVM = 0;
3354
3355	if( m_pcCfg->getGOPSize() == 1 && m_pcCfg->getIntraPeriod() != 1 && m_pcCfg->getFramesToBeEncoded() > RVM_VCEGAM10_M * 2 )
3356	{
3357	// calculate RVM only for lowdelay configurations
3358	std::vector<Double> vRL , vB;
3359	size_t N = m_vRVM_RP.size();
3360	vRL.resize( N );
3361	vB.resize( N );
3362
3363	Int i;
3364	Double dRavg = 0 , dBavg = 0;
3365	vB[RVM_VCEGAM10_M] = 0;
3366	for( i = RVM_VCEGAM10_M + 1 ; i < N - RVM_VCEGAM10_M + 1 ; i++ )
3367	{
3368	vRL[i] = 0;
3369	for( Int j = i - RVM_VCEGAM10_M ; j <= i + RVM_VCEGAM10_M - 1 ; j++ )
3370	vRL[i] += m_vRVM_RP[j];
3371	vRL[i] /= ( 2 * RVM_VCEGAM10_M );
3372	vB[i] = vB[i-1] + m_vRVM_RP[i] - vRL[i];
3373	dRavg += m_vRVM_RP[i];
3374	dBavg += vB[i];
3375	}
3376
3377	dRavg /= ( N - 2 * RVM_VCEGAM10_M );
3378	dBavg /= ( N - 2 * RVM_VCEGAM10_M );
3379
3380	Double dSigamB = 0;
3381	for( i = RVM_VCEGAM10_M + 1 ; i < N - RVM_VCEGAM10_M + 1 ; i++ )
3382	{
3383	Double tmp = vB[i] - dBavg;
3384	dSigamB += tmp * tmp;
3385	}
3386	dSigamB = sqrt( dSigamB / ( N - 2 * RVM_VCEGAM10_M ) );
3387
3388	Double f = sqrt( 12.0 * ( RVM_VCEGAM10_M - 1 ) / ( RVM_VCEGAM10_M + 1 ) );
3389
3390	dRVM = dSigamB / dRavg * f;
3391	}
3392
3393	return( dRVM );
3394	}
3395
3396	/** Attaches the input bitstream to the stream in the output NAL unit
3397	Updates rNalu to contain concatenated bitstream. rpcBitstreamRedirect is cleared at the end of this function call.
3398	* \param codedSliceData contains the coded slice data (bitstream) to be concatenated to rNalu
3399	* \param rNalu target NAL unit
3400	*/
3401	Void TEncGOP::xAttachSliceDataToNalUnit (OutputNALUnit& rNalu, TComOutputBitstream*& codedSliceData)
3402	{
3403	// Byte-align
3404	rNalu.m_Bitstream.writeByteAlignment(); // Slice header byte-alignment
3405
3406	// Perform bitstream concatenation
3407	if (codedSliceData->getNumberOfWrittenBits() > 0)
3408	{
3409	rNalu.m_Bitstream.addSubstream(codedSliceData);
3410	}
3411
3412	m_pcEntropyCoder->setBitstream(&rNalu.m_Bitstream);
3413
3414	codedSliceData->clear();
3415	}
3416
3417	// Function will arrange the long-term pictures in the decreasing order of poc_lsb_lt,
3418	// and among the pictures with the same lsb, it arranges them in increasing delta_poc_msb_cycle_lt value
3419	Void TEncGOP::arrangeLongtermPicturesInRPS(TComSlice pcSlice, TComList<TComPic>& rcListPic)
3420	{
3421	TComReferencePictureSet *rps = pcSlice->getRPS();
3422	if(!rps->getNumberOfLongtermPictures())
3423	{
3424	return;
3425	}
3426
3427	// Arrange long-term reference pictures in the correct order of LSB and MSB,
3428	// and assign values for pocLSBLT and MSB present flag
3429	Int longtermPicsPoc[MAX_NUM_REF_PICS], longtermPicsLSB[MAX_NUM_REF_PICS], indices[MAX_NUM_REF_PICS];
3430	Int longtermPicsMSB[MAX_NUM_REF_PICS];
3431	Bool mSBPresentFlag[MAX_NUM_REF_PICS];
3432	::memset(longtermPicsPoc, 0, sizeof(longtermPicsPoc)); // Store POC values of LTRP
3433	::memset(longtermPicsLSB, 0, sizeof(longtermPicsLSB)); // Store POC LSB values of LTRP
3434	::memset(longtermPicsMSB, 0, sizeof(longtermPicsMSB)); // Store POC LSB values of LTRP
3435	::memset(indices , 0, sizeof(indices)); // Indices to aid in tracking sorted LTRPs
3436	::memset(mSBPresentFlag , 0, sizeof(mSBPresentFlag)); // Indicate if MSB needs to be present
3437
3438	// Get the long-term reference pictures
3439	Int offset = rps->getNumberOfNegativePictures() + rps->getNumberOfPositivePictures();
3440	Int i, ctr = 0;
3441	Int maxPicOrderCntLSB = 1 << pcSlice->getSPS()->getBitsForPOC();
3442	for(i = rps->getNumberOfPictures() - 1; i >= offset; i--, ctr++)
3443	{
3444	longtermPicsPoc[ctr] = rps->getPOC(i); // LTRP POC
3445	longtermPicsLSB[ctr] = getLSB(longtermPicsPoc[ctr], maxPicOrderCntLSB); // LTRP POC LSB
3446	indices[ctr] = i;
3447	longtermPicsMSB[ctr] = longtermPicsPoc[ctr] - longtermPicsLSB[ctr];
3448	}
3449	Int numLongPics = rps->getNumberOfLongtermPictures();
3450	assert(ctr == numLongPics);
3451
3452	// Arrange pictures in decreasing order of MSB;
3453	for(i = 0; i < numLongPics; i++)
3454	{
3455	for(Int j = 0; j < numLongPics - 1; j++)
3456	{
3457	if(longtermPicsMSB[j] < longtermPicsMSB[j+1])
3458	{
3459	std::swap(longtermPicsPoc[j], longtermPicsPoc[j+1]);
3460	std::swap(longtermPicsLSB[j], longtermPicsLSB[j+1]);
3461	std::swap(longtermPicsMSB[j], longtermPicsMSB[j+1]);
3462	std::swap(indices[j] , indices[j+1] );
3463	}
3464	}
3465	}
3466
3467	for(i = 0; i < numLongPics; i++)
3468	{
3469	// Check if MSB present flag should be enabled.
3470	// Check if the buffer contains any pictures that have the same LSB.
3471	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
3472	TComPic* pcPic;
3473	while ( iterPic != rcListPic.end() )
3474	{
3475	pcPic = *iterPic;
3476	if( (getLSB(pcPic->getPOC(), maxPicOrderCntLSB) == longtermPicsLSB[i]) && // Same LSB
3477	(pcPic->getSlice(0)->isReferenced()) && // Reference picture
3478	(pcPic->getPOC() != longtermPicsPoc[i]) ) // Not the LTRP itself
3479	{
3480	mSBPresentFlag[i] = true;
3481	break;
3482	}
3483	iterPic++;
3484	}
3485	}
3486
3487	// tempArray for usedByCurr flag
3488	Bool tempArray[MAX_NUM_REF_PICS]; ::memset(tempArray, 0, sizeof(tempArray));
3489	for(i = 0; i < numLongPics; i++)
3490	{
3491	tempArray[i] = rps->getUsed(indices[i]);
3492	}
3493	// Now write the final values;
3494	ctr = 0;
3495	Int currMSB = 0, currLSB = 0;
3496	// currPicPoc = currMSB + currLSB
3497	currLSB = getLSB(pcSlice->getPOC(), maxPicOrderCntLSB);
3498	currMSB = pcSlice->getPOC() - currLSB;
3499
3500	for(i = rps->getNumberOfPictures() - 1; i >= offset; i--, ctr++)
3501	{
3502	rps->setPOC (i, longtermPicsPoc[ctr]);
3503	rps->setDeltaPOC (i, - pcSlice->getPOC() + longtermPicsPoc[ctr]);
3504	rps->setUsed (i, tempArray[ctr]);
3505	rps->setPocLSBLT (i, longtermPicsLSB[ctr]);
3506	rps->setDeltaPocMSBCycleLT (i, (currMSB - (longtermPicsPoc[ctr] - longtermPicsLSB[ctr])) / maxPicOrderCntLSB);
3507	rps->setDeltaPocMSBPresentFlag(i, mSBPresentFlag[ctr]);
3508
3509	assert(rps->getDeltaPocMSBCycleLT(i) >= 0); // Non-negative value
3510	}
3511	for(i = rps->getNumberOfPictures() - 1, ctr = 1; i >= offset; i--, ctr++)
3512	{
3513	for(Int j = rps->getNumberOfPictures() - 1 - ctr; j >= offset; j--)
3514	{
3515	// Here at the encoder we know that we have set the full POC value for the LTRPs, hence we
3516	// don't have to check the MSB present flag values for this constraint.
3517	assert( rps->getPOC(i) != rps->getPOC(j) ); // If assert fails, LTRP entry repeated in RPS!!!
3518	}
3519	}
3520	}
3521
3522	/** Function for finding the position to insert the first of APS and non-nested BP, PT, DU info SEI messages.
3523	* \param accessUnit Access Unit of the current picture
3524	* This function finds the position to insert the first of APS and non-nested BP, PT, DU info SEI messages.
3525	*/
3526	Int TEncGOP::xGetFirstSeiLocation(AccessUnit &accessUnit)
3527	{
3528	// Find the location of the first SEI message
3529	AccessUnit::iterator it;
3530	Int seiStartPos = 0;
3531	for(it = accessUnit.begin(); it != accessUnit.end(); it++, seiStartPos++)
3532	{
3533	if ((it)->isSei() \|\| (it)->isVcl())
3534	{
3535	break;
3536	}
3537	}
3538	// assert(it != accessUnit.end()); // Triggers with some legit configurations
3539	return seiStartPos;
3540	}
3541
3542	Void TEncGOP::dblMetric( TComPic* pcPic, UInt uiNumSlices )
3543	{
3544	TComPicYuv* pcPicYuvRec = pcPic->getPicYuvRec();
3545	Pel* Rec = pcPicYuvRec->getLumaAddr( 0 );
3546	Pel* tempRec = Rec;
3547	Int stride = pcPicYuvRec->getStride();
3548	UInt log2maxTB = pcPic->getSlice(0)->getSPS()->getQuadtreeTULog2MaxSize();
3549	UInt maxTBsize = (1<<log2maxTB);
3550	const UInt minBlockArtSize = 8;
3551	const UInt picWidth = pcPicYuvRec->getWidth();
3552	const UInt picHeight = pcPicYuvRec->getHeight();
3553	const UInt noCol = (picWidth>>log2maxTB);
3554	const UInt noRows = (picHeight>>log2maxTB);
3555	assert(noCol > 1);
3556	assert(noRows > 1);
3557	UInt64 colSAD = (UInt64)malloc(noCol*sizeof(UInt64));
3558	UInt64 rowSAD = (UInt64)malloc(noRows*sizeof(UInt64));
3559	UInt colIdx = 0;
3560	UInt rowIdx = 0;
3561	Pel p0, p1, p2, q0, q1, q2;
3562
3563	Int qp = pcPic->getSlice(0)->getSliceQp();
3564	Int bitdepthScale = 1 << (g_bitDepthY-8);
3565	Int beta = TComLoopFilter::getBeta( qp ) * bitdepthScale;
3566	const Int thr2 = (beta>>2);
3567	const Int thr1 = 2*bitdepthScale;
3568	UInt a = 0;
3569
3570	memset(colSAD, 0, noCol*sizeof(UInt64));
3571	memset(rowSAD, 0, noRows*sizeof(UInt64));
3572
3573	if (maxTBsize > minBlockArtSize)
3574	{
3575	// Analyze vertical artifact edges
3576	for(Int c = maxTBsize; c < picWidth; c += maxTBsize)
3577	{
3578	for(Int r = 0; r < picHeight; r++)
3579	{
3580	p2 = Rec[c-3];
3581	p1 = Rec[c-2];
3582	p0 = Rec[c-1];
3583	q0 = Rec[c];
3584	q1 = Rec[c+1];
3585	q2 = Rec[c+2];
3586	a = ((abs(p2-(p1<<1)+p0)+abs(q0-(q1<<1)+q2))<<1);
3587	if ( thr1 < a && a < thr2)
3588	{
3589	colSAD[colIdx] += abs(p0 - q0);
3590	}
3591	Rec += stride;
3592	}
3593	colIdx++;
3594	Rec = tempRec;
3595	}
3596
3597	// Analyze horizontal artifact edges
3598	for(Int r = maxTBsize; r < picHeight; r += maxTBsize)
3599	{
3600	for(Int c = 0; c < picWidth; c++)
3601	{
3602	p2 = Rec[c + (r-3)*stride];
3603	p1 = Rec[c + (r-2)*stride];
3604	p0 = Rec[c + (r-1)*stride];
3605	q0 = Rec[c + r*stride];
3606	q1 = Rec[c + (r+1)*stride];
3607	q2 = Rec[c + (r+2)*stride];
3608	a = ((abs(p2-(p1<<1)+p0)+abs(q0-(q1<<1)+q2))<<1);
3609	if (thr1 < a && a < thr2)
3610	{
3611	rowSAD[rowIdx] += abs(p0 - q0);
3612	}
3613	}
3614	rowIdx++;
3615	}
3616	}
3617
3618	UInt64 colSADsum = 0;
3619	UInt64 rowSADsum = 0;
3620	for(Int c = 0; c < noCol-1; c++)
3621	{
3622	colSADsum += colSAD[c];
3623	}
3624	for(Int r = 0; r < noRows-1; r++)
3625	{
3626	rowSADsum += rowSAD[r];
3627	}
3628
3629	colSADsum <<= 10;
3630	rowSADsum <<= 10;
3631	colSADsum /= (noCol-1);
3632	colSADsum /= picHeight;
3633	rowSADsum /= (noRows-1);
3634	rowSADsum /= picWidth;
3635
3636	UInt64 avgSAD = ((colSADsum + rowSADsum)>>1);
3637	avgSAD >>= (g_bitDepthY-8);
3638
3639	if ( avgSAD > 2048 )
3640	{
3641	avgSAD >>= 9;
3642	Int offset = Clip3(2,6,(Int)avgSAD);
3643	for (Int i=0; i<uiNumSlices; i++)
3644	{
3645	pcPic->getSlice(i)->setDeblockingFilterOverrideFlag(true);
3646	pcPic->getSlice(i)->setDeblockingFilterDisable(false);
3647	pcPic->getSlice(i)->setDeblockingFilterBetaOffsetDiv2( offset );
3648	pcPic->getSlice(i)->setDeblockingFilterTcOffsetDiv2( offset );
3649	}
3650	}
3651	else
3652	{
3653	for (Int i=0; i<uiNumSlices; i++)
3654	{
3655	pcPic->getSlice(i)->setDeblockingFilterOverrideFlag(false);
3656	pcPic->getSlice(i)->setDeblockingFilterDisable( pcPic->getSlice(i)->getPPS()->getPicDisableDeblockingFilterFlag() );
3657	pcPic->getSlice(i)->setDeblockingFilterBetaOffsetDiv2( pcPic->getSlice(i)->getPPS()->getDeblockingFilterBetaOffsetDiv2() );
3658	pcPic->getSlice(i)->setDeblockingFilterTcOffsetDiv2( pcPic->getSlice(i)->getPPS()->getDeblockingFilterTcOffsetDiv2() );
3659	}
3660	}
3661
3662	free(colSAD);
3663	free(rowSAD);
3664	}
3665	#if SVC_EXTENSION
3666	#if LAYERS_NOT_PRESENT_SEI
3667	SEILayersNotPresent* TEncGOP::xCreateSEILayersNotPresent ()
3668	{
3669	UInt i = 0;
3670	SEILayersNotPresent *seiLayersNotPresent = new SEILayersNotPresent();
3671	seiLayersNotPresent->m_activeVpsId = m_pcCfg->getVPS()->getVPSId();
3672	seiLayersNotPresent->m_vpsMaxLayers = m_pcCfg->getVPS()->getMaxLayers();
3673	for ( ; i < seiLayersNotPresent->m_vpsMaxLayers; i++)
3674	{
3675	seiLayersNotPresent->m_layerNotPresentFlag[i] = true;
3676	}
3677	for ( ; i < MAX_LAYERS; i++)
3678	{
3679	seiLayersNotPresent->m_layerNotPresentFlag[i] = false;
3680	}
3681	return seiLayersNotPresent;
3682	}
3683	#endif
3684
3685	#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
3686	SEIInterLayerConstrainedTileSets* TEncGOP::xCreateSEIInterLayerConstrainedTileSets()
3687	{
3688	SEIInterLayerConstrainedTileSets *seiInterLayerConstrainedTileSets = new SEIInterLayerConstrainedTileSets();
3689	seiInterLayerConstrainedTileSets->m_ilAllTilesExactSampleValueMatchFlag = false;
3690	seiInterLayerConstrainedTileSets->m_ilOneTilePerTileSetFlag = false;
3691	if (!seiInterLayerConstrainedTileSets->m_ilOneTilePerTileSetFlag)
3692	{
3693	seiInterLayerConstrainedTileSets->m_ilNumSetsInMessageMinus1 = m_pcCfg->getIlNumSetsInMessage() - 1;
3694	if (seiInterLayerConstrainedTileSets->m_ilNumSetsInMessageMinus1)
3695	{
3696	seiInterLayerConstrainedTileSets->m_skippedTileSetPresentFlag = m_pcCfg->getSkippedTileSetPresentFlag();
3697	}
3698	else
3699	{
3700	seiInterLayerConstrainedTileSets->m_skippedTileSetPresentFlag = false;
3701	}
3702	seiInterLayerConstrainedTileSets->m_ilNumSetsInMessageMinus1 += seiInterLayerConstrainedTileSets->m_skippedTileSetPresentFlag ? 1 : 0;
3703	for (UInt i = 0; i < m_pcCfg->getIlNumSetsInMessage(); i++)
3704	{
3705	seiInterLayerConstrainedTileSets->m_ilctsId[i] = i;
3706	seiInterLayerConstrainedTileSets->m_ilNumTileRectsInSetMinus1[i] = 0;
3707	for( UInt j = 0; j <= seiInterLayerConstrainedTileSets->m_ilNumTileRectsInSetMinus1[i]; j++)
3708	{
3709	seiInterLayerConstrainedTileSets->m_ilTopLeftTileIndex[i][j] = m_pcCfg->getTopLeftTileIndex(i);
3710	seiInterLayerConstrainedTileSets->m_ilBottomRightTileIndex[i][j] = m_pcCfg->getBottomRightTileIndex(i);
3711	}
3712	seiInterLayerConstrainedTileSets->m_ilcIdc[i] = m_pcCfg->getIlcIdc(i);
3713	if (seiInterLayerConstrainedTileSets->m_ilAllTilesExactSampleValueMatchFlag)
3714	{
3715	seiInterLayerConstrainedTileSets->m_ilExactSampleValueMatchFlag[i] = false;
3716	}
3717	}
3718	}
3719
3720	return seiInterLayerConstrainedTileSets;
3721	}
3722
3723	Void TEncGOP::xBuildTileSetsMap(TComPicSym* picSym)
3724	{
3725	Int numCUs = picSym->getFrameWidthInCU() * picSym->getFrameHeightInCU();
3726
3727	for (Int i = 0; i < numCUs; i++)
3728	{
3729	picSym->setTileSetIdxMap(i, -1, 0, false);
3730	}
3731
3732	for (Int i = 0; i < m_pcCfg->getIlNumSetsInMessage(); i++)
3733	{
3734	TComTile* topLeftTile = picSym->getTComTile(m_pcCfg->getTopLeftTileIndex(i));
3735	TComTile* bottomRightTile = picSym->getTComTile(m_pcCfg->getBottomRightTileIndex(i));
3736	Int tileSetLeftEdgePosInCU = topLeftTile->getRightEdgePosInCU() - topLeftTile->getTileWidth() + 1;
3737	Int tileSetRightEdgePosInCU = bottomRightTile->getRightEdgePosInCU();
3738	Int tileSetTopEdgePosInCU = topLeftTile->getBottomEdgePosInCU() - topLeftTile->getTileHeight() + 1;
3739	Int tileSetBottomEdgePosInCU = bottomRightTile->getBottomEdgePosInCU();
3740	assert(tileSetLeftEdgePosInCU < tileSetRightEdgePosInCU && tileSetTopEdgePosInCU < tileSetBottomEdgePosInCU);
3741	for (Int j = tileSetTopEdgePosInCU; j <= tileSetBottomEdgePosInCU; j++)
3742	{
3743	for (Int k = tileSetLeftEdgePosInCU; k <= tileSetRightEdgePosInCU; k++)
3744	{
3745	picSym->setTileSetIdxMap(j * picSym->getFrameWidthInCU() + k, i, m_pcCfg->getIlcIdc(i), false);
3746	}
3747	}
3748	}
3749
3750	if (m_pcCfg->getSkippedTileSetPresentFlag())
3751	{
3752	Int skippedTileSetIdx = m_pcCfg->getIlNumSetsInMessage();
3753	for (Int i = 0; i < numCUs; i++)
3754	{
3755	if (picSym->getTileSetIdxMap(i) < 0)
3756	{
3757	picSym->setTileSetIdxMap(i, skippedTileSetIdx, 0, true);
3758	}
3759	}
3760	}
3761	}
3762	#endif
3763
3764	#if O0164_MULTI_LAYER_HRD
3765	SEIScalableNesting* TEncGOP::xCreateBspNestingSEI(TComSlice *pcSlice)
3766	{
3767	SEIScalableNesting *seiScalableNesting = new SEIScalableNesting();
3768	SEIBspInitialArrivalTime *seiBspInitialArrivalTime = new SEIBspInitialArrivalTime();
3769	SEIBspNesting *seiBspNesting = new SEIBspNesting();
3770	SEIBufferingPeriod *seiBufferingPeriod = new SEIBufferingPeriod();
3771
3772	// Scalable nesting SEI
3773
3774	seiScalableNesting->m_bitStreamSubsetFlag = 1; // If the nested SEI messages are picture buffereing SEI mesages, picure timing SEI messages or sub-picture timing SEI messages, bitstream_subset_flag shall be equal to 1
3775	seiScalableNesting->m_nestingOpFlag = 1;
3776	seiScalableNesting->m_defaultOpFlag = 0;
3777	seiScalableNesting->m_nestingNumOpsMinus1 = 0; //nesting_num_ops_minus1
3778	seiScalableNesting->m_nestingOpIdx[0] = 1;
3779	seiScalableNesting->m_allLayersFlag = 0;
3780	seiScalableNesting->m_nestingNoOpMaxTemporalIdPlus1 = 6 + 1; //nesting_no_op_max_temporal_id_plus1
3781	seiScalableNesting->m_nestingNumLayersMinus1 = 1 - 1; //nesting_num_layers_minus1
3782	seiScalableNesting->m_nestingLayerId[0] = 0;
3783	seiScalableNesting->m_callerOwnsSEIs = true;
3784
3785	// Bitstream partition nesting SEI
3786
3787	seiBspNesting->m_bspIdx = 0;
3788	seiBspNesting->m_callerOwnsSEIs = true;
3789
3790	// Buffering period SEI
3791
3792	UInt uiInitialCpbRemovalDelay = (90000/2); // 0.5 sec
3793	seiBufferingPeriod->m_initialCpbRemovalDelay [0][0] = uiInitialCpbRemovalDelay;
3794	seiBufferingPeriod->m_initialCpbRemovalDelayOffset[0][0] = uiInitialCpbRemovalDelay;
3795	seiBufferingPeriod->m_initialCpbRemovalDelay [0][1] = uiInitialCpbRemovalDelay;
3796	seiBufferingPeriod->m_initialCpbRemovalDelayOffset[0][1] = uiInitialCpbRemovalDelay;
3797
3798	Double dTmp = (Double)pcSlice->getSPS()->getVuiParameters()->getTimingInfo()->getNumUnitsInTick() / (Double)pcSlice->getSPS()->getVuiParameters()->getTimingInfo()->getTimeScale();
3799
3800	UInt uiTmp = (UInt)( dTmp * 90000.0 );
3801	uiInitialCpbRemovalDelay -= uiTmp;
3802	uiInitialCpbRemovalDelay -= uiTmp / ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getTickDivisorMinus2() + 2 );
3803	seiBufferingPeriod->m_initialAltCpbRemovalDelay [0][0] = uiInitialCpbRemovalDelay;
3804	seiBufferingPeriod->m_initialAltCpbRemovalDelayOffset[0][0] = uiInitialCpbRemovalDelay;
3805	seiBufferingPeriod->m_initialAltCpbRemovalDelay [0][1] = uiInitialCpbRemovalDelay;
3806	seiBufferingPeriod->m_initialAltCpbRemovalDelayOffset[0][1] = uiInitialCpbRemovalDelay;
3807
3808	seiBufferingPeriod->m_rapCpbParamsPresentFlag = 0;
3809	//for the concatenation, it can be set to one during splicing.
3810	seiBufferingPeriod->m_concatenationFlag = 0;
3811	//since the temporal layer HRD is not ready, we assumed it is fixed
3812	seiBufferingPeriod->m_auCpbRemovalDelayDelta = 1;
3813	seiBufferingPeriod->m_cpbDelayOffset = 0;
3814	seiBufferingPeriod->m_dpbDelayOffset = 0;
3815
3816	// Intial arrival time SEI message
3817
3818	seiBspInitialArrivalTime->m_nalInitialArrivalDelay[0] = 0;
3819	seiBspInitialArrivalTime->m_vclInitialArrivalDelay[0] = 0;
3820
3821
3822	seiBspNesting->m_nestedSEIs.push_back(seiBufferingPeriod);
3823	seiBspNesting->m_nestedSEIs.push_back(seiBspInitialArrivalTime);
3824	seiScalableNesting->m_nestedSEIs.push_back(seiBspNesting); // BSP nesting SEI is contained in scalable nesting SEI
3825
3826	return seiScalableNesting;
3827	}
3828	#endif
3829
3830	#endif //SVC_EXTENSION
3831
3832	//! \}

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

Download in other formats: