Context navigation

source: SHVCSoftware/branches/SHM-4.1-dev/source/Lib/TLibEncoder/TEncGOP.cpp @ 506

Visit:

Last change on this file since 506 was 506, checked in by interdigital, 12 years ago

Integrated JCTVC-O0092/0094/0096

Implement O1008 SHVC text pseudo code for direct/indirect reference layers detection
constraint on the maximum number of reference layers
constraint on the layer id of SPS/PPS
identify SPS rep format with index into the list of rep format in VPS
specify default direct dependency type in VPS

Property svn:eol-style set to native

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

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

Download in other formats: