Context navigation

source: SHVCSoftware/branches/SHM-2.1-dev/source/Lib/TLibEncoder/TEncGOP.cpp @ 250

Visit:

Last change on this file since 250 was 250, checked in by seregin, 11 years ago
use refLayerIdc for getting reference layer encoder and decoder
File size: 117.5 KB

Line
1	/* The copyright in this software is being made available under the BSD
2	* License, included below. This software may be subject to other third party
3	* and contributor rights, including patent rights, and no such rights are
4	* granted under this license.
5	*
6	* Copyright (c) 2010-2013, 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	#if L0045_NON_NESTED_SEI_RESTRICTIONS
97	xResetNonNestedSEIPresentFlags();
98	#if K0180_SCALABLE_NESTING_SEI
99	xResetNestedSEIPresentFlags();
100	#endif
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	#if L0047_APS_FLAGS
166	seiActiveParameterSets->m_fullRandomAccessFlag = false;
167	seiActiveParameterSets->m_noParamSetUpdateFlag = false;
168	#endif
169	seiActiveParameterSets->numSpsIdsMinus1 = 0;
170	seiActiveParameterSets->activeSeqParamSetId.resize(seiActiveParameterSets->numSpsIdsMinus1 + 1);
171	seiActiveParameterSets->activeSeqParamSetId[0] = sps->getSPSId();
172	return seiActiveParameterSets;
173	}
174
175	SEIFramePacking* TEncGOP::xCreateSEIFramePacking()
176	{
177	SEIFramePacking *seiFramePacking = new SEIFramePacking();
178	seiFramePacking->m_arrangementId = m_pcCfg->getFramePackingArrangementSEIId();
179	seiFramePacking->m_arrangementCancelFlag = 0;
180	seiFramePacking->m_arrangementType = m_pcCfg->getFramePackingArrangementSEIType();
181	#if L0444_FPA_TYPE
182	assert((seiFramePacking->m_arrangementType > 2) && (seiFramePacking->m_arrangementType < 6) );
183	#endif
184	seiFramePacking->m_quincunxSamplingFlag = m_pcCfg->getFramePackingArrangementSEIQuincunx();
185	seiFramePacking->m_contentInterpretationType = m_pcCfg->getFramePackingArrangementSEIInterpretation();
186	seiFramePacking->m_spatialFlippingFlag = 0;
187	seiFramePacking->m_frame0FlippedFlag = 0;
188	seiFramePacking->m_fieldViewsFlag = (seiFramePacking->m_arrangementType == 2);
189	seiFramePacking->m_currentFrameIsFrame0Flag = ((seiFramePacking->m_arrangementType == 5) && m_iNumPicCoded&1);
190	seiFramePacking->m_frame0SelfContainedFlag = 0;
191	seiFramePacking->m_frame1SelfContainedFlag = 0;
192	seiFramePacking->m_frame0GridPositionX = 0;
193	seiFramePacking->m_frame0GridPositionY = 0;
194	seiFramePacking->m_frame1GridPositionX = 0;
195	seiFramePacking->m_frame1GridPositionY = 0;
196	seiFramePacking->m_arrangementReservedByte = 0;
197	#if L0045_PERSISTENCE_FLAGS
198	seiFramePacking->m_arrangementPersistenceFlag = true;
199	#else
200	seiFramePacking->m_arrangementRepetetionPeriod = 1;
201	#endif
202	seiFramePacking->m_upsampledAspectRatio = 0;
203	return seiFramePacking;
204	}
205
206	SEIDisplayOrientation* TEncGOP::xCreateSEIDisplayOrientation()
207	{
208	SEIDisplayOrientation *seiDisplayOrientation = new SEIDisplayOrientation();
209	seiDisplayOrientation->cancelFlag = false;
210	seiDisplayOrientation->horFlip = false;
211	seiDisplayOrientation->verFlip = false;
212	seiDisplayOrientation->anticlockwiseRotation = m_pcCfg->getDisplayOrientationSEIAngle();
213	return seiDisplayOrientation;
214	}
215
216	#if J0149_TONE_MAPPING_SEI
217	SEIToneMappingInfo* TEncGOP::xCreateSEIToneMappingInfo()
218	{
219	SEIToneMappingInfo *seiToneMappingInfo = new SEIToneMappingInfo();
220	seiToneMappingInfo->m_toneMapId = m_pcCfg->getTMISEIToneMapId();
221	seiToneMappingInfo->m_toneMapCancelFlag = m_pcCfg->getTMISEIToneMapCancelFlag();
222	seiToneMappingInfo->m_toneMapPersistenceFlag = m_pcCfg->getTMISEIToneMapPersistenceFlag();
223
224	seiToneMappingInfo->m_codedDataBitDepth = m_pcCfg->getTMISEICodedDataBitDepth();
225	assert(seiToneMappingInfo->m_codedDataBitDepth >= 8 && seiToneMappingInfo->m_codedDataBitDepth <= 14);
226	seiToneMappingInfo->m_targetBitDepth = m_pcCfg->getTMISEITargetBitDepth();
227	assert( (seiToneMappingInfo->m_targetBitDepth >= 1 && seiToneMappingInfo->m_targetBitDepth <= 17) \|\| (seiToneMappingInfo->m_targetBitDepth == 255) );
228	seiToneMappingInfo->m_modelId = m_pcCfg->getTMISEIModelID();
229	assert(seiToneMappingInfo->m_modelId >=0 &&seiToneMappingInfo->m_modelId<=4);
230
231	switch( seiToneMappingInfo->m_modelId)
232	{
233	case 0:
234	{
235	seiToneMappingInfo->m_minValue = m_pcCfg->getTMISEIMinValue();
236	seiToneMappingInfo->m_maxValue = m_pcCfg->getTMISEIMaxValue();
237	break;
238	}
239	case 1:
240	{
241	seiToneMappingInfo->m_sigmoidMidpoint = m_pcCfg->getTMISEISigmoidMidpoint();
242	seiToneMappingInfo->m_sigmoidWidth = m_pcCfg->getTMISEISigmoidWidth();
243	break;
244	}
245	case 2:
246	{
247	UInt num = 1u<<(seiToneMappingInfo->m_targetBitDepth);
248	seiToneMappingInfo->m_startOfCodedInterval.resize(num);
249	Int* ptmp = m_pcCfg->getTMISEIStartOfCodedInterva();
250	if(ptmp)
251	{
252	for(int i=0; i<num;i++)
253	{
254	seiToneMappingInfo->m_startOfCodedInterval[i] = ptmp[i];
255	}
256	}
257	break;
258	}
259	case 3:
260	{
261	seiToneMappingInfo->m_numPivots = m_pcCfg->getTMISEINumPivots();
262	seiToneMappingInfo->m_codedPivotValue.resize(seiToneMappingInfo->m_numPivots);
263	seiToneMappingInfo->m_targetPivotValue.resize(seiToneMappingInfo->m_numPivots);
264	Int* ptmpcoded = m_pcCfg->getTMISEICodedPivotValue();
265	Int* ptmptarget = m_pcCfg->getTMISEITargetPivotValue();
266	if(ptmpcoded&&ptmptarget)
267	{
268	for(int i=0; i<(seiToneMappingInfo->m_numPivots);i++)
269	{
270	seiToneMappingInfo->m_codedPivotValue[i]=ptmpcoded[i];
271	seiToneMappingInfo->m_targetPivotValue[i]=ptmptarget[i];
272	}
273	}
274	break;
275	}
276	case 4:
277	{
278	seiToneMappingInfo->m_cameraIsoSpeedIdc = m_pcCfg->getTMISEICameraIsoSpeedIdc();
279	seiToneMappingInfo->m_cameraIsoSpeedValue = m_pcCfg->getTMISEICameraIsoSpeedValue();
280	assert( seiToneMappingInfo->m_cameraIsoSpeedValue !=0 );
281	seiToneMappingInfo->m_exposureCompensationValueSignFlag = m_pcCfg->getTMISEIExposureCompensationValueSignFlag();
282	seiToneMappingInfo->m_exposureCompensationValueNumerator = m_pcCfg->getTMISEIExposureCompensationValueNumerator();
283	seiToneMappingInfo->m_exposureCompensationValueDenomIdc = m_pcCfg->getTMISEIExposureCompensationValueDenomIdc();
284	seiToneMappingInfo->m_refScreenLuminanceWhite = m_pcCfg->getTMISEIRefScreenLuminanceWhite();
285	seiToneMappingInfo->m_extendedRangeWhiteLevel = m_pcCfg->getTMISEIExtendedRangeWhiteLevel();
286	assert( seiToneMappingInfo->m_extendedRangeWhiteLevel >= 100 );
287	seiToneMappingInfo->m_nominalBlackLevelLumaCodeValue = m_pcCfg->getTMISEINominalBlackLevelLumaCodeValue();
288	seiToneMappingInfo->m_nominalWhiteLevelLumaCodeValue = m_pcCfg->getTMISEINominalWhiteLevelLumaCodeValue();
289	assert( seiToneMappingInfo->m_nominalWhiteLevelLumaCodeValue > seiToneMappingInfo->m_nominalBlackLevelLumaCodeValue );
290	seiToneMappingInfo->m_extendedWhiteLevelLumaCodeValue = m_pcCfg->getTMISEIExtendedWhiteLevelLumaCodeValue();
291	assert( seiToneMappingInfo->m_extendedWhiteLevelLumaCodeValue >= seiToneMappingInfo->m_nominalWhiteLevelLumaCodeValue );
292	break;
293	}
294	default:
295	{
296	assert(!"Undefined SEIToneMapModelId");
297	break;
298	}
299	}
300	return seiToneMappingInfo;
301	}
302	#endif
303	Void TEncGOP::xCreateLeadingSEIMessages (/SEIMessages seiMessages,/ AccessUnit &accessUnit, TComSPS *sps)
304	{
305	OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
306
307	if(m_pcCfg->getActiveParameterSetsSEIEnabled())
308	{
309	SEIActiveParameterSets *sei = xCreateSEIActiveParameterSets (sps);
310
311	//nalu = NALUnit(NAL_UNIT_SEI);
312	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
313	m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
314	writeRBSPTrailingBits(nalu.m_Bitstream);
315	accessUnit.push_back(new NALUnitEBSP(nalu));
316	delete sei;
317	#if L0045_NON_NESTED_SEI_RESTRICTIONS
318	m_activeParameterSetSEIPresentInAU = true;
319	#endif
320	}
321
322	if(m_pcCfg->getFramePackingArrangementSEIEnabled())
323	{
324	SEIFramePacking *sei = xCreateSEIFramePacking ();
325
326	nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
327	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
328	m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
329	writeRBSPTrailingBits(nalu.m_Bitstream);
330	accessUnit.push_back(new NALUnitEBSP(nalu));
331	delete sei;
332	}
333	if (m_pcCfg->getDisplayOrientationSEIAngle())
334	{
335	SEIDisplayOrientation *sei = xCreateSEIDisplayOrientation();
336
337	nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
338	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
339	m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
340	writeRBSPTrailingBits(nalu.m_Bitstream);
341	accessUnit.push_back(new NALUnitEBSP(nalu));
342	delete sei;
343	}
344	#if J0149_TONE_MAPPING_SEI
345	if(m_pcCfg->getToneMappingInfoSEIEnabled())
346	{
347	SEIToneMappingInfo *sei = xCreateSEIToneMappingInfo ();
348
349	nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
350	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
351	m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
352	writeRBSPTrailingBits(nalu.m_Bitstream);
353	accessUnit.push_back(new NALUnitEBSP(nalu));
354	delete sei;
355	}
356	#endif
357	}
358
359	// ====================================================================================================================
360	// Public member functions
361	// ====================================================================================================================
362	#if SVC_EXTENSION
363	Void TEncGOP::compressGOP( Int iPicIdInGOP, Int iPOCLast, Int iNumPicRcvd, TComList<TComPic>& rcListPic, TComList<TComPicYuv>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsInGOP)
364	#else
365	Void TEncGOP::compressGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic>& rcListPic, TComList<TComPicYuv>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsInGOP)
366	#endif
367	{
368	TComPic* pcPic;
369	TComPicYuv* pcPicYuvRecOut;
370	TComSlice* pcSlice;
371	TComOutputBitstream *pcBitstreamRedirect;
372	pcBitstreamRedirect = new TComOutputBitstream;
373	AccessUnit::iterator itLocationToPushSliceHeaderNALU; // used to store location where NALU containing slice header is to be inserted
374	UInt uiOneBitstreamPerSliceLength = 0;
375	TEncSbac* pcSbacCoders = NULL;
376	TComOutputBitstream* pcSubstreamsOut = NULL;
377
378	xInitGOP( iPOCLast, iNumPicRcvd, rcListPic, rcListPicYuvRecOut );
379
380	m_iNumPicCoded = 0;
381	SEIPictureTiming pictureTimingSEI;
382	#if L0208_SOP_DESCRIPTION_SEI
383	Bool writeSOP = m_pcCfg->getSOPDescriptionSEIEnabled();
384	#endif
385	#if K0180_SCALABLE_NESTING_SEI
386	// Initialize Scalable Nesting SEI with single layer values
387	SEIScalableNesting scalableNestingSEI;
388	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
389	scalableNestingSEI.m_nestingOpFlag = 0;
390	scalableNestingSEI.m_nestingNumOpsMinus1 = 0; //nesting_num_ops_minus1
391	scalableNestingSEI.m_allLayersFlag = 0;
392	scalableNestingSEI.m_nestingNoOpMaxTemporalIdPlus1 = 6 + 1; //nesting_no_op_max_temporal_id_plus1
393	scalableNestingSEI.m_nestingNumLayersMinus1 = 1 - 1; //nesting_num_layers_minus1
394	scalableNestingSEI.m_nestingLayerId[0] = 0;
395	scalableNestingSEI.m_callerOwnsSEIs = true;
396	#endif
397	#if L0044_DU_DPB_OUTPUT_DELAY_HRD
398	Int picSptDpbOutputDuDelay = 0;
399	#endif
400	UInt *accumBitsDU = NULL;
401	UInt *accumNalsDU = NULL;
402	SEIDecodingUnitInfo decodingUnitInfoSEI;
403	#if SVC_EXTENSION
404	for ( Int iGOPid=iPicIdInGOP; iGOPid < iPicIdInGOP+1; iGOPid++ )
405	#else
406	for ( Int iGOPid=0; iGOPid < m_iGopSize; iGOPid++ )
407	#endif
408	{
409	UInt uiColDir = 1;
410	//-- For time output for each slice
411	long iBeforeTime = clock();
412
413	//select uiColDir
414	Int iCloseLeft=1, iCloseRight=-1;
415	for(Int i = 0; i<m_pcCfg->getGOPEntry(iGOPid).m_numRefPics; i++)
416	{
417	Int iRef = m_pcCfg->getGOPEntry(iGOPid).m_referencePics[i];
418	if(iRef>0&&(iRef<iCloseRight\|\|iCloseRight==-1))
419	{
420	iCloseRight=iRef;
421	}
422	else if(iRef<0&&(iRef>iCloseLeft\|\|iCloseLeft==1))
423	{
424	iCloseLeft=iRef;
425	}
426	}
427	if(iCloseRight>-1)
428	{
429	iCloseRight=iCloseRight+m_pcCfg->getGOPEntry(iGOPid).m_POC-1;
430	}
431	if(iCloseLeft<1)
432	{
433	iCloseLeft=iCloseLeft+m_pcCfg->getGOPEntry(iGOPid).m_POC-1;
434	while(iCloseLeft<0)
435	{
436	iCloseLeft+=m_iGopSize;
437	}
438	}
439	Int iLeftQP=0, iRightQP=0;
440	for(Int i=0; i<m_iGopSize; i++)
441	{
442	if(m_pcCfg->getGOPEntry(i).m_POC==(iCloseLeft%m_iGopSize)+1)
443	{
444	iLeftQP= m_pcCfg->getGOPEntry(i).m_QPOffset;
445	}
446	if (m_pcCfg->getGOPEntry(i).m_POC==(iCloseRight%m_iGopSize)+1)
447	{
448	iRightQP=m_pcCfg->getGOPEntry(i).m_QPOffset;
449	}
450	}
451	if(iCloseRight>-1&&iRightQP<iLeftQP)
452	{
453	uiColDir=0;
454	}
455
456	/////////////////////////////////////////////////////////////////////////////////////////////////// Initial to start encoding
457	Int pocCurr = iPOCLast -iNumPicRcvd+ m_pcCfg->getGOPEntry(iGOPid).m_POC;
458	Int iTimeOffset = m_pcCfg->getGOPEntry(iGOPid).m_POC;
459	if(iPOCLast == 0)
460	{
461	pocCurr=0;
462	iTimeOffset = 1;
463	}
464	if(pocCurr>=m_pcCfg->getFramesToBeEncoded())
465	{
466	continue;
467	}
468
469	if( getNalUnitType(pocCurr, m_iLastIDR) == NAL_UNIT_CODED_SLICE_IDR_W_RADL \|\| getNalUnitType(pocCurr, m_iLastIDR) == NAL_UNIT_CODED_SLICE_IDR_N_LP )
470	{
471	m_iLastIDR = pocCurr;
472	}
473	// start a new access unit: create an entry in the list of output access units
474	accessUnitsInGOP.push_back(AccessUnit());
475	AccessUnit& accessUnit = accessUnitsInGOP.back();
476	xGetBuffer( rcListPic, rcListPicYuvRecOut, iNumPicRcvd, iTimeOffset, pcPic, pcPicYuvRecOut, pocCurr );
477
478	// Slice data initialization
479	pcPic->clearSliceBuffer();
480	assert(pcPic->getNumAllocatedSlice() == 1);
481	m_pcSliceEncoder->setSliceIdx(0);
482	pcPic->setCurrSliceIdx(0);
483	#if SVC_EXTENSION
484	pcPic->setLayerId( m_layerId );
485	m_pcSliceEncoder->initEncSlice ( pcPic, iPOCLast, pocCurr, iNumPicRcvd, iGOPid, pcSlice, m_pcEncTop->getSPS(), m_pcEncTop->getPPS(), m_pcEncTop->getVPS() );
486	#else
487	m_pcSliceEncoder->initEncSlice ( pcPic, iPOCLast, pocCurr, iNumPicRcvd, iGOPid, pcSlice, m_pcEncTop->getSPS(), m_pcEncTop->getPPS() );
488	#endif
489	pcSlice->setLastIDR(m_iLastIDR);
490	pcSlice->setSliceIdx(0);
491	//set default slice level flag to the same as SPS level flag
492	pcSlice->setLFCrossSliceBoundaryFlag( pcSlice->getPPS()->getLoopFilterAcrossSlicesEnabledFlag() );
493	pcSlice->setScalingList ( m_pcEncTop->getScalingList() );
494	pcSlice->getScalingList()->setUseTransformSkip(m_pcEncTop->getPPS()->getUseTransformSkip());
495	if(m_pcEncTop->getUseScalingListId() == SCALING_LIST_OFF)
496	{
497	m_pcEncTop->getTrQuant()->setFlatScalingList();
498	m_pcEncTop->getTrQuant()->setUseScalingList(false);
499	m_pcEncTop->getSPS()->setScalingListPresentFlag(false);
500	m_pcEncTop->getPPS()->setScalingListPresentFlag(false);
501	}
502	else if(m_pcEncTop->getUseScalingListId() == SCALING_LIST_DEFAULT)
503	{
504	pcSlice->setDefaultScalingList ();
505	m_pcEncTop->getSPS()->setScalingListPresentFlag(false);
506	m_pcEncTop->getPPS()->setScalingListPresentFlag(false);
507	m_pcEncTop->getTrQuant()->setScalingList(pcSlice->getScalingList());
508	m_pcEncTop->getTrQuant()->setUseScalingList(true);
509	}
510	else if(m_pcEncTop->getUseScalingListId() == SCALING_LIST_FILE_READ)
511	{
512	if(pcSlice->getScalingList()->xParseScalingList(m_pcCfg->getScalingListFile()))
513	{
514	pcSlice->setDefaultScalingList ();
515	}
516	pcSlice->getScalingList()->checkDcOfMatrix();
517	m_pcEncTop->getSPS()->setScalingListPresentFlag(pcSlice->checkDefaultScalingList());
518	m_pcEncTop->getPPS()->setScalingListPresentFlag(false);
519	m_pcEncTop->getTrQuant()->setScalingList(pcSlice->getScalingList());
520	m_pcEncTop->getTrQuant()->setUseScalingList(true);
521	}
522	else
523	{
524	printf("error : ScalingList == %d no support\n",m_pcEncTop->getUseScalingListId());
525	assert(0);
526	}
527
528	if(pcSlice->getSliceType()==B_SLICE&&m_pcCfg->getGOPEntry(iGOPid).m_sliceType=='P')
529	{
530	pcSlice->setSliceType(P_SLICE);
531	}
532	// Set the nal unit type
533	pcSlice->setNalUnitType(getNalUnitType(pocCurr, m_iLastIDR));
534	#if IDR_ALIGNMENT
535	if (m_layerId > 0)
536	{
537	#if VPS_EXTN_DIRECT_REF_LAYERS
538	TComList<TComPic> cListPic = m_ppcTEncTop[m_layerId]->getRefLayerEnc(m_layerId-1)->getListPic();
539	#else
540	TComList<TComPic> cListPic = m_ppcTEncTop[m_layerId-1]->getListPic();
541	#endif
542	pcSlice->setBaseColPic (*cListPic, m_layerId );
543
544	#if SIMPLIFIED_MV_POS_SCALING
545	#if SCALED_REF_LAYER_OFFSETS
546	const Window &scalEL = m_pcEncTop->getScaledRefLayerWindow();
547
548	Int widthBL = pcSlice->getBaseColPic()->getPicYuvRec()->getWidth();
549	Int heightBL = pcSlice->getBaseColPic()->getPicYuvRec()->getHeight();
550
551	Int widthEL = pcPic->getPicYuvRec()->getWidth() - scalEL.getWindowLeftOffset() - scalEL.getWindowRightOffset();
552	Int heightEL = pcPic->getPicYuvRec()->getHeight() - scalEL.getWindowTopOffset() - scalEL.getWindowBottomOffset();
553	#else
554	const Window &confBL = pcSlice->getBaseColPic()->getPicYuvRec()->getConformanceWindow();
555	const Window &confEL = pcPic->getPicYuvRec()->getConformanceWindow();
556
557	Int widthBL = pcSlice->getBaseColPic()->getPicYuvRec()->getWidth () - confBL.getWindowLeftOffset() - confBL.getWindowRightOffset();
558	Int heightBL = pcSlice->getBaseColPic()->getPicYuvRec()->getHeight() - confBL.getWindowTopOffset() - confBL.getWindowBottomOffset();
559
560	Int widthEL = pcPic->getPicYuvRec()->getWidth() - confEL.getWindowLeftOffset() - confEL.getWindowRightOffset();
561	Int heightEL = pcPic->getPicYuvRec()->getHeight() - confEL.getWindowTopOffset() - confEL.getWindowBottomOffset();
562	#endif
563	g_mvScalingFactor[m_layerId][0] = widthEL == widthBL ? 4096 : Clip3(-4096, 4095, ((widthEL << 8) + (widthBL >> 1)) / widthBL);
564	g_mvScalingFactor[m_layerId][1] = heightEL == heightBL ? 4096 : Clip3(-4096, 4095, ((heightEL << 8) + (heightBL >> 1)) / heightBL);
565
566	g_posScalingFactor[m_layerId][0] = ((widthBL << 16) + (widthEL >> 1)) / widthEL;
567	g_posScalingFactor[m_layerId][1] = ((heightBL << 16) + (heightEL >> 1)) / heightEL;
568	#endif
569	}
570	#endif
571
572	#if REF_IDX_FRAMEWORK
573	if( m_layerId > 0 && (pocCurr % m_pcCfg->getIntraPeriod() == 0) )
574	{
575	#if IDR_ALIGNMENT
576	if( pcSlice->getBaseColPic()->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL \|\| pcSlice->getBaseColPic()->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP )
577	{
578	pcSlice->setNalUnitType(pcSlice->getBaseColPic()->getSlice(0)->getNalUnitType());
579	}
580	else
581	#endif
582	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_CRA);
583	}
584	#if ZERO_NUM_DIRECT_LAYERS
585	if( m_layerId > 0 && pcSlice->getActiveNumILRRefIdx() == 0 && pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA )
586	{
587	pcSlice->setSliceType(I_SLICE);
588	}
589	else
590	#endif
591	if( m_layerId > 0 && !m_pcEncTop->getElRapSliceTypeB() )
592	{
593	if( (pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP) &&
594	(pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA) &&
595	pcSlice->getSliceType() == B_SLICE )
596	{
597	pcSlice->setSliceType(P_SLICE);
598	}
599	}
600	#endif
601	if(pcSlice->getTemporalLayerNonReferenceFlag())
602	{
603	if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_TRAIL_R)
604	{
605	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TRAIL_N);
606	}
607	if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_RADL_R)
608	{
609	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_RADL_N);
610	}
611	if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_RASL_R)
612	{
613	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_RASL_N);
614	}
615	}
616
617	// Do decoding refresh marking if any
618	pcSlice->decodingRefreshMarking(m_pocCRA, m_bRefreshPending, rcListPic);
619	m_pcEncTop->selectReferencePictureSet(pcSlice, pocCurr, iGOPid);
620	pcSlice->getRPS()->setNumberOfLongtermPictures(0);
621
622	if(pcSlice->checkThatAllRefPicsAreAvailable(rcListPic, pcSlice->getRPS(), false) != 0)
623	{
624	pcSlice->createExplicitReferencePictureSetFromReference(rcListPic, pcSlice->getRPS());
625	}
626	pcSlice->applyReferencePictureSet(rcListPic, pcSlice->getRPS());
627
628	if(pcSlice->getTLayer() > 0)
629	{
630	if(pcSlice->isTemporalLayerSwitchingPoint(rcListPic) \|\| pcSlice->getSPS()->getTemporalIdNestingFlag())
631	{
632	if(pcSlice->getTemporalLayerNonReferenceFlag())
633	{
634	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TSA_N);
635	}
636	else
637	{
638	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TLA_R);
639	}
640	}
641	else if(pcSlice->isStepwiseTemporalLayerSwitchingPointCandidate(rcListPic))
642	{
643	Bool isSTSA=true;
644	for(Int ii=iGOPid+1;(ii<m_pcCfg->getGOPSize() && isSTSA==true);ii++)
645	{
646	Int lTid= m_pcCfg->getGOPEntry(ii).m_temporalId;
647	if(lTid==pcSlice->getTLayer())
648	{
649	TComReferencePictureSet* nRPS = pcSlice->getSPS()->getRPSList()->getReferencePictureSet(ii);
650	for(Int jj=0;jj<nRPS->getNumberOfPictures();jj++)
651	{
652	if(nRPS->getUsed(jj))
653	{
654	Int tPoc=m_pcCfg->getGOPEntry(ii).m_POC+nRPS->getDeltaPOC(jj);
655	Int kk=0;
656	for(kk=0;kk<m_pcCfg->getGOPSize();kk++)
657	{
658	if(m_pcCfg->getGOPEntry(kk).m_POC==tPoc)
659	break;
660	}
661	Int tTid=m_pcCfg->getGOPEntry(kk).m_temporalId;
662	if(tTid >= pcSlice->getTLayer())
663	{
664	isSTSA=false;
665	break;
666	}
667	}
668	}
669	}
670	}
671	if(isSTSA==true)
672	{
673	if(pcSlice->getTemporalLayerNonReferenceFlag())
674	{
675	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_STSA_N);
676	}
677	else
678	{
679	pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_STSA_R);
680	}
681	}
682	}
683	}
684	arrangeLongtermPicturesInRPS(pcSlice, rcListPic);
685	TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
686	refPicListModification->setRefPicListModificationFlagL0(0);
687	refPicListModification->setRefPicListModificationFlagL1(0);
688	pcSlice->setNumRefIdx(REF_PIC_LIST_0,min(m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive,pcSlice->getRPS()->getNumberOfPictures()));
689	pcSlice->setNumRefIdx(REF_PIC_LIST_1,min(m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive,pcSlice->getRPS()->getNumberOfPictures()));
690
691	#if REF_IDX_FRAMEWORK
692	#if ZERO_NUM_DIRECT_LAYERS
693	if( m_layerId > 0 && pcSlice->getActiveNumILRRefIdx() )
694	#else
695	if(m_layerId > 0)
696	#endif
697	{
698	#if RESTR_CHK
699	if (pcSlice->getPOC()>0 && pcSlice->isRADL()&& pcPic->getSlice(0)->isRASL())
700	{
701	#if JCTVC_M0458_INTERLAYER_RPS_SIG
702	pcSlice->setActiveNumILRRefIdx(0);
703	pcSlice->setInterLayerPredEnabledFlag(0);
704	#else
705	pcSlice->setNumILRRefIdx(0);
706	#endif
707	}
708	#endif
709	#if JCTVC_M0458_INTERLAYER_RPS_SIG
710	if( pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA )
711	{
712	pcSlice->setNumRefIdx(REF_PIC_LIST_0, pcSlice->getActiveNumILRRefIdx());
713	pcSlice->setNumRefIdx(REF_PIC_LIST_1, pcSlice->getActiveNumILRRefIdx());
714	}
715	else
716	{
717	pcSlice->setNumRefIdx(REF_PIC_LIST_0, pcSlice->getNumRefIdx(REF_PIC_LIST_0)+pcSlice->getActiveNumILRRefIdx());
718	pcSlice->setNumRefIdx(REF_PIC_LIST_1, pcSlice->getNumRefIdx(REF_PIC_LIST_1)+pcSlice->getActiveNumILRRefIdx());
719	}
720	#else
721	if( pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA )
722	{
723	pcSlice->setNumRefIdx(REF_PIC_LIST_0, pcSlice->getNumILRRefIdx());
724	pcSlice->setNumRefIdx(REF_PIC_LIST_1, pcSlice->getNumILRRefIdx());
725	}
726	else
727	{
728	pcSlice->setNumRefIdx(REF_PIC_LIST_0, pcSlice->getNumRefIdx(REF_PIC_LIST_0)+pcSlice->getNumILRRefIdx());
729	pcSlice->setNumRefIdx(REF_PIC_LIST_1, pcSlice->getNumRefIdx(REF_PIC_LIST_1)+pcSlice->getNumILRRefIdx());
730	}
731	#endif
732	}
733	#endif
734
735	#if ADAPTIVE_QP_SELECTION
736	pcSlice->setTrQuant( m_pcEncTop->getTrQuant() );
737	#endif
738
739	#if SVC_EXTENSION
740	#if ZERO_NUM_DIRECT_LAYERS
741	if( m_layerId > 0 && pcSlice->getActiveNumILRRefIdx() )
742	#else
743	if(m_layerId > 0)
744	#endif
745	{
746	#if !IDR_ALIGNMENT
747	TComList<TComPic> cListPic = m_ppcTEncTop[m_layerId-1]->getListPic();
748	pcSlice->setBaseColPic (*cListPic, m_layerId );
749
750	#if SIMPLIFIED_MV_POS_SCALING
751	#if SCALED_REF_LAYER_OFFSETS
752	const Window &scalEL = m_pcEncTop->getScaledRefLayerWindow();
753
754	Int widthBL = pcSlice->getBaseColPic()->getPicYuvRec()->getWidth();
755	Int heightBL = pcSlice->getBaseColPic()->getPicYuvRec()->getHeight();
756
757	Int widthEL = pcPic->getPicYuvRec()->getWidth() - scalEL.getWindowLeftOffset() - scalEL.getWindowRightOffset();
758	Int heightEL = pcPic->getPicYuvRec()->getHeight() - scalEL.getWindowTopOffset() - scalEL.getWindowBottomOffset();
759	#else
760	const Window &confBL = pcSlice->getBaseColPic()->getPicYuvRec()->getConformanceWindow();
761	const Window &confEL = pcPic->getPicYuvRec()->getConformanceWindow();
762
763	Int widthBL = pcSlice->getBaseColPic()->getPicYuvRec()->getWidth () - confBL.getWindowLeftOffset() - confBL.getWindowRightOffset();
764	Int heightBL = pcSlice->getBaseColPic()->getPicYuvRec()->getHeight() - confBL.getWindowTopOffset() - confBL.getWindowBottomOffset();
765
766	Int widthEL = pcPic->getPicYuvRec()->getWidth() - confEL.getWindowLeftOffset() - confEL.getWindowRightOffset();
767	Int heightEL = pcPic->getPicYuvRec()->getHeight() - confEL.getWindowTopOffset() - confEL.getWindowBottomOffset();
768	#endif
769	g_mvScalingFactor[m_layerId][0] = widthEL == widthBL ? 4096 : Clip3(-4096, 4095, ((widthEL << 8) + (widthBL >> 1)) / widthBL);
770	g_mvScalingFactor[m_layerId][1] = heightEL == heightBL ? 4096 : Clip3(-4096, 4095, ((heightEL << 8) + (heightBL >> 1)) / heightBL);
771
772	g_posScalingFactor[m_layerId][0] = ((widthBL << 16) + (widthEL >> 1)) / widthEL;
773	g_posScalingFactor[m_layerId][1] = ((heightBL << 16) + (heightEL >> 1)) / heightEL;
774	#endif
775	#endif
776	#if SVC_UPSAMPLING
777	if ( pcPic->isSpatialEnhLayer())
778	{
779	#if SCALED_REF_LAYER_OFFSETS
780	m_pcPredSearch->upsampleBasePic( pcPic->getFullPelBaseRec(), pcSlice->getBaseColPic()->getPicYuvRec(), pcPic->getPicYuvRec(), pcSlice->getSPS()->getScaledRefLayerWindow() );
781	#else
782	m_pcPredSearch->upsampleBasePic( pcPic->getFullPelBaseRec(), pcSlice->getBaseColPic()->getPicYuvRec(), pcPic->getPicYuvRec() );
783	#endif
784	}
785	else
786	{
787	pcPic->setFullPelBaseRec( pcSlice->getBaseColPic()->getPicYuvRec() );
788	}
789	pcSlice->setFullPelBaseRec ( pcPic->getFullPelBaseRec() );
790	#endif
791	}
792	#endif
793
794	#if REF_IDX_FRAMEWORK
795	if( pcSlice->getSliceType() == B_SLICE )
796	{
797	pcSlice->setColFromL0Flag(1-uiColDir);
798	}
799	#endif
800
801	// Set reference list
802	#if REF_IDX_FRAMEWORK
803	#if ZERO_NUM_DIRECT_LAYERS
804	if(m_layerId == 0 \|\| ( m_layerId > 0 && pcSlice->getActiveNumILRRefIdx() == 0 ) )
805	#else
806	if(m_layerId == 0)
807	#endif
808	{
809	pcSlice->setRefPicList( rcListPic);
810	}
811	#else
812	pcSlice->setRefPicList ( rcListPic );
813	#endif
814	#if REF_IDX_FRAMEWORK
815	#if ZERO_NUM_DIRECT_LAYERS
816	if( m_layerId > 0 && pcSlice->getActiveNumILRRefIdx() )
817	#else
818	if(m_layerId > 0)
819	#endif
820	{
821	m_pcEncTop->setILRPic(pcPic);
822
823	#if REF_IDX_MFM
824	if( pcSlice->getSPS()->getMFMEnabledFlag() )
825	{
826	pcSlice->setRefPOCListILP(m_pcEncTop->getIlpList(), pcSlice->getBaseColPic());
827	}
828	#endif
829	pcSlice->setRefPicListModificationSvc();
830	pcSlice->setRefPicList( rcListPic, false, m_pcEncTop->getIlpList());
831
832	#if REF_IDX_MFM
833	if( pcSlice->getSPS()->getMFMEnabledFlag() )
834	{
835	Bool found = false;
836	UInt ColFromL0Flag = pcSlice->getColFromL0Flag();
837	UInt ColRefIdx = pcSlice->getColRefIdx();
838	for(Int colIdx = 0; colIdx < pcSlice->getNumRefIdx( RefPicList(1 - ColFromL0Flag) ); colIdx++)
839	{
840	if( pcSlice->getRefPic( RefPicList(1 - ColFromL0Flag), colIdx)->isILR(m_layerId) )
841	{
842	ColRefIdx = colIdx;
843	found = true;
844	break;
845	}
846	}
847
848	if( found == false )
849	{
850	ColFromL0Flag = 1 - ColFromL0Flag;
851	for(Int colIdx = 0; colIdx < pcSlice->getNumRefIdx( RefPicList(1 - ColFromL0Flag) ); colIdx++)
852	{
853	if( pcSlice->getRefPic( RefPicList(1 - ColFromL0Flag), colIdx)->isILR(m_layerId) )
854	{
855	ColRefIdx = colIdx;
856	found = true;
857	break;
858	}
859	}
860	}
861
862	if(found == true)
863	{
864	pcSlice->setColFromL0Flag(ColFromL0Flag);
865	pcSlice->setColRefIdx(ColRefIdx);
866	}
867	}
868	#endif
869	}
870	#endif
871
872	// Slice info. refinement
873	if ( (pcSlice->getSliceType() == B_SLICE) && (pcSlice->getNumRefIdx(REF_PIC_LIST_1) == 0) )
874	{
875	pcSlice->setSliceType ( P_SLICE );
876	}
877	#if !L0034_COMBINED_LIST_CLEANUP
878	if (pcSlice->getSliceType() != B_SLICE \|\| !pcSlice->getSPS()->getUseLComb())
879	{
880	pcSlice->setNumRefIdx(REF_PIC_LIST_C, 0);
881	pcSlice->setRefPicListCombinationFlag(false);
882	pcSlice->setRefPicListModificationFlagLC(false);
883	}
884	else
885	{
886	pcSlice->setRefPicListCombinationFlag(pcSlice->getSPS()->getUseLComb());
887	pcSlice->setNumRefIdx(REF_PIC_LIST_C, pcSlice->getNumRefIdx(REF_PIC_LIST_0));
888	}
889	#endif
890
891	if (pcSlice->getSliceType() == B_SLICE)
892	{
893	#if !REF_IDX_FRAMEWORK
894	pcSlice->setColFromL0Flag(1-uiColDir);
895	#endif
896	Bool bLowDelay = true;
897	Int iCurrPOC = pcSlice->getPOC();
898	Int iRefIdx = 0;
899
900	for (iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_0) && bLowDelay; iRefIdx++)
901	{
902	if ( pcSlice->getRefPic(REF_PIC_LIST_0, iRefIdx)->getPOC() > iCurrPOC )
903	{
904	bLowDelay = false;
905	}
906	}
907	for (iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_1) && bLowDelay; iRefIdx++)
908	{
909	if ( pcSlice->getRefPic(REF_PIC_LIST_1, iRefIdx)->getPOC() > iCurrPOC )
910	{
911	bLowDelay = false;
912	}
913	}
914
915	pcSlice->setCheckLDC(bLowDelay);
916	}
917	else
918	{
919	pcSlice->setCheckLDC(true);
920	}
921
922	uiColDir = 1-uiColDir;
923
924	//-------------------------------------------------------------
925	pcSlice->setRefPOCList();
926
927	#if L0034_COMBINED_LIST_CLEANUP
928	pcSlice->setList1IdxToList0Idx();
929	#else
930	pcSlice->setNoBackPredFlag( false );
931	if ( pcSlice->getSliceType() == B_SLICE && !pcSlice->getRefPicListCombinationFlag())
932	{
933	if ( pcSlice->getNumRefIdx(RefPicList( 0 ) ) == pcSlice->getNumRefIdx(RefPicList( 1 ) ) )
934	{
935	pcSlice->setNoBackPredFlag( true );
936	Int i;
937	for ( i=0; i < pcSlice->getNumRefIdx(RefPicList( 1 ) ); i++ )
938	{
939	if ( pcSlice->getRefPOC(RefPicList(1), i) != pcSlice->getRefPOC(RefPicList(0), i) )
940	{
941	pcSlice->setNoBackPredFlag( false );
942	break;
943	}
944	}
945	}
946	}
947
948	if(pcSlice->getNoBackPredFlag())
949	{
950	pcSlice->setNumRefIdx(REF_PIC_LIST_C, 0);
951	}
952	pcSlice->generateCombinedList();
953	#endif
954
955	if (m_pcEncTop->getTMVPModeId() == 2)
956	{
957	if (iGOPid == 0) // first picture in SOP (i.e. forward B)
958	{
959	pcSlice->setEnableTMVPFlag(0);
960	}
961	else
962	{
963	// Note: pcSlice->getColFromL0Flag() is assumed to be always 0 and getcolRefIdx() is always 0.
964	pcSlice->setEnableTMVPFlag(1);
965	}
966	pcSlice->getSPS()->setTMVPFlagsPresent(1);
967	}
968	else if (m_pcEncTop->getTMVPModeId() == 1)
969	{
970	pcSlice->getSPS()->setTMVPFlagsPresent(1);
971	pcSlice->setEnableTMVPFlag(1);
972	}
973	else
974	{
975	pcSlice->getSPS()->setTMVPFlagsPresent(0);
976	pcSlice->setEnableTMVPFlag(0);
977	}
978	/////////////////////////////////////////////////////////////////////////////////////////////////// Compress a slice
979	// Slice compression
980	if (m_pcCfg->getUseASR())
981	{
982	m_pcSliceEncoder->setSearchRange(pcSlice);
983	}
984
985	Bool bGPBcheck=false;
986	if ( pcSlice->getSliceType() == B_SLICE)
987	{
988	if ( pcSlice->getNumRefIdx(RefPicList( 0 ) ) == pcSlice->getNumRefIdx(RefPicList( 1 ) ) )
989	{
990	bGPBcheck=true;
991	Int i;
992	for ( i=0; i < pcSlice->getNumRefIdx(RefPicList( 1 ) ); i++ )
993	{
994	if ( pcSlice->getRefPOC(RefPicList(1), i) != pcSlice->getRefPOC(RefPicList(0), i) )
995	{
996	bGPBcheck=false;
997	break;
998	}
999	}
1000	}
1001	}
1002	if(bGPBcheck)
1003	{
1004	pcSlice->setMvdL1ZeroFlag(true);
1005	}
1006	else
1007	{
1008	pcSlice->setMvdL1ZeroFlag(false);
1009	}
1010	pcPic->getSlice(pcSlice->getSliceIdx())->setMvdL1ZeroFlag(pcSlice->getMvdL1ZeroFlag());
1011
1012	#if RATE_CONTROL_LAMBDA_DOMAIN
1013	Int sliceQP = pcSlice->getSliceQp();
1014	Double lambda = 0.0;
1015	Int actualHeadBits = 0;
1016	Int actualTotalBits = 0;
1017	Int estimatedBits = 0;
1018	Int tmpBitsBeforeWriting = 0;
1019	if ( m_pcCfg->getUseRateCtrl() )
1020	{
1021	Int frameLevel = m_pcRateCtrl->getRCSeq()->getGOPID2Level( iGOPid );
1022	if ( pcPic->getSlice(0)->getSliceType() == I_SLICE )
1023	{
1024	frameLevel = 0;
1025	}
1026	m_pcRateCtrl->initRCPic( frameLevel );
1027	estimatedBits = m_pcRateCtrl->getRCPic()->getTargetBits();
1028
1029	if ( ( pcSlice->getPOC() == 0 && m_pcCfg->getInitialQP() > 0 ) \|\| ( frameLevel == 0 && m_pcCfg->getForceIntraQP() ) ) // QP is specified
1030	{
1031	sliceQP = m_pcCfg->getInitialQP();
1032	Int NumberBFrames = ( m_pcCfg->getGOPSize() - 1 );
1033	Double dLambda_scale = 1.0 - Clip3( 0.0, 0.5, 0.05*(Double)NumberBFrames );
1034	Double dQPFactor = 0.57*dLambda_scale;
1035	Int SHIFT_QP = 12;
1036	Int bitdepth_luma_qp_scale = 0;
1037	Double qp_temp = (Double) sliceQP + bitdepth_luma_qp_scale - SHIFT_QP;
1038	lambda = dQPFactor*pow( 2.0, qp_temp/3.0 );
1039	}
1040	else if ( frameLevel == 0 ) // intra case, but use the model
1041	{
1042	if ( m_pcCfg->getIntraPeriod() != 1 ) // do not refine allocated bits for all intra case
1043	{
1044	Int bits = m_pcRateCtrl->getRCSeq()->getLeftAverageBits();
1045	bits = m_pcRateCtrl->getRCSeq()->getRefineBitsForIntra( bits );
1046	if ( bits < 200 )
1047	{
1048	bits = 200;
1049	}
1050	m_pcRateCtrl->getRCPic()->setTargetBits( bits );
1051	}
1052
1053	list<TEncRCPic*> listPreviousPicture = m_pcRateCtrl->getPicList();
1054	lambda = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture );
1055	sliceQP = m_pcRateCtrl->getRCPic()->estimatePicQP( lambda, listPreviousPicture );
1056	}
1057	else // normal case
1058	{
1059	list<TEncRCPic*> listPreviousPicture = m_pcRateCtrl->getPicList();
1060	lambda = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture );
1061	sliceQP = m_pcRateCtrl->getRCPic()->estimatePicQP( lambda, listPreviousPicture );
1062	}
1063
1064	sliceQP = Clip3( -pcSlice->getSPS()->getQpBDOffsetY(), MAX_QP, sliceQP );
1065	m_pcRateCtrl->getRCPic()->setPicEstQP( sliceQP );
1066
1067	m_pcSliceEncoder->resetQP( pcPic, sliceQP, lambda );
1068	}
1069	#endif
1070
1071	UInt uiNumSlices = 1;
1072
1073	UInt uiInternalAddress = pcPic->getNumPartInCU()-4;
1074	UInt uiExternalAddress = pcPic->getPicSym()->getNumberOfCUsInFrame()-1;
1075	UInt uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
1076	UInt uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
1077	UInt uiWidth = pcSlice->getSPS()->getPicWidthInLumaSamples();
1078	UInt uiHeight = pcSlice->getSPS()->getPicHeightInLumaSamples();
1079	while(uiPosX>=uiWidth\|\|uiPosY>=uiHeight)
1080	{
1081	uiInternalAddress--;
1082	uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
1083	uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
1084	}
1085	uiInternalAddress++;
1086	if(uiInternalAddress==pcPic->getNumPartInCU())
1087	{
1088	uiInternalAddress = 0;
1089	uiExternalAddress++;
1090	}
1091	UInt uiRealEndAddress = uiExternalAddress*pcPic->getNumPartInCU()+uiInternalAddress;
1092
1093	UInt uiCummulativeTileWidth;
1094	UInt uiCummulativeTileHeight;
1095	Int p, j;
1096	UInt uiEncCUAddr;
1097
1098	//set NumColumnsMinus1 and NumRowsMinus1
1099	pcPic->getPicSym()->setNumColumnsMinus1( pcSlice->getPPS()->getNumColumnsMinus1() );
1100	pcPic->getPicSym()->setNumRowsMinus1( pcSlice->getPPS()->getNumRowsMinus1() );
1101
1102	//create the TComTileArray
1103	pcPic->getPicSym()->xCreateTComTileArray();
1104
1105	if( pcSlice->getPPS()->getUniformSpacingFlag() == 1 )
1106	{
1107	//set the width for each tile
1108	for(j=0; j < pcPic->getPicSym()->getNumRowsMinus1()+1; j++)
1109	{
1110	for(p=0; p < pcPic->getPicSym()->getNumColumnsMinus1()+1; p++)
1111	{
1112	pcPic->getPicSym()->getTComTile( j * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + p )->
1113	setTileWidth( (p+1)*pcPic->getPicSym()->getFrameWidthInCU()/(pcPic->getPicSym()->getNumColumnsMinus1()+1)
1114	- (p*pcPic->getPicSym()->getFrameWidthInCU())/(pcPic->getPicSym()->getNumColumnsMinus1()+1) );
1115	}
1116	}
1117
1118	//set the height for each tile
1119	for(j=0; j < pcPic->getPicSym()->getNumColumnsMinus1()+1; j++)
1120	{
1121	for(p=0; p < pcPic->getPicSym()->getNumRowsMinus1()+1; p++)
1122	{
1123	pcPic->getPicSym()->getTComTile( p * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + j )->
1124	setTileHeight( (p+1)*pcPic->getPicSym()->getFrameHeightInCU()/(pcPic->getPicSym()->getNumRowsMinus1()+1)
1125	- (p*pcPic->getPicSym()->getFrameHeightInCU())/(pcPic->getPicSym()->getNumRowsMinus1()+1) );
1126	}
1127	}
1128	}
1129	else
1130	{
1131	//set the width for each tile
1132	for(j=0; j < pcPic->getPicSym()->getNumRowsMinus1()+1; j++)
1133	{
1134	uiCummulativeTileWidth = 0;
1135	for(p=0; p < pcPic->getPicSym()->getNumColumnsMinus1(); p++)
1136	{
1137	pcPic->getPicSym()->getTComTile( j * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + p )->setTileWidth( pcSlice->getPPS()->getColumnWidth(p) );
1138	uiCummulativeTileWidth += pcSlice->getPPS()->getColumnWidth(p);
1139	}
1140	pcPic->getPicSym()->getTComTile(j * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + p)->setTileWidth( pcPic->getPicSym()->getFrameWidthInCU()-uiCummulativeTileWidth );
1141	}
1142
1143	//set the height for each tile
1144	for(j=0; j < pcPic->getPicSym()->getNumColumnsMinus1()+1; j++)
1145	{
1146	uiCummulativeTileHeight = 0;
1147	for(p=0; p < pcPic->getPicSym()->getNumRowsMinus1(); p++)
1148	{
1149	pcPic->getPicSym()->getTComTile( p * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + j )->setTileHeight( pcSlice->getPPS()->getRowHeight(p) );
1150	uiCummulativeTileHeight += pcSlice->getPPS()->getRowHeight(p);
1151	}
1152	pcPic->getPicSym()->getTComTile(p * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + j)->setTileHeight( pcPic->getPicSym()->getFrameHeightInCU()-uiCummulativeTileHeight );
1153	}
1154	}
1155	//intialize each tile of the current picture
1156	pcPic->getPicSym()->xInitTiles();
1157
1158	// Allocate some coders, now we know how many tiles there are.
1159	Int iNumSubstreams = pcSlice->getPPS()->getNumSubstreams();
1160
1161	//generate the Coding Order Map and Inverse Coding Order Map
1162	for(p=0, uiEncCUAddr=0; p<pcPic->getPicSym()->getNumberOfCUsInFrame(); p++, uiEncCUAddr = pcPic->getPicSym()->xCalculateNxtCUAddr(uiEncCUAddr))
1163	{
1164	pcPic->getPicSym()->setCUOrderMap(p, uiEncCUAddr);
1165	pcPic->getPicSym()->setInverseCUOrderMap(uiEncCUAddr, p);
1166	}
1167	pcPic->getPicSym()->setCUOrderMap(pcPic->getPicSym()->getNumberOfCUsInFrame(), pcPic->getPicSym()->getNumberOfCUsInFrame());
1168	pcPic->getPicSym()->setInverseCUOrderMap(pcPic->getPicSym()->getNumberOfCUsInFrame(), pcPic->getPicSym()->getNumberOfCUsInFrame());
1169
1170	// Allocate some coders, now we know how many tiles there are.
1171	m_pcEncTop->createWPPCoders(iNumSubstreams);
1172	pcSbacCoders = m_pcEncTop->getSbacCoders();
1173	pcSubstreamsOut = new TComOutputBitstream[iNumSubstreams];
1174
1175	UInt startCUAddrSliceIdx = 0; // used to index "m_uiStoredStartCUAddrForEncodingSlice" containing locations of slice boundaries
1176	UInt startCUAddrSlice = 0; // used to keep track of current slice's starting CU addr.
1177	pcSlice->setSliceCurStartCUAddr( startCUAddrSlice ); // Setting "start CU addr" for current slice
1178	m_storedStartCUAddrForEncodingSlice.clear();
1179
1180	UInt startCUAddrSliceSegmentIdx = 0; // used to index "m_uiStoredStartCUAddrForEntropyEncodingSlice" containing locations of slice boundaries
1181	UInt startCUAddrSliceSegment = 0; // used to keep track of current Dependent slice's starting CU addr.
1182	pcSlice->setSliceSegmentCurStartCUAddr( startCUAddrSliceSegment ); // Setting "start CU addr" for current Dependent slice
1183
1184	m_storedStartCUAddrForEncodingSliceSegment.clear();
1185	UInt nextCUAddr = 0;
1186	m_storedStartCUAddrForEncodingSlice.push_back (nextCUAddr);
1187	startCUAddrSliceIdx++;
1188	m_storedStartCUAddrForEncodingSliceSegment.push_back(nextCUAddr);
1189	startCUAddrSliceSegmentIdx++;
1190	#if AVC_BASE
1191	if( m_layerId == 0 && m_pcEncTop->getVPS()->getAvcBaseLayerFlag() )
1192	{
1193	pcPic->getPicYuvOrg()->copyToPic( pcPic->getPicYuvRec() );
1194	#if AVC_SYNTAX
1195	pcPic->readBLSyntax( m_ppcTEncTop[0]->getBLSyntaxFile(), SYNTAX_BYTES );
1196	#endif
1197	return;
1198	}
1199	#endif
1200
1201	while(nextCUAddr<uiRealEndAddress) // determine slice boundaries
1202	{
1203	pcSlice->setNextSlice ( false );
1204	pcSlice->setNextSliceSegment( false );
1205	assert(pcPic->getNumAllocatedSlice() == startCUAddrSliceIdx);
1206	m_pcSliceEncoder->precompressSlice( pcPic );
1207	m_pcSliceEncoder->compressSlice ( pcPic );
1208
1209	Bool bNoBinBitConstraintViolated = (!pcSlice->isNextSlice() && !pcSlice->isNextSliceSegment());
1210	if (pcSlice->isNextSlice() \|\| (bNoBinBitConstraintViolated && m_pcCfg->getSliceMode()==FIXED_NUMBER_OF_LCU))
1211	{
1212	startCUAddrSlice = pcSlice->getSliceCurEndCUAddr();
1213	// Reconstruction slice
1214	m_storedStartCUAddrForEncodingSlice.push_back(startCUAddrSlice);
1215	startCUAddrSliceIdx++;
1216	// Dependent slice
1217	if (startCUAddrSliceSegmentIdx>0 && m_storedStartCUAddrForEncodingSliceSegment[startCUAddrSliceSegmentIdx-1] != startCUAddrSlice)
1218	{
1219	m_storedStartCUAddrForEncodingSliceSegment.push_back(startCUAddrSlice);
1220	startCUAddrSliceSegmentIdx++;
1221	}
1222
1223	if (startCUAddrSlice < uiRealEndAddress)
1224	{
1225	pcPic->allocateNewSlice();
1226	pcPic->setCurrSliceIdx ( startCUAddrSliceIdx-1 );
1227	m_pcSliceEncoder->setSliceIdx ( startCUAddrSliceIdx-1 );
1228	pcSlice = pcPic->getSlice ( startCUAddrSliceIdx-1 );
1229	pcSlice->copySliceInfo ( pcPic->getSlice(0) );
1230	pcSlice->setSliceIdx ( startCUAddrSliceIdx-1 );
1231	pcSlice->setSliceCurStartCUAddr ( startCUAddrSlice );
1232	pcSlice->setSliceSegmentCurStartCUAddr ( startCUAddrSlice );
1233	pcSlice->setSliceBits(0);
1234	uiNumSlices ++;
1235	}
1236	}
1237	else if (pcSlice->isNextSliceSegment() \|\| (bNoBinBitConstraintViolated && m_pcCfg->getSliceSegmentMode()==FIXED_NUMBER_OF_LCU))
1238	{
1239	startCUAddrSliceSegment = pcSlice->getSliceSegmentCurEndCUAddr();
1240	m_storedStartCUAddrForEncodingSliceSegment.push_back(startCUAddrSliceSegment);
1241	startCUAddrSliceSegmentIdx++;
1242	pcSlice->setSliceSegmentCurStartCUAddr( startCUAddrSliceSegment );
1243	}
1244	else
1245	{
1246	startCUAddrSlice = pcSlice->getSliceCurEndCUAddr();
1247	startCUAddrSliceSegment = pcSlice->getSliceSegmentCurEndCUAddr();
1248	}
1249
1250	nextCUAddr = (startCUAddrSlice > startCUAddrSliceSegment) ? startCUAddrSlice : startCUAddrSliceSegment;
1251	}
1252	m_storedStartCUAddrForEncodingSlice.push_back( pcSlice->getSliceCurEndCUAddr());
1253	startCUAddrSliceIdx++;
1254	m_storedStartCUAddrForEncodingSliceSegment.push_back(pcSlice->getSliceCurEndCUAddr());
1255	startCUAddrSliceSegmentIdx++;
1256
1257	pcSlice = pcPic->getSlice(0);
1258
1259	// SAO parameter estimation using non-deblocked pixels for LCU bottom and right boundary areas
1260	if( m_pcCfg->getSaoLcuBasedOptimization() && m_pcCfg->getSaoLcuBoundary() )
1261	{
1262	m_pcSAO->resetStats();
1263	m_pcSAO->calcSaoStatsCu_BeforeDblk( pcPic );
1264	}
1265
1266	//-- Loop filter
1267	Bool bLFCrossTileBoundary = pcSlice->getPPS()->getLoopFilterAcrossTilesEnabledFlag();
1268	m_pcLoopFilter->setCfg(bLFCrossTileBoundary);
1269	#if L0386_DB_METRIC
1270	if ( m_pcCfg->getDeblockingFilterMetric() )
1271	{
1272	dblMetric(pcPic, uiNumSlices);
1273	}
1274	#endif
1275	m_pcLoopFilter->loopFilterPic( pcPic );
1276
1277	pcSlice = pcPic->getSlice(0);
1278	if(pcSlice->getSPS()->getUseSAO())
1279	{
1280	std::vector<Bool> LFCrossSliceBoundaryFlag;
1281	for(Int s=0; s< uiNumSlices; s++)
1282	{
1283	LFCrossSliceBoundaryFlag.push_back( ((uiNumSlices==1)?true:pcPic->getSlice(s)->getLFCrossSliceBoundaryFlag()) );
1284	}
1285	m_storedStartCUAddrForEncodingSlice.resize(uiNumSlices+1);
1286	pcPic->createNonDBFilterInfo(m_storedStartCUAddrForEncodingSlice, 0, &LFCrossSliceBoundaryFlag ,pcPic->getPicSym()->getNumTiles() ,bLFCrossTileBoundary);
1287	}
1288
1289
1290	pcSlice = pcPic->getSlice(0);
1291
1292	if(pcSlice->getSPS()->getUseSAO())
1293	{
1294	m_pcSAO->createPicSaoInfo(pcPic);
1295	}
1296
1297	/////////////////////////////////////////////////////////////////////////////////////////////////// File writing
1298	// Set entropy coder
1299	m_pcEntropyCoder->setEntropyCoder ( m_pcCavlcCoder, pcSlice );
1300
1301	/* write various header sets. */
1302	if ( m_bSeqFirst )
1303	{
1304	#if SVC_EXTENSION
1305	OutputNALUnit nalu(NAL_UNIT_VPS, 0, m_layerId);
1306	#if AVC_BASE
1307	if( ( m_layerId == 1 && m_pcEncTop->getVPS()->getAvcBaseLayerFlag() ) \|\| ( m_layerId == 0 && !m_pcEncTop->getVPS()->getAvcBaseLayerFlag() ) )
1308	#else
1309	if( m_layerId == 0 )
1310	#endif
1311	{
1312	#else
1313	OutputNALUnit nalu(NAL_UNIT_VPS);
1314	#endif
1315	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1316	m_pcEntropyCoder->encodeVPS(m_pcEncTop->getVPS());
1317	writeRBSPTrailingBits(nalu.m_Bitstream);
1318	accessUnit.push_back(new NALUnitEBSP(nalu));
1319	#if RATE_CONTROL_LAMBDA_DOMAIN
1320	actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;
1321	#endif
1322	#if SVC_EXTENSION
1323	}
1324	#endif
1325
1326	#if SVC_EXTENSION
1327	nalu = NALUnit(NAL_UNIT_SPS, 0, m_layerId);
1328	#else
1329	nalu = NALUnit(NAL_UNIT_SPS);
1330	#endif
1331	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1332	if (m_bSeqFirst)
1333	{
1334	pcSlice->getSPS()->setNumLongTermRefPicSPS(m_numLongTermRefPicSPS);
1335	for (Int k = 0; k < m_numLongTermRefPicSPS; k++)
1336	{
1337	pcSlice->getSPS()->setLtRefPicPocLsbSps(k, m_ltRefPicPocLsbSps[k]);
1338	pcSlice->getSPS()->setUsedByCurrPicLtSPSFlag(k, m_ltRefPicUsedByCurrPicFlag[k]);
1339	}
1340	}
1341	if( m_pcCfg->getPictureTimingSEIEnabled() \|\| m_pcCfg->getDecodingUnitInfoSEIEnabled() )
1342	{
1343	UInt maxCU = m_pcCfg->getSliceArgument() >> ( pcSlice->getSPS()->getMaxCUDepth() << 1);
1344	UInt numDU = ( m_pcCfg->getSliceMode() == 1 ) ? ( pcPic->getNumCUsInFrame() / maxCU ) : ( 0 );
1345	if( pcPic->getNumCUsInFrame() % maxCU != 0 )
1346	{
1347	numDU ++;
1348	}
1349	pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->setNumDU( numDU );
1350	pcSlice->getSPS()->setHrdParameters( m_pcCfg->getFrameRate(), numDU, m_pcCfg->getTargetBitrate(), ( m_pcCfg->getIntraPeriod() > 0 ) );
1351	}
1352	if( m_pcCfg->getBufferingPeriodSEIEnabled() \|\| m_pcCfg->getPictureTimingSEIEnabled() \|\| m_pcCfg->getDecodingUnitInfoSEIEnabled() )
1353	{
1354	pcSlice->getSPS()->getVuiParameters()->setHrdParametersPresentFlag( true );
1355	}
1356	m_pcEntropyCoder->encodeSPS(pcSlice->getSPS());
1357	writeRBSPTrailingBits(nalu.m_Bitstream);
1358	accessUnit.push_back(new NALUnitEBSP(nalu));
1359	#if RATE_CONTROL_LAMBDA_DOMAIN
1360	actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;
1361	#endif
1362
1363	#if SVC_EXTENSION
1364	nalu = NALUnit(NAL_UNIT_PPS, 0, m_layerId);
1365	#else
1366	nalu = NALUnit(NAL_UNIT_PPS);
1367	#endif
1368	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1369	m_pcEntropyCoder->encodePPS(pcSlice->getPPS());
1370	writeRBSPTrailingBits(nalu.m_Bitstream);
1371	accessUnit.push_back(new NALUnitEBSP(nalu));
1372	#if RATE_CONTROL_LAMBDA_DOMAIN
1373	actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;
1374	#endif
1375
1376	xCreateLeadingSEIMessages(accessUnit, pcSlice->getSPS());
1377
1378	m_bSeqFirst = false;
1379	}
1380
1381	#if L0208_SOP_DESCRIPTION_SEI
1382	if (writeSOP) // write SOP description SEI (if enabled) at the beginning of GOP
1383	{
1384	Int SOPcurrPOC = pocCurr;
1385
1386	OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
1387	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
1388	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1389
1390	SEISOPDescription SOPDescriptionSEI;
1391	SOPDescriptionSEI.m_sopSeqParameterSetId = pcSlice->getSPS()->getSPSId();
1392
1393	UInt i = 0;
1394	UInt prevEntryId = iGOPid;
1395	for (j = iGOPid; j < m_iGopSize; j++)
1396	{
1397	Int deltaPOC = m_pcCfg->getGOPEntry(j).m_POC - m_pcCfg->getGOPEntry(prevEntryId).m_POC;
1398	if ((SOPcurrPOC + deltaPOC) < m_pcCfg->getFramesToBeEncoded())
1399	{
1400	SOPcurrPOC += deltaPOC;
1401	SOPDescriptionSEI.m_sopDescVclNaluType[i] = getNalUnitType(SOPcurrPOC, m_iLastIDR);
1402	SOPDescriptionSEI.m_sopDescTemporalId[i] = m_pcCfg->getGOPEntry(j).m_temporalId;
1403	SOPDescriptionSEI.m_sopDescStRpsIdx[i] = m_pcEncTop->getReferencePictureSetIdxForSOP(pcSlice, SOPcurrPOC, j);
1404	SOPDescriptionSEI.m_sopDescPocDelta[i] = deltaPOC;
1405
1406	prevEntryId = j;
1407	i++;
1408	}
1409	}
1410
1411	SOPDescriptionSEI.m_numPicsInSopMinus1 = i - 1;
1412
1413	m_seiWriter.writeSEImessage( nalu.m_Bitstream, SOPDescriptionSEI, pcSlice->getSPS());
1414	writeRBSPTrailingBits(nalu.m_Bitstream);
1415	accessUnit.push_back(new NALUnitEBSP(nalu));
1416
1417	writeSOP = false;
1418	}
1419	#endif
1420
1421	if( ( m_pcCfg->getPictureTimingSEIEnabled() \|\| m_pcCfg->getDecodingUnitInfoSEIEnabled() ) &&
1422	( pcSlice->getSPS()->getVuiParametersPresentFlag() ) &&
1423	( ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNalHrdParametersPresentFlag() )
1424	\|\| ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getVclHrdParametersPresentFlag() ) ) )
1425	{
1426	if( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getSubPicCpbParamsPresentFlag() )
1427	{
1428	UInt numDU = pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNumDU();
1429	pictureTimingSEI.m_numDecodingUnitsMinus1 = ( numDU - 1 );
1430	pictureTimingSEI.m_duCommonCpbRemovalDelayFlag = false;
1431
1432	if( pictureTimingSEI.m_numNalusInDuMinus1 == NULL )
1433	{
1434	pictureTimingSEI.m_numNalusInDuMinus1 = new UInt[ numDU ];
1435	}
1436	if( pictureTimingSEI.m_duCpbRemovalDelayMinus1 == NULL )
1437	{
1438	pictureTimingSEI.m_duCpbRemovalDelayMinus1 = new UInt[ numDU ];
1439	}
1440	if( accumBitsDU == NULL )
1441	{
1442	accumBitsDU = new UInt[ numDU ];
1443	}
1444	if( accumNalsDU == NULL )
1445	{
1446	accumNalsDU = new UInt[ numDU ];
1447	}
1448	}
1449	pictureTimingSEI.m_auCpbRemovalDelay = std::max<Int>(1, m_totalCoded - m_lastBPSEI); // Syntax element signalled as minus, hence the .
1450	pictureTimingSEI.m_picDpbOutputDelay = pcSlice->getSPS()->getNumReorderPics(0) + pcSlice->getPOC() - m_totalCoded;
1451	#if L0044_DU_DPB_OUTPUT_DELAY_HRD
1452	Int factor = pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getTickDivisorMinus2() + 2;
1453	pictureTimingSEI.m_picDpbOutputDuDelay = factor * pictureTimingSEI.m_picDpbOutputDelay;
1454	if( m_pcCfg->getDecodingUnitInfoSEIEnabled() )
1455	{
1456	picSptDpbOutputDuDelay = factor * pictureTimingSEI.m_picDpbOutputDelay;
1457	}
1458	#endif
1459	}
1460
1461	if( ( m_pcCfg->getBufferingPeriodSEIEnabled() ) && ( pcSlice->getSliceType() == I_SLICE ) &&
1462	( pcSlice->getSPS()->getVuiParametersPresentFlag() ) &&
1463	( ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNalHrdParametersPresentFlag() )
1464	\|\| ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getVclHrdParametersPresentFlag() ) ) )
1465	{
1466	OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
1467	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
1468	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1469
1470	SEIBufferingPeriod sei_buffering_period;
1471
1472	UInt uiInitialCpbRemovalDelay = (90000/2); // 0.5 sec
1473	sei_buffering_period.m_initialCpbRemovalDelay [0][0] = uiInitialCpbRemovalDelay;
1474	sei_buffering_period.m_initialCpbRemovalDelayOffset[0][0] = uiInitialCpbRemovalDelay;
1475	sei_buffering_period.m_initialCpbRemovalDelay [0][1] = uiInitialCpbRemovalDelay;
1476	sei_buffering_period.m_initialCpbRemovalDelayOffset[0][1] = uiInitialCpbRemovalDelay;
1477
1478	#if L0043_TIMING_INFO
1479	Double dTmp = (Double)pcSlice->getSPS()->getVuiParameters()->getTimingInfo()->getNumUnitsInTick() / (Double)pcSlice->getSPS()->getVuiParameters()->getTimingInfo()->getTimeScale();
1480	#else
1481	Double dTmp = (Double)pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNumUnitsInTick() / (Double)pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getTimeScale();
1482	#endif
1483
1484	UInt uiTmp = (UInt)( dTmp * 90000.0 );
1485	uiInitialCpbRemovalDelay -= uiTmp;
1486	uiInitialCpbRemovalDelay -= uiTmp / ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getTickDivisorMinus2() + 2 );
1487	sei_buffering_period.m_initialAltCpbRemovalDelay [0][0] = uiInitialCpbRemovalDelay;
1488	sei_buffering_period.m_initialAltCpbRemovalDelayOffset[0][0] = uiInitialCpbRemovalDelay;
1489	sei_buffering_period.m_initialAltCpbRemovalDelay [0][1] = uiInitialCpbRemovalDelay;
1490	sei_buffering_period.m_initialAltCpbRemovalDelayOffset[0][1] = uiInitialCpbRemovalDelay;
1491
1492	sei_buffering_period.m_rapCpbParamsPresentFlag = 0;
1493	#if L0328_SPLICING
1494	//for the concatenation, it can be set to one during splicing.
1495	sei_buffering_period.m_concatenationFlag = 0;
1496	//since the temporal layer HRD is not ready, we assumed it is fixed
1497	sei_buffering_period.m_auCpbRemovalDelayDelta = 1;
1498	#endif
1499	#if L0044_CPB_DPB_DELAY_OFFSET
1500	sei_buffering_period.m_cpbDelayOffset = 0;
1501	sei_buffering_period.m_dpbDelayOffset = 0;
1502	#endif
1503
1504	m_seiWriter.writeSEImessage( nalu.m_Bitstream, sei_buffering_period, pcSlice->getSPS());
1505	writeRBSPTrailingBits(nalu.m_Bitstream);
1506	#if L0045_NON_NESTED_SEI_RESTRICTIONS
1507	{
1508	UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
1509	UInt offsetPosition = m_activeParameterSetSEIPresentInAU; // Insert BP SEI after APS SEI
1510	AccessUnit::iterator it;
1511	for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
1512	{
1513	it++;
1514	}
1515	accessUnit.insert(it, new NALUnitEBSP(nalu));
1516	m_bufferingPeriodSEIPresentInAU = true;
1517	}
1518	#else
1519	accessUnit.push_back(new NALUnitEBSP(nalu));
1520	#endif
1521
1522	#if K0180_SCALABLE_NESTING_SEI
1523	if (m_pcCfg->getScalableNestingSEIEnabled())
1524	{
1525	OutputNALUnit naluTmp(NAL_UNIT_PREFIX_SEI);
1526	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
1527	m_pcEntropyCoder->setBitstream(&naluTmp.m_Bitstream);
1528	scalableNestingSEI.m_nestedSEIs.clear();
1529	scalableNestingSEI.m_nestedSEIs.push_back(&sei_buffering_period);
1530	m_seiWriter.writeSEImessage( naluTmp.m_Bitstream, scalableNestingSEI, pcSlice->getSPS());
1531	writeRBSPTrailingBits(naluTmp.m_Bitstream);
1532	#if L0045_NON_NESTED_SEI_RESTRICTIONS
1533	UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
1534	UInt offsetPosition = m_activeParameterSetSEIPresentInAU + m_bufferingPeriodSEIPresentInAU + m_pictureTimingSEIPresentInAU; // Insert BP SEI after non-nested APS, BP and PT SEIs
1535	AccessUnit::iterator it;
1536	for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
1537	{
1538	it++;
1539	}
1540	accessUnit.insert(it, new NALUnitEBSP(naluTmp));
1541	m_nestedBufferingPeriodSEIPresentInAU = true;
1542	#else
1543	accessUnit.push_back(new NALUnitEBSP(naluTmp));
1544	#endif
1545	}
1546	#endif
1547
1548	m_lastBPSEI = m_totalCoded;
1549	m_cpbRemovalDelay = 0;
1550	}
1551	m_cpbRemovalDelay ++;
1552	if( ( m_pcEncTop->getRecoveryPointSEIEnabled() ) && ( pcSlice->getSliceType() == I_SLICE ) )
1553	{
1554	if( m_pcEncTop->getGradualDecodingRefreshInfoEnabled() && !pcSlice->getRapPicFlag() )
1555	{
1556	// Gradual decoding refresh SEI
1557	OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
1558	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
1559	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1560
1561	SEIGradualDecodingRefreshInfo seiGradualDecodingRefreshInfo;
1562	seiGradualDecodingRefreshInfo.m_gdrForegroundFlag = true; // Indicating all "foreground"
1563
1564	m_seiWriter.writeSEImessage( nalu.m_Bitstream, seiGradualDecodingRefreshInfo, pcSlice->getSPS() );
1565	writeRBSPTrailingBits(nalu.m_Bitstream);
1566	accessUnit.push_back(new NALUnitEBSP(nalu));
1567	}
1568	// Recovery point SEI
1569	OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
1570	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
1571	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1572
1573	SEIRecoveryPoint sei_recovery_point;
1574	sei_recovery_point.m_recoveryPocCnt = 0;
1575	sei_recovery_point.m_exactMatchingFlag = ( pcSlice->getPOC() == 0 ) ? (true) : (false);
1576	sei_recovery_point.m_brokenLinkFlag = false;
1577
1578	m_seiWriter.writeSEImessage( nalu.m_Bitstream, sei_recovery_point, pcSlice->getSPS() );
1579	writeRBSPTrailingBits(nalu.m_Bitstream);
1580	accessUnit.push_back(new NALUnitEBSP(nalu));
1581	}
1582
1583	/* use the main bitstream buffer for storing the marshalled picture */
1584	m_pcEntropyCoder->setBitstream(NULL);
1585
1586	startCUAddrSliceIdx = 0;
1587	startCUAddrSlice = 0;
1588
1589	startCUAddrSliceSegmentIdx = 0;
1590	startCUAddrSliceSegment = 0;
1591	nextCUAddr = 0;
1592	pcSlice = pcPic->getSlice(startCUAddrSliceIdx);
1593
1594	Int processingState = (pcSlice->getSPS()->getUseSAO())?(EXECUTE_INLOOPFILTER):(ENCODE_SLICE);
1595	Bool skippedSlice=false;
1596	while (nextCUAddr < uiRealEndAddress) // Iterate over all slices
1597	{
1598	switch(processingState)
1599	{
1600	case ENCODE_SLICE:
1601	{
1602	pcSlice->setNextSlice ( false );
1603	pcSlice->setNextSliceSegment( false );
1604	if (nextCUAddr == m_storedStartCUAddrForEncodingSlice[startCUAddrSliceIdx])
1605	{
1606	pcSlice = pcPic->getSlice(startCUAddrSliceIdx);
1607	if(startCUAddrSliceIdx > 0 && pcSlice->getSliceType()!= I_SLICE)
1608	{
1609	pcSlice->checkColRefIdx(startCUAddrSliceIdx, pcPic);
1610	}
1611	pcPic->setCurrSliceIdx(startCUAddrSliceIdx);
1612	m_pcSliceEncoder->setSliceIdx(startCUAddrSliceIdx);
1613	assert(startCUAddrSliceIdx == pcSlice->getSliceIdx());
1614	// Reconstruction slice
1615	pcSlice->setSliceCurStartCUAddr( nextCUAddr ); // to be used in encodeSlice() + context restriction
1616	pcSlice->setSliceCurEndCUAddr ( m_storedStartCUAddrForEncodingSlice[startCUAddrSliceIdx+1 ] );
1617	// Dependent slice
1618	pcSlice->setSliceSegmentCurStartCUAddr( nextCUAddr ); // to be used in encodeSlice() + context restriction
1619	pcSlice->setSliceSegmentCurEndCUAddr ( m_storedStartCUAddrForEncodingSliceSegment[startCUAddrSliceSegmentIdx+1 ] );
1620
1621	pcSlice->setNextSlice ( true );
1622
1623	startCUAddrSliceIdx++;
1624	startCUAddrSliceSegmentIdx++;
1625	}
1626	else if (nextCUAddr == m_storedStartCUAddrForEncodingSliceSegment[startCUAddrSliceSegmentIdx])
1627	{
1628	// Dependent slice
1629	pcSlice->setSliceSegmentCurStartCUAddr( nextCUAddr ); // to be used in encodeSlice() + context restriction
1630	pcSlice->setSliceSegmentCurEndCUAddr ( m_storedStartCUAddrForEncodingSliceSegment[startCUAddrSliceSegmentIdx+1 ] );
1631
1632	pcSlice->setNextSliceSegment( true );
1633
1634	startCUAddrSliceSegmentIdx++;
1635	}
1636
1637	pcSlice->setRPS(pcPic->getSlice(0)->getRPS());
1638	pcSlice->setRPSidx(pcPic->getSlice(0)->getRPSidx());
1639	UInt uiDummyStartCUAddr;
1640	UInt uiDummyBoundingCUAddr;
1641	m_pcSliceEncoder->xDetermineStartAndBoundingCUAddr(uiDummyStartCUAddr,uiDummyBoundingCUAddr,pcPic,true);
1642
1643	uiInternalAddress = pcPic->getPicSym()->getPicSCUAddr(pcSlice->getSliceSegmentCurEndCUAddr()-1) % pcPic->getNumPartInCU();
1644	uiExternalAddress = pcPic->getPicSym()->getPicSCUAddr(pcSlice->getSliceSegmentCurEndCUAddr()-1) / pcPic->getNumPartInCU();
1645	uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
1646	uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
1647	uiWidth = pcSlice->getSPS()->getPicWidthInLumaSamples();
1648	uiHeight = pcSlice->getSPS()->getPicHeightInLumaSamples();
1649	while(uiPosX>=uiWidth\|\|uiPosY>=uiHeight)
1650	{
1651	uiInternalAddress--;
1652	uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
1653	uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
1654	}
1655	uiInternalAddress++;
1656	if(uiInternalAddress==pcPic->getNumPartInCU())
1657	{
1658	uiInternalAddress = 0;
1659	uiExternalAddress = pcPic->getPicSym()->getCUOrderMap(pcPic->getPicSym()->getInverseCUOrderMap(uiExternalAddress)+1);
1660	}
1661	UInt endAddress = pcPic->getPicSym()->getPicSCUEncOrder(uiExternalAddress*pcPic->getNumPartInCU()+uiInternalAddress);
1662	if(endAddress<=pcSlice->getSliceSegmentCurStartCUAddr())
1663	{
1664	UInt boundingAddrSlice, boundingAddrSliceSegment;
1665	boundingAddrSlice = m_storedStartCUAddrForEncodingSlice[startCUAddrSliceIdx];
1666	boundingAddrSliceSegment = m_storedStartCUAddrForEncodingSliceSegment[startCUAddrSliceSegmentIdx];
1667	nextCUAddr = min(boundingAddrSlice, boundingAddrSliceSegment);
1668	if(pcSlice->isNextSlice())
1669	{
1670	skippedSlice=true;
1671	}
1672	continue;
1673	}
1674	if(skippedSlice)
1675	{
1676	pcSlice->setNextSlice ( true );
1677	pcSlice->setNextSliceSegment( false );
1678	}
1679	skippedSlice=false;
1680	pcSlice->allocSubstreamSizes( iNumSubstreams );
1681	for ( UInt ui = 0 ; ui < iNumSubstreams; ui++ )
1682	{
1683	pcSubstreamsOut[ui].clear();
1684	}
1685
1686	m_pcEntropyCoder->setEntropyCoder ( m_pcCavlcCoder, pcSlice );
1687	m_pcEntropyCoder->resetEntropy ();
1688	/* start slice NALunit */
1689	#if SVC_EXTENSION
1690	OutputNALUnit nalu( pcSlice->getNalUnitType(), pcSlice->getTLayer(), m_layerId );
1691	#else
1692	OutputNALUnit nalu( pcSlice->getNalUnitType(), pcSlice->getTLayer() );
1693	#endif
1694	Bool sliceSegment = (!pcSlice->isNextSlice());
1695	if (!sliceSegment)
1696	{
1697	uiOneBitstreamPerSliceLength = 0; // start of a new slice
1698	}
1699	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1700	#if RATE_CONTROL_LAMBDA_DOMAIN
1701	tmpBitsBeforeWriting = m_pcEntropyCoder->getNumberOfWrittenBits();
1702	#endif
1703	m_pcEntropyCoder->encodeSliceHeader(pcSlice);
1704	#if RATE_CONTROL_LAMBDA_DOMAIN
1705	actualHeadBits += ( m_pcEntropyCoder->getNumberOfWrittenBits() - tmpBitsBeforeWriting );
1706	#endif
1707
1708	// is it needed?
1709	{
1710	if (!sliceSegment)
1711	{
1712	pcBitstreamRedirect->writeAlignOne();
1713	}
1714	else
1715	{
1716	// We've not completed our slice header info yet, do the alignment later.
1717	}
1718	m_pcSbacCoder->init( (TEncBinIf*)m_pcBinCABAC );
1719	m_pcEntropyCoder->setEntropyCoder ( m_pcSbacCoder, pcSlice );
1720	m_pcEntropyCoder->resetEntropy ();
1721	for ( UInt ui = 0 ; ui < pcSlice->getPPS()->getNumSubstreams() ; ui++ )
1722	{
1723	m_pcEntropyCoder->setEntropyCoder ( &pcSbacCoders[ui], pcSlice );
1724	m_pcEntropyCoder->resetEntropy ();
1725	}
1726	}
1727
1728	if(pcSlice->isNextSlice())
1729	{
1730	// set entropy coder for writing
1731	m_pcSbacCoder->init( (TEncBinIf*)m_pcBinCABAC );
1732	{
1733	for ( UInt ui = 0 ; ui < pcSlice->getPPS()->getNumSubstreams() ; ui++ )
1734	{
1735	m_pcEntropyCoder->setEntropyCoder ( &pcSbacCoders[ui], pcSlice );
1736	m_pcEntropyCoder->resetEntropy ();
1737	}
1738	pcSbacCoders[0].load(m_pcSbacCoder);
1739	m_pcEntropyCoder->setEntropyCoder ( &pcSbacCoders[0], pcSlice ); //ALF is written in substream #0 with CABAC coder #0 (see ALF param encoding below)
1740	}
1741	m_pcEntropyCoder->resetEntropy ();
1742	// File writing
1743	if (!sliceSegment)
1744	{
1745	m_pcEntropyCoder->setBitstream(pcBitstreamRedirect);
1746	}
1747	else
1748	{
1749	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1750	}
1751	// for now, override the TILES_DECODER setting in order to write substreams.
1752	m_pcEntropyCoder->setBitstream ( &pcSubstreamsOut[0] );
1753
1754	}
1755	pcSlice->setFinalized(true);
1756
1757	m_pcSbacCoder->load( &pcSbacCoders[0] );
1758
1759	pcSlice->setTileOffstForMultES( uiOneBitstreamPerSliceLength );
1760	pcSlice->setTileLocationCount ( 0 );
1761	m_pcSliceEncoder->encodeSlice(pcPic, pcSubstreamsOut);
1762
1763	{
1764	// Construct the final bitstream by flushing and concatenating substreams.
1765	// The final bitstream is either nalu.m_Bitstream or pcBitstreamRedirect;
1766	UInt* puiSubstreamSizes = pcSlice->getSubstreamSizes();
1767	UInt uiTotalCodedSize = 0; // for padding calcs.
1768	UInt uiNumSubstreamsPerTile = iNumSubstreams;
1769	if (iNumSubstreams > 1)
1770	{
1771	uiNumSubstreamsPerTile /= pcPic->getPicSym()->getNumTiles();
1772	}
1773	for ( UInt ui = 0 ; ui < iNumSubstreams; ui++ )
1774	{
1775	// Flush all substreams -- this includes empty ones.
1776	// Terminating bit and flush.
1777	m_pcEntropyCoder->setEntropyCoder ( &pcSbacCoders[ui], pcSlice );
1778	m_pcEntropyCoder->setBitstream ( &pcSubstreamsOut[ui] );
1779	m_pcEntropyCoder->encodeTerminatingBit( 1 );
1780	m_pcEntropyCoder->encodeSliceFinish();
1781
1782	pcSubstreamsOut[ui].writeByteAlignment(); // Byte-alignment in slice_data() at end of sub-stream
1783	// Byte alignment is necessary between tiles when tiles are independent.
1784	uiTotalCodedSize += pcSubstreamsOut[ui].getNumberOfWrittenBits();
1785
1786	Bool bNextSubstreamInNewTile = ((ui+1) < iNumSubstreams)&& ((ui+1)%uiNumSubstreamsPerTile == 0);
1787	if (bNextSubstreamInNewTile)
1788	{
1789	pcSlice->setTileLocation(ui/uiNumSubstreamsPerTile, pcSlice->getTileOffstForMultES()+(uiTotalCodedSize>>3));
1790	}
1791	if (ui+1 < pcSlice->getPPS()->getNumSubstreams())
1792	{
1793	puiSubstreamSizes[ui] = pcSubstreamsOut[ui].getNumberOfWrittenBits() + (pcSubstreamsOut[ui].countStartCodeEmulations()<<3);
1794	}
1795	}
1796
1797	// Complete the slice header info.
1798	m_pcEntropyCoder->setEntropyCoder ( m_pcCavlcCoder, pcSlice );
1799	m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
1800	m_pcEntropyCoder->encodeTilesWPPEntryPoint( pcSlice );
1801
1802	// Substreams...
1803	TComOutputBitstream *pcOut = pcBitstreamRedirect;
1804	Int offs = 0;
1805	Int nss = pcSlice->getPPS()->getNumSubstreams();
1806	if (pcSlice->getPPS()->getEntropyCodingSyncEnabledFlag())
1807	{
1808	// 1st line present for WPP.
1809	offs = pcSlice->getSliceSegmentCurStartCUAddr()/pcSlice->getPic()->getNumPartInCU()/pcSlice->getPic()->getFrameWidthInCU();
1810	nss = pcSlice->getNumEntryPointOffsets()+1;
1811	}
1812	for ( UInt ui = 0 ; ui < nss; ui++ )
1813	{
1814	pcOut->addSubstream(&pcSubstreamsOut[ui+offs]);
1815	}
1816	}
1817
1818	UInt boundingAddrSlice, boundingAddrSliceSegment;
1819	boundingAddrSlice = m_storedStartCUAddrForEncodingSlice[startCUAddrSliceIdx];
1820	boundingAddrSliceSegment = m_storedStartCUAddrForEncodingSliceSegment[startCUAddrSliceSegmentIdx];
1821	nextCUAddr = min(boundingAddrSlice, boundingAddrSliceSegment);
1822	// If current NALU is the first NALU of slice (containing slice header) and more NALUs exist (due to multiple dependent slices) then buffer it.
1823	// 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.
1824	Bool bNALUAlignedWrittenToList = false; // used to ensure current NALU is not written more than once to the NALU list.
1825	xAttachSliceDataToNalUnit(nalu, pcBitstreamRedirect);
1826	accessUnit.push_back(new NALUnitEBSP(nalu));
1827	#if RATE_CONTROL_LAMBDA_DOMAIN
1828	actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;
1829	#endif
1830	bNALUAlignedWrittenToList = true;
1831	uiOneBitstreamPerSliceLength += nalu.m_Bitstream.getNumberOfWrittenBits(); // length of bitstream after byte-alignment
1832
1833	if (!bNALUAlignedWrittenToList)
1834	{
1835	{
1836	nalu.m_Bitstream.writeAlignZero();
1837	}
1838	accessUnit.push_back(new NALUnitEBSP(nalu));
1839	uiOneBitstreamPerSliceLength += nalu.m_Bitstream.getNumberOfWrittenBits() + 24; // length of bitstream after byte-alignment + 3 byte startcode 0x000001
1840	}
1841
1842	if( ( m_pcCfg->getPictureTimingSEIEnabled() \|\| m_pcCfg->getDecodingUnitInfoSEIEnabled() ) &&
1843	( pcSlice->getSPS()->getVuiParametersPresentFlag() ) &&
1844	( ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNalHrdParametersPresentFlag() )
1845	\|\| ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getVclHrdParametersPresentFlag() ) ) &&
1846	( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getSubPicCpbParamsPresentFlag() ) )
1847	{
1848	UInt numNalus = 0;
1849	UInt numRBSPBytes = 0;
1850	for (AccessUnit::const_iterator it = accessUnit.begin(); it != accessUnit.end(); it++)
1851	{
1852	UInt numRBSPBytes_nal = UInt((*it)->m_nalUnitData.str().size());
1853	if ((it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI)
1854	{
1855	numRBSPBytes += numRBSPBytes_nal;
1856	numNalus ++;
1857	}
1858	}
1859	accumBitsDU[ pcSlice->getSliceIdx() ] = ( numRBSPBytes << 3 );
1860	accumNalsDU[ pcSlice->getSliceIdx() ] = numNalus; // SEI not counted for bit count; hence shouldn't be counted for # of NALUs - only for consistency
1861	}
1862	processingState = ENCODE_SLICE;
1863	}
1864	break;
1865	case EXECUTE_INLOOPFILTER:
1866	{
1867	// set entropy coder for RD
1868	m_pcEntropyCoder->setEntropyCoder ( m_pcSbacCoder, pcSlice );
1869	if ( pcSlice->getSPS()->getUseSAO() )
1870	{
1871	m_pcEntropyCoder->resetEntropy();
1872	m_pcEntropyCoder->setBitstream( m_pcBitCounter );
1873	m_pcSAO->startSaoEnc(pcPic, m_pcEntropyCoder, m_pcEncTop->getRDSbacCoder(), m_pcEncTop->getRDGoOnSbacCoder());
1874	SAOParam& cSaoParam = *pcSlice->getPic()->getPicSym()->getSaoParam();
1875
1876	#if SAO_CHROMA_LAMBDA
1877	#if SAO_ENCODING_CHOICE
1878	m_pcSAO->SAOProcess(&cSaoParam, pcPic->getSlice(0)->getLambdaLuma(), pcPic->getSlice(0)->getLambdaChroma(), pcPic->getSlice(0)->getDepth());
1879	#else
1880	m_pcSAO->SAOProcess(&cSaoParam, pcPic->getSlice(0)->getLambdaLuma(), pcPic->getSlice(0)->getLambdaChroma());
1881	#endif
1882	#else
1883	m_pcSAO->SAOProcess(&cSaoParam, pcPic->getSlice(0)->getLambda());
1884	#endif
1885	m_pcSAO->endSaoEnc();
1886	m_pcSAO->PCMLFDisableProcess(pcPic);
1887	}
1888	#if SAO_RDO
1889	m_pcEntropyCoder->setEntropyCoder ( m_pcCavlcCoder, pcSlice );
1890	#endif
1891	processingState = ENCODE_SLICE;
1892
1893	for(Int s=0; s< uiNumSlices; s++)
1894	{
1895	if (pcSlice->getSPS()->getUseSAO())
1896	{
1897	pcPic->getSlice(s)->setSaoEnabledFlag((pcSlice->getPic()->getPicSym()->getSaoParam()->bSaoFlag[0]==1)?true:false);
1898	}
1899	}
1900	}
1901	break;
1902	default:
1903	{
1904	printf("Not a supported encoding state\n");
1905	assert(0);
1906	exit(-1);
1907	}
1908	}
1909	} // end iteration over slices
1910
1911	if(pcSlice->getSPS()->getUseSAO())
1912	{
1913	if(pcSlice->getSPS()->getUseSAO())
1914	{
1915	m_pcSAO->destroyPicSaoInfo();
1916	}
1917	pcPic->destroyNonDBFilterInfo();
1918	}
1919
1920	pcPic->compressMotion();
1921
1922	//-- For time output for each slice
1923	Double dEncTime = (Double)(clock()-iBeforeTime) / CLOCKS_PER_SEC;
1924
1925	const Char* digestStr = NULL;
1926	if (m_pcCfg->getDecodedPictureHashSEIEnabled())
1927	{
1928	/* calculate MD5sum for entire reconstructed picture */
1929	SEIDecodedPictureHash sei_recon_picture_digest;
1930	if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 1)
1931	{
1932	sei_recon_picture_digest.method = SEIDecodedPictureHash::MD5;
1933	calcMD5(*pcPic->getPicYuvRec(), sei_recon_picture_digest.digest);
1934	digestStr = digestToString(sei_recon_picture_digest.digest, 16);
1935	}
1936	else if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 2)
1937	{
1938	sei_recon_picture_digest.method = SEIDecodedPictureHash::CRC;
1939	calcCRC(*pcPic->getPicYuvRec(), sei_recon_picture_digest.digest);
1940	digestStr = digestToString(sei_recon_picture_digest.digest, 2);
1941	}
1942	else if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 3)
1943	{
1944	sei_recon_picture_digest.method = SEIDecodedPictureHash::CHECKSUM;
1945	calcChecksum(*pcPic->getPicYuvRec(), sei_recon_picture_digest.digest);
1946	digestStr = digestToString(sei_recon_picture_digest.digest, 4);
1947	}
1948	#if SVC_EXTENSION
1949	OutputNALUnit nalu(NAL_UNIT_SUFFIX_SEI, pcSlice->getTLayer(), m_layerId);
1950	#else
1951	OutputNALUnit nalu(NAL_UNIT_SUFFIX_SEI, pcSlice->getTLayer());
1952	#endif
1953
1954	/* write the SEI messages */
1955	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
1956	m_seiWriter.writeSEImessage(nalu.m_Bitstream, sei_recon_picture_digest, pcSlice->getSPS());
1957	writeRBSPTrailingBits(nalu.m_Bitstream);
1958
1959	accessUnit.insert(accessUnit.end(), new NALUnitEBSP(nalu));
1960	}
1961	if (m_pcCfg->getTemporalLevel0IndexSEIEnabled())
1962	{
1963	SEITemporalLevel0Index sei_temporal_level0_index;
1964	if (pcSlice->getRapPicFlag())
1965	{
1966	m_tl0Idx = 0;
1967	m_rapIdx = (m_rapIdx + 1) & 0xFF;
1968	}
1969	else
1970	{
1971	m_tl0Idx = (m_tl0Idx + (pcSlice->getTLayer() ? 0 : 1)) & 0xFF;
1972	}
1973	sei_temporal_level0_index.tl0Idx = m_tl0Idx;
1974	sei_temporal_level0_index.rapIdx = m_rapIdx;
1975
1976	OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
1977
1978	/* write the SEI messages */
1979	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
1980	m_seiWriter.writeSEImessage(nalu.m_Bitstream, sei_temporal_level0_index, pcSlice->getSPS());
1981	writeRBSPTrailingBits(nalu.m_Bitstream);
1982
1983	/* insert the SEI message NALUnit before any Slice NALUnits */
1984	AccessUnit::iterator it = find_if(accessUnit.begin(), accessUnit.end(), mem_fun(&NALUnit::isSlice));
1985	accessUnit.insert(it, new NALUnitEBSP(nalu));
1986	}
1987
1988	xCalculateAddPSNR( pcPic, pcPic->getPicYuvRec(), accessUnit, dEncTime );
1989
1990	if (digestStr)
1991	{
1992	if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 1)
1993	{
1994	printf(" [MD5:%s]", digestStr);
1995	}
1996	else if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 2)
1997	{
1998	printf(" [CRC:%s]", digestStr);
1999	}
2000	else if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 3)
2001	{
2002	printf(" [Checksum:%s]", digestStr);
2003	}
2004	}
2005	#if RATE_CONTROL_LAMBDA_DOMAIN
2006	if ( m_pcCfg->getUseRateCtrl() )
2007	{
2008	Double effectivePercentage = m_pcRateCtrl->getRCPic()->getEffectivePercentage();
2009	Double avgQP = m_pcRateCtrl->getRCPic()->calAverageQP();
2010	Double avgLambda = m_pcRateCtrl->getRCPic()->calAverageLambda();
2011	if ( avgLambda < 0.0 )
2012	{
2013	avgLambda = lambda;
2014	}
2015	m_pcRateCtrl->getRCPic()->updateAfterPicture( actualHeadBits, actualTotalBits, avgQP, avgLambda, effectivePercentage );
2016	m_pcRateCtrl->getRCPic()->addToPictureLsit( m_pcRateCtrl->getPicList() );
2017
2018	m_pcRateCtrl->getRCSeq()->updateAfterPic( actualTotalBits );
2019	if ( pcSlice->getSliceType() != I_SLICE )
2020	{
2021	m_pcRateCtrl->getRCGOP()->updateAfterPicture( actualTotalBits );
2022	}
2023	else // for intra picture, the estimated bits are used to update the current status in the GOP
2024	{
2025	m_pcRateCtrl->getRCGOP()->updateAfterPicture( estimatedBits );
2026	}
2027	}
2028	#else
2029	if(m_pcCfg->getUseRateCtrl())
2030	{
2031	UInt frameBits = m_vRVM_RP[m_vRVM_RP.size()-1];
2032	m_pcRateCtrl->updataRCFrameStatus((Int)frameBits, pcSlice->getSliceType());
2033	}
2034	#endif
2035	if( ( m_pcCfg->getPictureTimingSEIEnabled() \|\| m_pcCfg->getDecodingUnitInfoSEIEnabled() ) &&
2036	( pcSlice->getSPS()->getVuiParametersPresentFlag() ) &&
2037	( ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNalHrdParametersPresentFlag() )
2038	\|\| ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getVclHrdParametersPresentFlag() ) ) )
2039	{
2040	TComVUI *vui = pcSlice->getSPS()->getVuiParameters();
2041	TComHRD *hrd = vui->getHrdParameters();
2042
2043	if( hrd->getSubPicCpbParamsPresentFlag() )
2044	{
2045	Int i;
2046	UInt64 ui64Tmp;
2047	UInt uiPrev = 0;
2048	UInt numDU = ( pictureTimingSEI.m_numDecodingUnitsMinus1 + 1 );
2049	UInt *pCRD = &pictureTimingSEI.m_duCpbRemovalDelayMinus1[0];
2050	UInt maxDiff = ( hrd->getTickDivisorMinus2() + 2 ) - 1;
2051
2052	for( i = 0; i < numDU; i ++ )
2053	{
2054	pictureTimingSEI.m_numNalusInDuMinus1[ i ] = ( i == 0 ) ? ( accumNalsDU[ i ] - 1 ) : ( accumNalsDU[ i ] - accumNalsDU[ i - 1] - 1 );
2055	}
2056
2057	if( numDU == 1 )
2058	{
2059	pCRD[ 0 ] = 0; /* don't care */
2060	}
2061	else
2062	{
2063	pCRD[ numDU - 1 ] = 0;/* by definition */
2064	UInt tmp = 0;
2065	UInt accum = 0;
2066
2067	for( i = ( numDU - 2 ); i >= 0; i -- )
2068	{
2069	#if L0043_TIMING_INFO
2070	ui64Tmp = ( ( ( accumBitsDU[ numDU - 1 ] - accumBitsDU[ i ] ) * ( vui->getTimingInfo()->getTimeScale() / vui->getTimingInfo()->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
2071	#else
2072	ui64Tmp = ( ( ( accumBitsDU[ numDU - 1 ] - accumBitsDU[ i ] ) * ( hrd->getTimeScale() / hrd->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
2073	#endif
2074	if( (UInt)ui64Tmp > maxDiff )
2075	{
2076	tmp ++;
2077	}
2078	}
2079	uiPrev = 0;
2080
2081	UInt flag = 0;
2082	for( i = ( numDU - 2 ); i >= 0; i -- )
2083	{
2084	flag = 0;
2085	#if L0043_TIMING_INFO
2086	ui64Tmp = ( ( ( accumBitsDU[ numDU - 1 ] - accumBitsDU[ i ] ) * ( vui->getTimingInfo()->getTimeScale() / vui->getTimingInfo()->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
2087	#else
2088	ui64Tmp = ( ( ( accumBitsDU[ numDU - 1 ] - accumBitsDU[ i ] ) * ( hrd->getTimeScale() / hrd->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
2089	#endif
2090
2091	if( (UInt)ui64Tmp > maxDiff )
2092	{
2093	if(uiPrev >= maxDiff - tmp)
2094	{
2095	ui64Tmp = uiPrev + 1;
2096	flag = 1;
2097	}
2098	else ui64Tmp = maxDiff - tmp + 1;
2099	}
2100	pCRD[ i ] = (UInt)ui64Tmp - uiPrev - 1;
2101	if( (Int)pCRD[ i ] < 0 )
2102	{
2103	pCRD[ i ] = 0;
2104	}
2105	else if (tmp > 0 && flag == 1)
2106	{
2107	tmp --;
2108	}
2109	accum += pCRD[ i ] + 1;
2110	uiPrev = accum;
2111	}
2112	}
2113	}
2114	if( m_pcCfg->getPictureTimingSEIEnabled() )
2115	{
2116	{
2117	OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, pcSlice->getTLayer());
2118	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
2119	m_seiWriter.writeSEImessage(nalu.m_Bitstream, pictureTimingSEI, pcSlice->getSPS());
2120	writeRBSPTrailingBits(nalu.m_Bitstream);
2121	#if L0045_NON_NESTED_SEI_RESTRICTIONS
2122	UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
2123	UInt offsetPosition = m_activeParameterSetSEIPresentInAU
2124	+ m_bufferingPeriodSEIPresentInAU; // Insert PT SEI after APS and BP SEI
2125	AccessUnit::iterator it;
2126	for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
2127	{
2128	it++;
2129	}
2130	accessUnit.insert(it, new NALUnitEBSP(nalu));
2131	m_pictureTimingSEIPresentInAU = true;
2132	#else
2133	AccessUnit::iterator it = find_if(accessUnit.begin(), accessUnit.end(), mem_fun(&NALUnit::isSlice));
2134	accessUnit.insert(it, new NALUnitEBSP(nalu));
2135	#endif
2136	}
2137	#if K0180_SCALABLE_NESTING_SEI
2138	if ( m_pcCfg->getScalableNestingSEIEnabled() ) // put picture timing SEI into scalable nesting SEI
2139	{
2140	OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, pcSlice->getTLayer());
2141	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
2142	scalableNestingSEI.m_nestedSEIs.clear();
2143	scalableNestingSEI.m_nestedSEIs.push_back(&pictureTimingSEI);
2144	m_seiWriter.writeSEImessage(nalu.m_Bitstream, scalableNestingSEI, pcSlice->getSPS());
2145	writeRBSPTrailingBits(nalu.m_Bitstream);
2146	#if L0045_NON_NESTED_SEI_RESTRICTIONS
2147	UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
2148	UInt offsetPosition = m_activeParameterSetSEIPresentInAU
2149	+ m_bufferingPeriodSEIPresentInAU + m_pictureTimingSEIPresentInAU + m_nestedBufferingPeriodSEIPresentInAU; // Insert PT SEI after APS and BP SEI
2150	AccessUnit::iterator it;
2151	for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
2152	{
2153	it++;
2154	}
2155	accessUnit.insert(it, new NALUnitEBSP(nalu));
2156	m_nestedPictureTimingSEIPresentInAU = true;
2157	#else
2158	AccessUnit::iterator it = find_if(accessUnit.begin(), accessUnit.end(), mem_fun(&NALUnit::isSlice));
2159	accessUnit.insert(it, new NALUnitEBSP(nalu));
2160	#endif
2161	}
2162	#endif
2163
2164	}
2165	if( m_pcCfg->getDecodingUnitInfoSEIEnabled() && hrd->getSubPicCpbParamsPresentFlag() )
2166	{
2167	m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
2168	for( Int i = 0; i < ( pictureTimingSEI.m_numDecodingUnitsMinus1 + 1 ); i ++ )
2169	{
2170	OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, pcSlice->getTLayer());
2171
2172	SEIDecodingUnitInfo tempSEI;
2173	tempSEI.m_decodingUnitIdx = i;
2174	tempSEI.m_duSptCpbRemovalDelay = pictureTimingSEI.m_duCpbRemovalDelayMinus1[i] + 1;
2175	#if L0044_DU_DPB_OUTPUT_DELAY_HRD
2176	tempSEI.m_dpbOutputDuDelayPresentFlag = false;
2177	tempSEI.m_picSptDpbOutputDuDelay = picSptDpbOutputDuDelay;
2178	#endif
2179
2180	AccessUnit::iterator it;
2181	// Insert the first one in the right location, before the first slice
2182	if(i == 0)
2183	{
2184	// Insert before the first slice.
2185	m_seiWriter.writeSEImessage(nalu.m_Bitstream, tempSEI, pcSlice->getSPS());
2186	writeRBSPTrailingBits(nalu.m_Bitstream);
2187
2188	#if L0045_NON_NESTED_SEI_RESTRICTIONS
2189	UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
2190	UInt offsetPosition = m_activeParameterSetSEIPresentInAU
2191	+ m_bufferingPeriodSEIPresentInAU
2192	+ m_pictureTimingSEIPresentInAU; // Insert DU info SEI after APS, BP and PT SEI
2193	for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
2194	{
2195	it++;
2196	}
2197	accessUnit.insert(it, new NALUnitEBSP(nalu));
2198	#else
2199	it = find_if(accessUnit.begin(), accessUnit.end(), mem_fun(&NALUnit::isSlice));
2200	accessUnit.insert(it, new NALUnitEBSP(nalu));
2201	#endif
2202	}
2203	else
2204	{
2205	Int ctr;
2206	// For the second decoding unit onwards we know how many NALUs are present
2207	for (ctr = 0, it = accessUnit.begin(); it != accessUnit.end(); it++)
2208	{
2209	if(ctr == accumNalsDU[ i - 1 ])
2210	{
2211	// Insert before the first slice.
2212	m_seiWriter.writeSEImessage(nalu.m_Bitstream, tempSEI, pcSlice->getSPS());
2213	writeRBSPTrailingBits(nalu.m_Bitstream);
2214
2215	accessUnit.insert(it, new NALUnitEBSP(nalu));
2216	break;
2217	}
2218	if ((it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI)
2219	{
2220	ctr++;
2221	}
2222	}
2223	}
2224	}
2225	}
2226	}
2227	#if L0045_NON_NESTED_SEI_RESTRICTIONS
2228	xResetNonNestedSEIPresentFlags();
2229	#if K0180_SCALABLE_NESTING_SEI
2230	xResetNestedSEIPresentFlags();
2231	#endif
2232	#endif
2233	pcPic->getPicYuvRec()->copyToPic(pcPicYuvRecOut);
2234
2235	pcPic->setReconMark ( true );
2236	m_bFirst = false;
2237	m_iNumPicCoded++;
2238	m_totalCoded ++;
2239	/* logging: insert a newline at end of picture period */
2240	printf("\n");
2241	fflush(stdout);
2242
2243	delete[] pcSubstreamsOut;
2244	}
2245	#if !RATE_CONTROL_LAMBDA_DOMAIN
2246	if(m_pcCfg->getUseRateCtrl())
2247	{
2248	m_pcRateCtrl->updateRCGOPStatus();
2249	}
2250	#endif
2251	delete pcBitstreamRedirect;
2252
2253	if( accumBitsDU != NULL) delete accumBitsDU;
2254	if( accumNalsDU != NULL) delete accumNalsDU;
2255
2256	#if SVC_EXTENSION
2257	assert ( m_iNumPicCoded <= 1 );
2258	#else
2259	assert ( m_iNumPicCoded == iNumPicRcvd );
2260	#endif
2261	}
2262
2263	#if !SVC_EXTENSION
2264	Void TEncGOP::printOutSummary(UInt uiNumAllPicCoded)
2265	{
2266	assert (uiNumAllPicCoded == m_gcAnalyzeAll.getNumPic());
2267
2268
2269	//--CFG_KDY
2270	m_gcAnalyzeAll.setFrmRate( m_pcCfg->getFrameRate() );
2271	m_gcAnalyzeI.setFrmRate( m_pcCfg->getFrameRate() );
2272	m_gcAnalyzeP.setFrmRate( m_pcCfg->getFrameRate() );
2273	m_gcAnalyzeB.setFrmRate( m_pcCfg->getFrameRate() );
2274
2275	//-- all
2276	printf( "\n\nSUMMARY --------------------------------------------------------\n" );
2277	m_gcAnalyzeAll.printOut('a');
2278
2279	printf( "\n\nI Slices--------------------------------------------------------\n" );
2280	m_gcAnalyzeI.printOut('i');
2281
2282	printf( "\n\nP Slices--------------------------------------------------------\n" );
2283	m_gcAnalyzeP.printOut('p');
2284
2285	printf( "\n\nB Slices--------------------------------------------------------\n" );
2286	m_gcAnalyzeB.printOut('b');
2287
2288	#if _SUMMARY_OUT_
2289	m_gcAnalyzeAll.printSummaryOut();
2290	#endif
2291	#if _SUMMARY_PIC_
2292	m_gcAnalyzeI.printSummary('I');
2293	m_gcAnalyzeP.printSummary('P');
2294	m_gcAnalyzeB.printSummary('B');
2295	#endif
2296
2297	printf("\nRVM: %.3lf\n" , xCalculateRVM());
2298	}
2299	#endif
2300
2301	Void TEncGOP::preLoopFilterPicAll( TComPic* pcPic, UInt64& ruiDist, UInt64& ruiBits )
2302	{
2303	TComSlice* pcSlice = pcPic->getSlice(pcPic->getCurrSliceIdx());
2304	Bool bCalcDist = false;
2305	m_pcLoopFilter->setCfg(m_pcCfg->getLFCrossTileBoundaryFlag());
2306	m_pcLoopFilter->loopFilterPic( pcPic );
2307
2308	m_pcEntropyCoder->setEntropyCoder ( m_pcEncTop->getRDGoOnSbacCoder(), pcSlice );
2309	m_pcEntropyCoder->resetEntropy ();
2310	m_pcEntropyCoder->setBitstream ( m_pcBitCounter );
2311	pcSlice = pcPic->getSlice(0);
2312	if(pcSlice->getSPS()->getUseSAO())
2313	{
2314	std::vector<Bool> LFCrossSliceBoundaryFlag(1, true);
2315	std::vector<Int> sliceStartAddress;
2316	sliceStartAddress.push_back(0);
2317	sliceStartAddress.push_back(pcPic->getNumCUsInFrame()* pcPic->getNumPartInCU());
2318	pcPic->createNonDBFilterInfo(sliceStartAddress, 0, &LFCrossSliceBoundaryFlag);
2319	}
2320
2321	if( pcSlice->getSPS()->getUseSAO())
2322	{
2323	pcPic->destroyNonDBFilterInfo();
2324	}
2325
2326	m_pcEntropyCoder->resetEntropy ();
2327	ruiBits += m_pcEntropyCoder->getNumberOfWrittenBits();
2328
2329	if (!bCalcDist)
2330	ruiDist = xFindDistortionFrame(pcPic->getPicYuvOrg(), pcPic->getPicYuvRec());
2331	}
2332
2333	// ====================================================================================================================
2334	// Protected member functions
2335	// ====================================================================================================================
2336
2337	Void TEncGOP::xInitGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic>& rcListPic, TComList<TComPicYuv>& rcListPicYuvRecOut )
2338	{
2339	assert( iNumPicRcvd > 0 );
2340	// Exception for the first frame
2341	if ( iPOCLast == 0 )
2342	{
2343	m_iGopSize = 1;
2344	}
2345	else
2346	m_iGopSize = m_pcCfg->getGOPSize();
2347
2348	assert (m_iGopSize > 0);
2349
2350	return;
2351	}
2352
2353	Void TEncGOP::xGetBuffer( TComList<TComPic*>& rcListPic,
2354	TComList<TComPicYuv*>& rcListPicYuvRecOut,
2355	Int iNumPicRcvd,
2356	Int iTimeOffset,
2357	TComPic*& rpcPic,
2358	TComPicYuv*& rpcPicYuvRecOut,
2359	Int pocCurr )
2360	{
2361	Int i;
2362	// Rec. output
2363	TComList<TComPicYuv*>::iterator iterPicYuvRec = rcListPicYuvRecOut.end();
2364	for ( i = 0; i < iNumPicRcvd - iTimeOffset + 1; i++ )
2365	{
2366	iterPicYuvRec--;
2367	}
2368
2369	rpcPicYuvRecOut = *(iterPicYuvRec);
2370
2371	// Current pic.
2372	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
2373	while (iterPic != rcListPic.end())
2374	{
2375	rpcPic = *(iterPic);
2376	rpcPic->setCurrSliceIdx(0);
2377	if (rpcPic->getPOC() == pocCurr)
2378	{
2379	break;
2380	}
2381	iterPic++;
2382	}
2383
2384	assert (rpcPic->getPOC() == pocCurr);
2385
2386	return;
2387	}
2388
2389	UInt64 TEncGOP::xFindDistortionFrame (TComPicYuv* pcPic0, TComPicYuv* pcPic1)
2390	{
2391	Int x, y;
2392	Pel* pSrc0 = pcPic0 ->getLumaAddr();
2393	Pel* pSrc1 = pcPic1 ->getLumaAddr();
2394	UInt uiShift = 2 * DISTORTION_PRECISION_ADJUSTMENT(g_bitDepthY-8);
2395	Int iTemp;
2396
2397	Int iStride = pcPic0->getStride();
2398	Int iWidth = pcPic0->getWidth();
2399	Int iHeight = pcPic0->getHeight();
2400
2401	UInt64 uiTotalDiff = 0;
2402
2403	for( y = 0; y < iHeight; y++ )
2404	{
2405	for( x = 0; x < iWidth; x++ )
2406	{
2407	iTemp = pSrc0[x] - pSrc1[x]; uiTotalDiff += (iTemp*iTemp) >> uiShift;
2408	}
2409	pSrc0 += iStride;
2410	pSrc1 += iStride;
2411	}
2412
2413	uiShift = 2 * DISTORTION_PRECISION_ADJUSTMENT(g_bitDepthC-8);
2414	iHeight >>= 1;
2415	iWidth >>= 1;
2416	iStride >>= 1;
2417
2418	pSrc0 = pcPic0->getCbAddr();
2419	pSrc1 = pcPic1->getCbAddr();
2420
2421	for( y = 0; y < iHeight; y++ )
2422	{
2423	for( x = 0; x < iWidth; x++ )
2424	{
2425	iTemp = pSrc0[x] - pSrc1[x]; uiTotalDiff += (iTemp*iTemp) >> uiShift;
2426	}
2427	pSrc0 += iStride;
2428	pSrc1 += iStride;
2429	}
2430
2431	pSrc0 = pcPic0->getCrAddr();
2432	pSrc1 = pcPic1->getCrAddr();
2433
2434	for( y = 0; y < iHeight; y++ )
2435	{
2436	for( x = 0; x < iWidth; x++ )
2437	{
2438	iTemp = pSrc0[x] - pSrc1[x]; uiTotalDiff += (iTemp*iTemp) >> uiShift;
2439	}
2440	pSrc0 += iStride;
2441	pSrc1 += iStride;
2442	}
2443
2444	return uiTotalDiff;
2445	}
2446
2447	#if VERBOSE_RATE
2448	static const Char* nalUnitTypeToString(NalUnitType type)
2449	{
2450	switch (type)
2451	{
2452	case NAL_UNIT_CODED_SLICE_TRAIL_R: return "TRAIL_R";
2453	case NAL_UNIT_CODED_SLICE_TRAIL_N: return "TRAIL_N";
2454	case NAL_UNIT_CODED_SLICE_TLA_R: return "TLA_R";
2455	case NAL_UNIT_CODED_SLICE_TSA_N: return "TSA_N";
2456	case NAL_UNIT_CODED_SLICE_STSA_R: return "STSA_R";
2457	case NAL_UNIT_CODED_SLICE_STSA_N: return "STSA_N";
2458	case NAL_UNIT_CODED_SLICE_BLA_W_LP: return "BLA_W_LP";
2459	case NAL_UNIT_CODED_SLICE_BLA_W_RADL: return "BLA_W_RADL";
2460	case NAL_UNIT_CODED_SLICE_BLA_N_LP: return "BLA_N_LP";
2461	case NAL_UNIT_CODED_SLICE_IDR_W_RADL: return "IDR_W_RADL";
2462	case NAL_UNIT_CODED_SLICE_IDR_N_LP: return "IDR_N_LP";
2463	case NAL_UNIT_CODED_SLICE_CRA: return "CRA";
2464	case NAL_UNIT_CODED_SLICE_RADL_R: return "RADL_R";
2465	case NAL_UNIT_CODED_SLICE_RASL_R: return "RASL_R";
2466	case NAL_UNIT_VPS: return "VPS";
2467	case NAL_UNIT_SPS: return "SPS";
2468	case NAL_UNIT_PPS: return "PPS";
2469	case NAL_UNIT_ACCESS_UNIT_DELIMITER: return "AUD";
2470	case NAL_UNIT_EOS: return "EOS";
2471	case NAL_UNIT_EOB: return "EOB";
2472	case NAL_UNIT_FILLER_DATA: return "FILLER";
2473	case NAL_UNIT_PREFIX_SEI: return "SEI";
2474	case NAL_UNIT_SUFFIX_SEI: return "SEI";
2475	default: return "UNK";
2476	}
2477	}
2478	#endif
2479
2480	Void TEncGOP::xCalculateAddPSNR( TComPic* pcPic, TComPicYuv* pcPicD, const AccessUnit& accessUnit, Double dEncTime )
2481	{
2482	Int x, y;
2483	UInt64 uiSSDY = 0;
2484	UInt64 uiSSDU = 0;
2485	UInt64 uiSSDV = 0;
2486
2487	Double dYPSNR = 0.0;
2488	Double dUPSNR = 0.0;
2489	Double dVPSNR = 0.0;
2490
2491	//===== calculate PSNR =====
2492	Pel* pOrg = pcPic ->getPicYuvOrg()->getLumaAddr();
2493	Pel* pRec = pcPicD->getLumaAddr();
2494	Int iStride = pcPicD->getStride();
2495
2496	Int iWidth;
2497	Int iHeight;
2498
2499	iWidth = pcPicD->getWidth () - m_pcEncTop->getPad(0);
2500	iHeight = pcPicD->getHeight() - m_pcEncTop->getPad(1);
2501
2502	Int iSize = iWidth*iHeight;
2503
2504	for( y = 0; y < iHeight; y++ )
2505	{
2506	for( x = 0; x < iWidth; x++ )
2507	{
2508	Int iDiff = (Int)( pOrg[x] - pRec[x] );
2509	uiSSDY += iDiff * iDiff;
2510	}
2511	pOrg += iStride;
2512	pRec += iStride;
2513	}
2514
2515	iHeight >>= 1;
2516	iWidth >>= 1;
2517	iStride >>= 1;
2518	pOrg = pcPic ->getPicYuvOrg()->getCbAddr();
2519	pRec = pcPicD->getCbAddr();
2520
2521	for( y = 0; y < iHeight; y++ )
2522	{
2523	for( x = 0; x < iWidth; x++ )
2524	{
2525	Int iDiff = (Int)( pOrg[x] - pRec[x] );
2526	uiSSDU += iDiff * iDiff;
2527	}
2528	pOrg += iStride;
2529	pRec += iStride;
2530	}
2531
2532	pOrg = pcPic ->getPicYuvOrg()->getCrAddr();
2533	pRec = pcPicD->getCrAddr();
2534
2535	for( y = 0; y < iHeight; y++ )
2536	{
2537	for( x = 0; x < iWidth; x++ )
2538	{
2539	Int iDiff = (Int)( pOrg[x] - pRec[x] );
2540	uiSSDV += iDiff * iDiff;
2541	}
2542	pOrg += iStride;
2543	pRec += iStride;
2544	}
2545
2546	Int maxvalY = 255 << (g_bitDepthY-8);
2547	Int maxvalC = 255 << (g_bitDepthC-8);
2548	Double fRefValueY = (Double) maxvalY * maxvalY * iSize;
2549	Double fRefValueC = (Double) maxvalC * maxvalC * iSize / 4.0;
2550	dYPSNR = ( uiSSDY ? 10.0 * log10( fRefValueY / (Double)uiSSDY ) : 99.99 );
2551	dUPSNR = ( uiSSDU ? 10.0 * log10( fRefValueC / (Double)uiSSDU ) : 99.99 );
2552	dVPSNR = ( uiSSDV ? 10.0 * log10( fRefValueC / (Double)uiSSDV ) : 99.99 );
2553
2554	/* calculate the size of the access unit, excluding:
2555	* - any AnnexB contributions (start_code_prefix, zero_byte, etc.,)
2556	* - SEI NAL units
2557	*/
2558	UInt numRBSPBytes = 0;
2559	for (AccessUnit::const_iterator it = accessUnit.begin(); it != accessUnit.end(); it++)
2560	{
2561	UInt numRBSPBytes_nal = UInt((*it)->m_nalUnitData.str().size());
2562	#if VERBOSE_RATE
2563	printf("*** %6s numBytesInNALunit: %u\n", nalUnitTypeToString((*it)->m_nalUnitType), numRBSPBytes_nal);
2564	#endif
2565	if ((it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI)
2566	{
2567	numRBSPBytes += numRBSPBytes_nal;
2568	}
2569	}
2570
2571	UInt uibits = numRBSPBytes * 8;
2572	m_vRVM_RP.push_back( uibits );
2573
2574	//===== add PSNR =====
2575	#if SVC_EXTENSION
2576	m_gcAnalyzeAll[m_layerId].addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
2577	TComSlice* pcSlice = pcPic->getSlice(0);
2578	if (pcSlice->isIntra())
2579	{
2580	m_gcAnalyzeI[m_layerId].addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
2581	}
2582	if (pcSlice->isInterP())
2583	{
2584	m_gcAnalyzeP[m_layerId].addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
2585	}
2586	if (pcSlice->isInterB())
2587	{
2588	m_gcAnalyzeB[m_layerId].addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
2589	}
2590	#else
2591	m_gcAnalyzeAll.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
2592	TComSlice* pcSlice = pcPic->getSlice(0);
2593	if (pcSlice->isIntra())
2594	{
2595	m_gcAnalyzeI.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
2596	}
2597	if (pcSlice->isInterP())
2598	{
2599	m_gcAnalyzeP.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
2600	}
2601	if (pcSlice->isInterB())
2602	{
2603	m_gcAnalyzeB.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
2604	}
2605	#endif
2606
2607	Char c = (pcSlice->isIntra() ? 'I' : pcSlice->isInterP() ? 'P' : 'B');
2608	if (!pcSlice->isReferenced()) c += 32;
2609
2610	#if SVC_EXTENSION
2611	#if ADAPTIVE_QP_SELECTION
2612	printf("POC %4d LId: %1d TId: %1d ( %c-SLICE, nQP %d QP %d ) %10d bits",
2613	pcSlice->getPOC(),
2614	pcSlice->getLayerId(),
2615	pcSlice->getTLayer(),
2616	c,
2617	pcSlice->getSliceQpBase(),
2618	pcSlice->getSliceQp(),
2619	uibits );
2620	#else
2621	printf("POC %4d LId: %1d TId: %1d ( %c-SLICE, QP %d ) %10d bits",
2622	pcSlice->getPOC()-pcSlice->getLastIDR(),
2623	pcSlice->getLayerId(),
2624	pcSlice->getTLayer(),
2625	c,
2626	pcSlice->getSliceQp(),
2627	uibits );
2628	#endif
2629	#else
2630	#if ADAPTIVE_QP_SELECTION
2631	printf("POC %4d TId: %1d ( %c-SLICE, nQP %d QP %d ) %10d bits",
2632	pcSlice->getPOC(),
2633	pcSlice->getTLayer(),
2634	c,
2635	pcSlice->getSliceQpBase(),
2636	pcSlice->getSliceQp(),
2637	uibits );
2638	#else
2639	printf("POC %4d TId: %1d ( %c-SLICE, QP %d ) %10d bits",
2640	pcSlice->getPOC()-pcSlice->getLastIDR(),
2641	pcSlice->getTLayer(),
2642	c,
2643	pcSlice->getSliceQp(),
2644	uibits );
2645	#endif
2646	#endif
2647
2648	printf(" [Y %6.4lf dB U %6.4lf dB V %6.4lf dB]", dYPSNR, dUPSNR, dVPSNR );
2649	printf(" [ET %5.0f ]", dEncTime );
2650
2651	for (Int iRefList = 0; iRefList < 2; iRefList++)
2652	{
2653	printf(" [L%d ", iRefList);
2654	for (Int iRefIndex = 0; iRefIndex < pcSlice->getNumRefIdx(RefPicList(iRefList)); iRefIndex++)
2655	{
2656	#if REF_IDX_FRAMEWORK && VPS_EXTN_DIRECT_REF_LAYERS
2657	if( pcSlice->getRefPic(RefPicList(iRefList), iRefIndex)->isILR(m_layerId) )
2658	{
2659	printf( "%d(%d) ", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex)-pcSlice->getLastIDR(), pcSlice->getRefPic(RefPicList(iRefList), iRefIndex)->getLayerId() );
2660	}
2661	else
2662	#endif
2663	printf ("%d ", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex)-pcSlice->getLastIDR());
2664	}
2665	printf("]");
2666	}
2667	}
2668
2669	/** Function for deciding the nal_unit_type.
2670	* \param pocCurr POC of the current picture
2671	* \returns the nal unit type of the picture
2672	* This function checks the configuration and returns the appropriate nal_unit_type for the picture.
2673	*/
2674	NalUnitType TEncGOP::getNalUnitType(Int pocCurr, Int lastIDR)
2675	{
2676	if (pocCurr == 0)
2677	{
2678	return NAL_UNIT_CODED_SLICE_IDR_W_RADL;
2679	}
2680	if (pocCurr % m_pcCfg->getIntraPeriod() == 0)
2681	{
2682	if (m_pcCfg->getDecodingRefreshType() == 1)
2683	{
2684	return NAL_UNIT_CODED_SLICE_CRA;
2685	}
2686	else if (m_pcCfg->getDecodingRefreshType() == 2)
2687	{
2688	return NAL_UNIT_CODED_SLICE_IDR_W_RADL;
2689	}
2690	}
2691	if(m_pocCRA>0)
2692	{
2693	if(pocCurr<m_pocCRA)
2694	{
2695	// All leading pictures are being marked as TFD pictures here since current encoder uses all
2696	// reference pictures while encoding leading pictures. An encoder can ensure that a leading
2697	// picture can be still decodable when random accessing to a CRA/CRANT/BLA/BLANT picture by
2698	// controlling the reference pictures used for encoding that leading picture. Such a leading
2699	// picture need not be marked as a TFD picture.
2700	return NAL_UNIT_CODED_SLICE_RASL_R;
2701	}
2702	}
2703	if (lastIDR>0)
2704	{
2705	if (pocCurr < lastIDR)
2706	{
2707	return NAL_UNIT_CODED_SLICE_RADL_R;
2708	}
2709	}
2710	return NAL_UNIT_CODED_SLICE_TRAIL_R;
2711	}
2712
2713	Double TEncGOP::xCalculateRVM()
2714	{
2715	Double dRVM = 0;
2716
2717	if( m_pcCfg->getGOPSize() == 1 && m_pcCfg->getIntraPeriod() != 1 && m_pcCfg->getFramesToBeEncoded() > RVM_VCEGAM10_M * 2 )
2718	{
2719	// calculate RVM only for lowdelay configurations
2720	std::vector<Double> vRL , vB;
2721	size_t N = m_vRVM_RP.size();
2722	vRL.resize( N );
2723	vB.resize( N );
2724
2725	Int i;
2726	Double dRavg = 0 , dBavg = 0;
2727	vB[RVM_VCEGAM10_M] = 0;
2728	for( i = RVM_VCEGAM10_M + 1 ; i < N - RVM_VCEGAM10_M + 1 ; i++ )
2729	{
2730	vRL[i] = 0;
2731	for( Int j = i - RVM_VCEGAM10_M ; j <= i + RVM_VCEGAM10_M - 1 ; j++ )
2732	vRL[i] += m_vRVM_RP[j];
2733	vRL[i] /= ( 2 * RVM_VCEGAM10_M );
2734	vB[i] = vB[i-1] + m_vRVM_RP[i] - vRL[i];
2735	dRavg += m_vRVM_RP[i];
2736	dBavg += vB[i];
2737	}
2738
2739	dRavg /= ( N - 2 * RVM_VCEGAM10_M );
2740	dBavg /= ( N - 2 * RVM_VCEGAM10_M );
2741
2742	Double dSigamB = 0;
2743	for( i = RVM_VCEGAM10_M + 1 ; i < N - RVM_VCEGAM10_M + 1 ; i++ )
2744	{
2745	Double tmp = vB[i] - dBavg;
2746	dSigamB += tmp * tmp;
2747	}
2748	dSigamB = sqrt( dSigamB / ( N - 2 * RVM_VCEGAM10_M ) );
2749
2750	Double f = sqrt( 12.0 * ( RVM_VCEGAM10_M - 1 ) / ( RVM_VCEGAM10_M + 1 ) );
2751
2752	dRVM = dSigamB / dRavg * f;
2753	}
2754
2755	return( dRVM );
2756	}
2757
2758	/** Attaches the input bitstream to the stream in the output NAL unit
2759	Updates rNalu to contain concatenated bitstream. rpcBitstreamRedirect is cleared at the end of this function call.
2760	* \param codedSliceData contains the coded slice data (bitstream) to be concatenated to rNalu
2761	* \param rNalu target NAL unit
2762	*/
2763	Void TEncGOP::xAttachSliceDataToNalUnit (OutputNALUnit& rNalu, TComOutputBitstream*& codedSliceData)
2764	{
2765	// Byte-align
2766	rNalu.m_Bitstream.writeByteAlignment(); // Slice header byte-alignment
2767
2768	// Perform bitstream concatenation
2769	if (codedSliceData->getNumberOfWrittenBits() > 0)
2770	{
2771	rNalu.m_Bitstream.addSubstream(codedSliceData);
2772	}
2773
2774	m_pcEntropyCoder->setBitstream(&rNalu.m_Bitstream);
2775
2776	codedSliceData->clear();
2777	}
2778
2779	// Function will arrange the long-term pictures in the decreasing order of poc_lsb_lt,
2780	// and among the pictures with the same lsb, it arranges them in increasing delta_poc_msb_cycle_lt value
2781	Void TEncGOP::arrangeLongtermPicturesInRPS(TComSlice pcSlice, TComList<TComPic>& rcListPic)
2782	{
2783	TComReferencePictureSet *rps = pcSlice->getRPS();
2784	if(!rps->getNumberOfLongtermPictures())
2785	{
2786	return;
2787	}
2788
2789	// Arrange long-term reference pictures in the correct order of LSB and MSB,
2790	// and assign values for pocLSBLT and MSB present flag
2791	Int longtermPicsPoc[MAX_NUM_REF_PICS], longtermPicsLSB[MAX_NUM_REF_PICS], indices[MAX_NUM_REF_PICS];
2792	Int longtermPicsMSB[MAX_NUM_REF_PICS];
2793	Bool mSBPresentFlag[MAX_NUM_REF_PICS];
2794	::memset(longtermPicsPoc, 0, sizeof(longtermPicsPoc)); // Store POC values of LTRP
2795	::memset(longtermPicsLSB, 0, sizeof(longtermPicsLSB)); // Store POC LSB values of LTRP
2796	::memset(longtermPicsMSB, 0, sizeof(longtermPicsMSB)); // Store POC LSB values of LTRP
2797	::memset(indices , 0, sizeof(indices)); // Indices to aid in tracking sorted LTRPs
2798	::memset(mSBPresentFlag , 0, sizeof(mSBPresentFlag)); // Indicate if MSB needs to be present
2799
2800	// Get the long-term reference pictures
2801	Int offset = rps->getNumberOfNegativePictures() + rps->getNumberOfPositivePictures();
2802	Int i, ctr = 0;
2803	Int maxPicOrderCntLSB = 1 << pcSlice->getSPS()->getBitsForPOC();
2804	for(i = rps->getNumberOfPictures() - 1; i >= offset; i--, ctr++)
2805	{
2806	longtermPicsPoc[ctr] = rps->getPOC(i); // LTRP POC
2807	longtermPicsLSB[ctr] = getLSB(longtermPicsPoc[ctr], maxPicOrderCntLSB); // LTRP POC LSB
2808	indices[ctr] = i;
2809	longtermPicsMSB[ctr] = longtermPicsPoc[ctr] - longtermPicsLSB[ctr];
2810	}
2811	Int numLongPics = rps->getNumberOfLongtermPictures();
2812	assert(ctr == numLongPics);
2813
2814	// Arrange pictures in decreasing order of MSB;
2815	for(i = 0; i < numLongPics; i++)
2816	{
2817	for(Int j = 0; j < numLongPics - 1; j++)
2818	{
2819	if(longtermPicsMSB[j] < longtermPicsMSB[j+1])
2820	{
2821	std::swap(longtermPicsPoc[j], longtermPicsPoc[j+1]);
2822	std::swap(longtermPicsLSB[j], longtermPicsLSB[j+1]);
2823	std::swap(longtermPicsMSB[j], longtermPicsMSB[j+1]);
2824	std::swap(indices[j] , indices[j+1] );
2825	}
2826	}
2827	}
2828
2829	for(i = 0; i < numLongPics; i++)
2830	{
2831	// Check if MSB present flag should be enabled.
2832	// Check if the buffer contains any pictures that have the same LSB.
2833	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
2834	TComPic* pcPic;
2835	while ( iterPic != rcListPic.end() )
2836	{
2837	pcPic = *iterPic;
2838	if( (getLSB(pcPic->getPOC(), maxPicOrderCntLSB) == longtermPicsLSB[i]) && // Same LSB
2839	(pcPic->getSlice(0)->isReferenced()) && // Reference picture
2840	(pcPic->getPOC() != longtermPicsPoc[i]) ) // Not the LTRP itself
2841	{
2842	mSBPresentFlag[i] = true;
2843	break;
2844	}
2845	iterPic++;
2846	}
2847	}
2848
2849	// tempArray for usedByCurr flag
2850	Bool tempArray[MAX_NUM_REF_PICS]; ::memset(tempArray, 0, sizeof(tempArray));
2851	for(i = 0; i < numLongPics; i++)
2852	{
2853	tempArray[i] = rps->getUsed(indices[i]);
2854	}
2855	// Now write the final values;
2856	ctr = 0;
2857	Int currMSB = 0, currLSB = 0;
2858	// currPicPoc = currMSB + currLSB
2859	currLSB = getLSB(pcSlice->getPOC(), maxPicOrderCntLSB);
2860	currMSB = pcSlice->getPOC() - currLSB;
2861
2862	for(i = rps->getNumberOfPictures() - 1; i >= offset; i--, ctr++)
2863	{
2864	rps->setPOC (i, longtermPicsPoc[ctr]);
2865	rps->setDeltaPOC (i, - pcSlice->getPOC() + longtermPicsPoc[ctr]);
2866	rps->setUsed (i, tempArray[ctr]);
2867	rps->setPocLSBLT (i, longtermPicsLSB[ctr]);
2868	rps->setDeltaPocMSBCycleLT (i, (currMSB - (longtermPicsPoc[ctr] - longtermPicsLSB[ctr])) / maxPicOrderCntLSB);
2869	rps->setDeltaPocMSBPresentFlag(i, mSBPresentFlag[ctr]);
2870
2871	assert(rps->getDeltaPocMSBCycleLT(i) >= 0); // Non-negative value
2872	}
2873	for(i = rps->getNumberOfPictures() - 1, ctr = 1; i >= offset; i--, ctr++)
2874	{
2875	for(Int j = rps->getNumberOfPictures() - 1 - ctr; j >= offset; j--)
2876	{
2877	// Here at the encoder we know that we have set the full POC value for the LTRPs, hence we
2878	// don't have to check the MSB present flag values for this constraint.
2879	assert( rps->getPOC(i) != rps->getPOC(j) ); // If assert fails, LTRP entry repeated in RPS!!!
2880	}
2881	}
2882	}
2883
2884	#if L0045_NON_NESTED_SEI_RESTRICTIONS
2885	/** Function for finding the position to insert the first of APS and non-nested BP, PT, DU info SEI messages.
2886	* \param accessUnit Access Unit of the current picture
2887	* This function finds the position to insert the first of APS and non-nested BP, PT, DU info SEI messages.
2888	*/
2889	Int TEncGOP::xGetFirstSeiLocation(AccessUnit &accessUnit)
2890	{
2891	// Find the location of the first SEI message
2892	AccessUnit::iterator it;
2893	Int seiStartPos = 0;
2894	for(it = accessUnit.begin(); it != accessUnit.end(); it++, seiStartPos++)
2895	{
2896	if ((it)->isSei() \|\| (it)->isVcl())
2897	{
2898	break;
2899	}
2900	}
2901	// assert(it != accessUnit.end()); // Triggers with some legit configurations
2902	return seiStartPos;
2903	}
2904	#endif
2905
2906	#if L0386_DB_METRIC
2907	Void TEncGOP::dblMetric( TComPic* pcPic, UInt uiNumSlices )
2908	{
2909	TComPicYuv* pcPicYuvRec = pcPic->getPicYuvRec();
2910	Pel* Rec = pcPicYuvRec->getLumaAddr( 0 );
2911	Pel* tempRec = Rec;
2912	Int stride = pcPicYuvRec->getStride();
2913	UInt log2maxTB = pcPic->getSlice(0)->getSPS()->getQuadtreeTULog2MaxSize();
2914	UInt maxTBsize = (1<<log2maxTB);
2915	const UInt minBlockArtSize = 8;
2916	const UInt picWidth = pcPicYuvRec->getWidth();
2917	const UInt picHeight = pcPicYuvRec->getHeight();
2918	const UInt noCol = (picWidth>>log2maxTB);
2919	const UInt noRows = (picHeight>>log2maxTB);
2920	UInt64 colSAD = (UInt64)malloc(noCol*sizeof(UInt64));
2921	UInt64 rowSAD = (UInt64)malloc(noRows*sizeof(UInt64));
2922	UInt colIdx = 0;
2923	UInt rowIdx = 0;
2924	Pel p0, p1, p2, q0, q1, q2;
2925
2926	Int qp = pcPic->getSlice(0)->getSliceQp();
2927	Int bitdepthScale = 1 << (g_bitDepthY-8);
2928	Int beta = TComLoopFilter::getBeta( qp ) * bitdepthScale;
2929	const Int thr2 = (beta>>2);
2930	const Int thr1 = 2*bitdepthScale;
2931	UInt a = 0;
2932
2933	memset(colSAD, 0, noCol*sizeof(UInt64));
2934	memset(rowSAD, 0, noRows*sizeof(UInt64));
2935
2936	if (maxTBsize > minBlockArtSize)
2937	{
2938	// Analyze vertical artifact edges
2939	for(Int c = maxTBsize; c < picWidth; c += maxTBsize)
2940	{
2941	for(Int r = 0; r < picHeight; r++)
2942	{
2943	p2 = Rec[c-3];
2944	p1 = Rec[c-2];
2945	p0 = Rec[c-1];
2946	q0 = Rec[c];
2947	q1 = Rec[c+1];
2948	q2 = Rec[c+2];
2949	a = ((abs(p2-(p1<<1)+p0)+abs(q0-(q1<<1)+q2))<<1);
2950	if ( thr1 < a && a < thr2)
2951	{
2952	colSAD[colIdx] += abs(p0 - q0);
2953	}
2954	Rec += stride;
2955	}
2956	colIdx++;
2957	Rec = tempRec;
2958	}
2959
2960	// Analyze horizontal artifact edges
2961	for(Int r = maxTBsize; r < picHeight; r += maxTBsize)
2962	{
2963	for(Int c = 0; c < picWidth; c++)
2964	{
2965	p2 = Rec[c + (r-3)*stride];
2966	p1 = Rec[c + (r-2)*stride];
2967	p0 = Rec[c + (r-1)*stride];
2968	q0 = Rec[c + r*stride];
2969	q1 = Rec[c + (r+1)*stride];
2970	q2 = Rec[c + (r+2)*stride];
2971	a = ((abs(p2-(p1<<1)+p0)+abs(q0-(q1<<1)+q2))<<1);
2972	if (thr1 < a && a < thr2)
2973	{
2974	rowSAD[rowIdx] += abs(p0 - q0);
2975	}
2976	}
2977	rowIdx++;
2978	}
2979	}
2980
2981	UInt64 colSADsum = 0;
2982	UInt64 rowSADsum = 0;
2983	for(Int c = 0; c < noCol-1; c++)
2984	{
2985	colSADsum += colSAD[c];
2986	}
2987	for(Int r = 0; r < noRows-1; r++)
2988	{
2989	rowSADsum += rowSAD[r];
2990	}
2991
2992	colSADsum <<= 10;
2993	rowSADsum <<= 10;
2994	colSADsum /= (noCol-1);
2995	colSADsum /= picHeight;
2996	rowSADsum /= (noRows-1);
2997	rowSADsum /= picWidth;
2998
2999	UInt64 avgSAD = ((colSADsum + rowSADsum)>>1);
3000	avgSAD >>= (g_bitDepthY-8);
3001
3002	if ( avgSAD > 2048 )
3003	{
3004	avgSAD >>= 9;
3005	Int offset = Clip3(2,6,(Int)avgSAD);
3006	for (Int i=0; i<uiNumSlices; i++)
3007	{
3008	pcPic->getSlice(i)->setDeblockingFilterOverrideFlag(true);
3009	pcPic->getSlice(i)->setDeblockingFilterDisable(false);
3010	pcPic->getSlice(i)->setDeblockingFilterBetaOffsetDiv2( offset );
3011	pcPic->getSlice(i)->setDeblockingFilterTcOffsetDiv2( offset );
3012	}
3013	}
3014	else
3015	{
3016	for (Int i=0; i<uiNumSlices; i++)
3017	{
3018	pcPic->getSlice(i)->setDeblockingFilterOverrideFlag(false);
3019	pcPic->getSlice(i)->setDeblockingFilterDisable( pcPic->getSlice(i)->getPPS()->getPicDisableDeblockingFilterFlag() );
3020	pcPic->getSlice(i)->setDeblockingFilterBetaOffsetDiv2( pcPic->getSlice(i)->getPPS()->getDeblockingFilterBetaOffsetDiv2() );
3021	pcPic->getSlice(i)->setDeblockingFilterTcOffsetDiv2( pcPic->getSlice(i)->getPPS()->getDeblockingFilterTcOffsetDiv2() );
3022	}
3023	}
3024
3025	free(colSAD);
3026	free(rowSAD);
3027	}
3028	#endif
3029	//! \}

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

Download in other formats: