Context navigation

source: SHVCSoftware/branches/SHM-dev/source/Lib/TLibCommon/TComSlice.cpp @ 1189

Visit:

Last change on this file since 1189 was 1180, checked in by seregin, 9 years ago
macro cleanup: VPS_RESERVED_FLAGS
Property svn:eol-style set to `native`
File size: 130.0 KB

Line
1	/* The copyright in this software is being made available under the BSD
2	* License, included below. This software may be subject to other third party
3	* and contributor rights, including patent rights, and no such rights are
4	* granted under this license.
5	*
6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	* All rights reserved.
8	*
9	* Redistribution and use in source and binary forms, with or without
10	* modification, are permitted provided that the following conditions are met:
11	*
12	* * Redistributions of source code must retain the above copyright notice,
13	* this list of conditions and the following disclaimer.
14	* * Redistributions in binary form must reproduce the above copyright notice,
15	* this list of conditions and the following disclaimer in the documentation
16	* and/or other materials provided with the distribution.
17	* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18	* be used to endorse or promote products derived from this software without
19	* specific prior written permission.
20	*
21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31	* THE POSSIBILITY OF SUCH DAMAGE.
32	*/
33
34	/** \file TComSlice.cpp
35	\brief slice header and SPS class
36	*/
37
38	#include "CommonDef.h"
39	#include "TComSlice.h"
40	#include "TComPic.h"
41	#include "TLibEncoder/TEncSbac.h"
42	#include "TLibDecoder/TDecSbac.h"
43
44
45	//! \ingroup TLibCommon
46	//! \{
47
48	#if SVC_EXTENSION
49	#include <numeric>
50	ParameterSetMap<TComVPS> ParameterSetManager::m_vpsMap(MAX_NUM_VPS);
51	ParameterSetMap<TComSPS> ParameterSetManager::m_spsMap(MAX_NUM_SPS);
52	ParameterSetMap<TComPPS> ParameterSetManager::m_ppsMap(MAX_NUM_PPS);
53	Int ParameterSetManager::m_activeVPSId = -1;
54	#endif
55
56	TComSlice::TComSlice()
57	: m_iPPSId ( -1 )
58	, m_PicOutputFlag ( true )
59	, m_iPOC ( 0 )
60	, m_iLastIDR ( 0 )
61	, m_iAssociatedIRAP ( 0 )
62	, m_iAssociatedIRAPType ( NAL_UNIT_INVALID )
63	, m_pcRPS ( 0 )
64	, m_LocalRPS ( )
65	, m_iBDidx ( 0 )
66	, m_RefPicListModification ( )
67	, m_eNalUnitType ( NAL_UNIT_CODED_SLICE_IDR_W_RADL )
68	, m_eSliceType ( I_SLICE )
69	, m_iSliceQp ( 0 )
70	, m_dependentSliceSegmentFlag ( false )
71	#if ADAPTIVE_QP_SELECTION
72	, m_iSliceQpBase ( 0 )
73	#endif
74	, m_ChromaQpAdjEnabled ( false )
75	, m_deblockingFilterDisable ( false )
76	, m_deblockingFilterOverrideFlag ( false )
77	, m_deblockingFilterBetaOffsetDiv2( 0 )
78	, m_deblockingFilterTcOffsetDiv2 ( 0 )
79	, m_bCheckLDC ( false )
80	, m_iSliceQpDelta ( 0 )
81	, m_iDepth ( 0 )
82	, m_bRefenced ( false )
83	, m_pcVPS ( NULL )
84	, m_pcSPS ( NULL )
85	, m_pcPPS ( NULL )
86	, m_pcPic ( NULL )
87	#if ADAPTIVE_QP_SELECTION
88	, m_pcTrQuant ( NULL )
89	#endif
90	, m_colFromL0Flag ( 1 )
91	, m_noOutputPriorPicsFlag ( false )
92	, m_noRaslOutputFlag ( false )
93	, m_handleCraAsBlaFlag ( false )
94	, m_colRefIdx ( 0 )
95	, m_maxNumMergeCand ( 0 )
96	, m_uiTLayer ( 0 )
97	, m_bTLayerSwitchingFlag ( false )
98	, m_sliceMode ( NO_SLICES )
99	, m_sliceArgument ( 0 )
100	, m_sliceCurStartCtuTsAddr ( 0 )
101	, m_sliceCurEndCtuTsAddr ( 0 )
102	, m_sliceIdx ( 0 )
103	, m_sliceSegmentMode ( NO_SLICES )
104	, m_sliceSegmentArgument ( 0 )
105	, m_sliceSegmentCurStartCtuTsAddr ( 0 )
106	, m_sliceSegmentCurEndCtuTsAddr ( 0 )
107	, m_nextSlice ( false )
108	, m_nextSliceSegment ( false )
109	, m_sliceBits ( 0 )
110	, m_sliceSegmentBits ( 0 )
111	, m_bFinalized ( false )
112	, m_substreamSizes ( )
113	, m_scalingList ( NULL )
114	, m_cabacInitFlag ( false )
115	, m_bLMvdL1Zero ( false )
116	, m_temporalLayerNonReferenceFlag ( false )
117	, m_LFCrossSliceBoundaryFlag ( false )
118	, m_enableTMVPFlag ( true )
119	#if SVC_EXTENSION
120	, m_firstSliceInPic ( false )
121	#if R0226_SLICE_TMVP
122	, m_availableForTMVPRefFlag ( true )
123	#endif
124	, m_layerId ( 0 )
125	#if REF_IDX_MFM
126	, m_bMFMEnabledFlag ( false )
127	#endif
128	, m_bDiscardableFlag ( false )
129	, m_bCrossLayerBLAFlag ( false )
130	#if POC_RESET_IDC_SIGNALLING
131	, m_pocResetIdc ( 0 )
132	, m_pocResetPeriodId ( 0 )
133	, m_fullPocResetFlag ( false )
134	, m_pocLsbVal ( 0 )
135	, m_pocMsbVal ( 0 )
136	, m_pocMsbValRequiredFlag ( false )
137	, m_pocMsbValPresentFlag ( false )
138	#if P0297_VPS_POC_LSB_ALIGNED_FLAG
139	, m_pocMsbValNeeded ( false )
140	#endif
141	#endif
142	#if POC_RESET_IDC_DECODER \|\| POC_RESET_IDC_ENCODER
143	, m_picOrderCntLsb (0)
144	#endif
145	#endif //SVC_EXTENSION
146	{
147	for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
148	{
149	m_aiNumRefIdx[i] = 0;
150	}
151
152	#if SVC_EXTENSION
153	memset( m_pcBaseColPic, 0, sizeof( m_pcBaseColPic ) );
154	m_activeNumILRRefIdx = 0;
155	m_interLayerPredEnabledFlag = 0;
156	::memset( m_interLayerPredLayerIdc, 0, sizeof(m_interLayerPredLayerIdc) );
157	#endif //SVC_EXTENSION
158
159	for (UInt component = 0; component < MAX_NUM_COMPONENT; component++)
160	{
161	m_lambdas [component] = 0.0;
162	m_iSliceChromaQpDelta[component] = 0;
163	}
164
165	initEqualRef();
166
167	for ( Int idx = 0; idx < MAX_NUM_REF; idx++ )
168	{
169	m_list1IdxToList0Idx[idx] = -1;
170	}
171
172	for(Int iNumCount = 0; iNumCount < MAX_NUM_REF; iNumCount++)
173	{
174	for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
175	{
176	m_apcRefPicList [i][iNumCount] = NULL;
177	m_aiRefPOCList [i][iNumCount] = 0;
178	}
179	}
180
181	resetWpScaling();
182	initWpAcDcParam();
183
184	for(Int ch=0; ch < MAX_NUM_CHANNEL_TYPE; ch++)
185	{
186	m_saoEnabledFlag[ch] = false;
187	}
188	}
189
190	TComSlice::~TComSlice()
191	{
192	}
193
194
195	#if SVC_EXTENSION
196	Void TComSlice::initSlice( UInt layerId )
197	#else
198	Void TComSlice::initSlice()
199	#endif
200	{
201	#if SVC_EXTENSION
202	m_layerId = layerId;
203	m_activeNumILRRefIdx = 0;
204	m_interLayerPredEnabledFlag = 0;
205	#endif
206
207	for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
208	{
209	m_aiNumRefIdx[i] = 0;
210	}
211	m_colFromL0Flag = 1;
212
213	m_colRefIdx = 0;
214	initEqualRef();
215
216	m_bCheckLDC = false;
217
218	for (UInt component = 0; component < MAX_NUM_COMPONENT; component++) m_iSliceChromaQpDelta[component] = 0;
219
220	m_maxNumMergeCand = MRG_MAX_NUM_CANDS;
221
222	m_bFinalized=false;
223
224	m_substreamSizes.clear();
225	m_cabacInitFlag = false;
226	m_enableTMVPFlag = true;
227	#if POC_RESET_IDC_SIGNALLING
228	m_pocResetIdc = 0;
229	m_pocResetPeriodId = 0;
230	m_fullPocResetFlag = false;
231	m_pocLsbVal = 0;
232	m_pocMsbVal = 0;
233	m_pocMsbValRequiredFlag = false;
234	m_pocMsbValPresentFlag = false;
235	#endif
236	#if POC_RESET_IDC_DECODER \|\| POC_RESET_IDC_ENCODER
237	m_picOrderCntLsb = 0;
238	#endif
239	#if P0297_VPS_POC_LSB_ALIGNED_FLAG
240	m_pocMsbValNeeded = false;
241	m_pocResetDeltaPoc = 0;
242	#endif
243	}
244
245	Bool TComSlice::getRapPicFlag()
246	{
247	return getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
248	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP
249	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
250	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
251	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
252	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA;
253	}
254
255
256	Void TComSlice::sortPicList (TComList<TComPic*>& rcListPic)
257	{
258	TComPic* pcPicExtract;
259	TComPic* pcPicInsert;
260
261	TComList<TComPic*>::iterator iterPicExtract;
262	TComList<TComPic*>::iterator iterPicExtract_1;
263	TComList<TComPic*>::iterator iterPicInsert;
264
265	for (Int i = 1; i < (Int)(rcListPic.size()); i++)
266	{
267	iterPicExtract = rcListPic.begin();
268	for (Int j = 0; j < i; j++) iterPicExtract++;
269	pcPicExtract = *(iterPicExtract);
270	pcPicExtract->setCurrSliceIdx(0);
271
272	iterPicInsert = rcListPic.begin();
273	while (iterPicInsert != iterPicExtract)
274	{
275	pcPicInsert = *(iterPicInsert);
276	pcPicInsert->setCurrSliceIdx(0);
277	if (pcPicInsert->getPOC() >= pcPicExtract->getPOC())
278	{
279	break;
280	}
281
282	iterPicInsert++;
283	}
284
285	iterPicExtract_1 = iterPicExtract; iterPicExtract_1++;
286
287	// swap iterPicExtract and iterPicInsert, iterPicExtract = curr. / iterPicInsert = insertion position
288	rcListPic.insert (iterPicInsert, iterPicExtract, iterPicExtract_1);
289	rcListPic.erase (iterPicExtract);
290	}
291	}
292
293	TComPic* TComSlice::xGetRefPic (TComList<TComPic*>& rcListPic, Int poc)
294	{
295	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
296	TComPic* pcPic = *(iterPic);
297	while ( iterPic != rcListPic.end() )
298	{
299	#if POC_RESET_IDC_ENCODER
300	if( (pcPic->getPOC() == poc) && (pcPic->getSlice(0)->isReferenced()) )
301	#else
302	if(pcPic->getPOC() == poc)
303	#endif
304	{
305	break;
306	}
307	iterPic++;
308	#if SVC_EXTENSION
309	// return NULL, if picture with requested POC is not in the list, otherwise iterator goes outside of the list
310	if( iterPic == rcListPic.end() )
311	{
312	return NULL;
313	}
314	#endif
315	pcPic = *(iterPic);
316	}
317	#if POC_RESET_IDC_DECODER
318	assert( pcPic->getSlice(0)->isReferenced() );
319	#endif
320	return pcPic;
321	}
322
323
324	TComPic* TComSlice::xGetLongTermRefPic(TComList<TComPic*>& rcListPic, Int poc, Bool pocHasMsb)
325	{
326	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
327	TComPic* pcPic = *(iterPic);
328	TComPic* pcStPic = pcPic;
329
330	Int pocCycle = 1 << getSPS()->getBitsForPOC();
331	if (!pocHasMsb)
332	{
333	poc = poc & (pocCycle - 1);
334	}
335
336	while ( iterPic != rcListPic.end() )
337	{
338	pcPic = *(iterPic);
339	if (pcPic && pcPic->getPOC()!=this->getPOC() && pcPic->getSlice( 0 )->isReferenced())
340	{
341	Int picPoc = pcPic->getPOC();
342	if (!pocHasMsb)
343	{
344	picPoc = picPoc & (pocCycle - 1);
345	}
346
347	if (poc == picPoc)
348	{
349	if(pcPic->getIsLongTerm())
350	{
351	return pcPic;
352	}
353	else
354	{
355	pcStPic = pcPic;
356	}
357	break;
358	}
359	}
360
361	iterPic++;
362	}
363
364	return pcStPic;
365	}
366
367	Void TComSlice::setRefPOCList ()
368	{
369	for (Int iDir = 0; iDir < NUM_REF_PIC_LIST_01; iDir++)
370	{
371	for (Int iNumRefIdx = 0; iNumRefIdx < m_aiNumRefIdx[iDir]; iNumRefIdx++)
372	{
373	m_aiRefPOCList[iDir][iNumRefIdx] = m_apcRefPicList[iDir][iNumRefIdx]->getPOC();
374	}
375	}
376
377	}
378
379	Void TComSlice::setList1IdxToList0Idx()
380	{
381	Int idxL0, idxL1;
382	for ( idxL1 = 0; idxL1 < getNumRefIdx( REF_PIC_LIST_1 ); idxL1++ )
383	{
384	m_list1IdxToList0Idx[idxL1] = -1;
385	for ( idxL0 = 0; idxL0 < getNumRefIdx( REF_PIC_LIST_0 ); idxL0++ )
386	{
387	if ( m_apcRefPicList[REF_PIC_LIST_0][idxL0]->getPOC() == m_apcRefPicList[REF_PIC_LIST_1][idxL1]->getPOC() )
388	{
389	m_list1IdxToList0Idx[idxL1] = idxL0;
390	break;
391	}
392	}
393	}
394	}
395
396	#if SVC_EXTENSION
397	Void TComSlice::setRefPicList( TComList<TComPic>& rcListPic, Bool checkNumPocTotalCurr, TComPic* ilpPic)
398	#else
399	Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr )
400	#endif
401	{
402	if (!checkNumPocTotalCurr)
403	{
404	if (m_eSliceType == I_SLICE)
405	{
406	::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
407	::memset( m_aiNumRefIdx, 0, sizeof ( m_aiNumRefIdx ));
408
409	return;
410	}
411
412	m_aiNumRefIdx[REF_PIC_LIST_0] = getNumRefIdx(REF_PIC_LIST_0);
413	m_aiNumRefIdx[REF_PIC_LIST_1] = getNumRefIdx(REF_PIC_LIST_1);
414	}
415
416	TComPic* pcRefPic= NULL;
417	static const UInt MAX_NUM_NEGATIVE_PICTURES=16;
418	TComPic* RefPicSetStCurr0[MAX_NUM_NEGATIVE_PICTURES];
419	TComPic* RefPicSetStCurr1[MAX_NUM_NEGATIVE_PICTURES];
420	TComPic* RefPicSetLtCurr[MAX_NUM_NEGATIVE_PICTURES];
421	UInt NumPocStCurr0 = 0;
422	UInt NumPocStCurr1 = 0;
423	UInt NumPocLtCurr = 0;
424	Int i;
425
426	#if SVC_EXTENSION
427	if( m_layerId == 0 \|\| ( m_layerId > 0 && ( m_activeNumILRRefIdx == 0 \|\| !((getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP) && (getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA)) ) ) )
428	{
429	#endif
430	for(i=0; i < m_pcRPS->getNumberOfNegativePictures(); i++)
431	{
432	if(m_pcRPS->getUsed(i))
433	{
434	pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
435	pcRefPic->setIsLongTerm(0);
436	pcRefPic->getPicYuvRec()->extendPicBorder();
437	RefPicSetStCurr0[NumPocStCurr0] = pcRefPic;
438	NumPocStCurr0++;
439	pcRefPic->setCheckLTMSBPresent(false);
440	}
441	}
442
443	for(; i < m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures(); i++)
444	{
445	if(m_pcRPS->getUsed(i))
446	{
447	pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
448	pcRefPic->setIsLongTerm(0);
449	pcRefPic->getPicYuvRec()->extendPicBorder();
450	RefPicSetStCurr1[NumPocStCurr1] = pcRefPic;
451	NumPocStCurr1++;
452	pcRefPic->setCheckLTMSBPresent(false);
453	}
454	}
455
456	for(i = m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()+m_pcRPS->getNumberOfLongtermPictures()-1; i > m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()-1 ; i--)
457	{
458	if(m_pcRPS->getUsed(i))
459	{
460	pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
461	pcRefPic->setIsLongTerm(1);
462	pcRefPic->getPicYuvRec()->extendPicBorder();
463	RefPicSetLtCurr[NumPocLtCurr] = pcRefPic;
464	NumPocLtCurr++;
465	}
466	if(pcRefPic==NULL)
467	{
468	pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
469	}
470	pcRefPic->setCheckLTMSBPresent(m_pcRPS->getCheckLTMSBPresent(i));
471	}
472	#if SVC_EXTENSION
473	}
474	#endif
475
476	// ref_pic_list_init
477	TComPic* rpsCurrList0[MAX_NUM_REF+1];
478	TComPic* rpsCurrList1[MAX_NUM_REF+1];
479	#if SVC_EXTENSION
480	Int numInterLayerRPSPics = 0;
481	if( m_layerId > 0 && m_activeNumILRRefIdx > 0 )
482	{
483	for( i=0; i < m_pcVPS->getNumDirectRefLayers( m_layerId ); i++ )
484	{
485	Int maxTidIlRefPicsPlus1 = getVPS()->getMaxTidIlRefPicsPlus1(ilpPic[i]->getSlice(0)->getLayerIdx(), getLayerIdx());
486
487	if( ((Int)(ilpPic[i]->getSlice(0)->getTLayer())<= maxTidIlRefPicsPlus1-1) \|\| (maxTidIlRefPicsPlus1==0 && ilpPic[i]->getSlice(0)->getRapPicFlag() ) )
488	{
489	numInterLayerRPSPics++;
490	#if DISCARDABLE_PIC_RPS
491	assert( ilpPic[i]->getSlice(0)->getDiscardableFlag() == 0 ); // Inter-layer RPS shall not contain picture with discardable_flag = 1.
492	#endif
493	}
494	}
495	if (numInterLayerRPSPics < m_activeNumILRRefIdx)
496	{
497	m_activeNumILRRefIdx = numInterLayerRPSPics;
498	}
499	#if MAX_ONE_RESAMPLING_DIRECT_LAYERS
500	if( m_pcVPS->getScalabilityMask( SCALABILITY_ID ) )
501	{
502	Int numResampler = 0;
503	#if MOTION_RESAMPLING_CONSTRAINT
504	Int numMotionResamplers = 0;
505	Int refResamplingLayer[MAX_LAYERS];
506	memset( refResamplingLayer, 0, sizeof( refResamplingLayer ) );
507	#endif
508
509	for( i=0; i < m_activeNumILRRefIdx; i++ )
510	{
511	UInt refLayerIdc = m_interLayerPredLayerIdc[i];
512	UInt refLayerId = m_pcVPS->getRefLayerId( m_layerId, refLayerIdc );
513
514	const Window &scalEL = getPPS()->getScaledRefLayerWindowForLayer(refLayerId);
515
516	Int scalingOffset = ((scalEL.getWindowLeftOffset() == 0 ) &&
517	(scalEL.getWindowRightOffset() == 0 ) &&
518	(scalEL.getWindowTopOffset() == 0 ) &&
519	(scalEL.getWindowBottomOffset() == 0 )
520	);
521
522	#if O0194_DIFFERENT_BITDEPTH_EL_BL
523	Bool sameBitDepths = ( g_bitDepthLayer[CHANNEL_TYPE_LUMA][m_layerId] == g_bitDepthLayer[CHANNEL_TYPE_LUMA][refLayerId] ) && ( g_bitDepthLayer[CHANNEL_TYPE_CHROMA][m_layerId] == g_bitDepthLayer[CHANNEL_TYPE_CHROMA][refLayerId] );
524
525	if( !( g_posScalingFactor[refLayerIdc][0] == 65536 && g_posScalingFactor[refLayerIdc][1] == 65536 ) \|\| !scalingOffset \|\| !sameBitDepths
526	#if Q0048_CGS_3D_ASYMLUT
527	\|\| getPPS()->getCGSFlag()
528	#endif
529	) // ratio 1x
530	#else
531	if(!( g_posScalingFactor[refLayerIdc][0] == 65536 && g_posScalingFactor[refLayerIdc][1] == 65536 ) \|\| (!scalingOffset)) // ratio 1x
532	#endif
533	{
534	#if MOTION_RESAMPLING_CONSTRAINT
535	UInt predType = m_pcVPS->getDirectDependencyType( m_layerId, refLayerId ) + 1;
536
537	if( predType & 0x1 )
538	{
539	numResampler++;
540	refResamplingLayer[i] = refLayerIdc + 1;
541	}
542
543	if( predType & 0x2 )
544	{
545	numMotionResamplers++;
546	refResamplingLayer[i] -= refLayerIdc + 1;
547	}
548	#else
549	numResampler++;
550	#endif
551	}
552	}
553
554	// When both picture sample values and picture motion field resampling processes are invoked for decoding of a particular picture, they shall be applied to the same reference layer picture.
555	if( m_activeNumILRRefIdx > 1 && numResampler > 0 )
556	{
557	for( i=0; i < m_activeNumILRRefIdx; i++ )
558	{
559	assert( refResamplingLayer[i] >= 0 && "Motion and sample inter-layer prediction shall be from the same layer" );
560	}
561	}
562
563	// Bitstream constraint for SHVC: The picture resampling process as specified in subclause G.8.1.4.1 shall not be invoked more than once for decoding of each particular picture.
564	assert(numResampler <= 1);
565	#if MOTION_RESAMPLING_CONSTRAINT
566	assert( numMotionResamplers <= 1 && "Up to 1 motion resampling is allowed" );
567	#endif
568	}
569	#endif
570	}
571	Int numPocTotalCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr + m_activeNumILRRefIdx;
572	#else //SVC_EXTENSION
573	Int numPocTotalCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr;
574	#endif //SVC_EXTENSION
575
576	if (checkNumPocTotalCurr)
577	{
578	// The variable NumPocTotalCurr is derived as specified in subclause 7.4.7.2. It is a requirement of bitstream conformance that the following applies to the value of NumPocTotalCurr:
579	#if SVC_EXTENSION // inter-layer prediction is allowed for BLA, CRA pictures of nuh_layer_id>0
580	// - If the current picture is a BLA or CRA picture with nuh_layer_id equal to 0, the value of NumPocTotalCurr shall be equal to 0.
581	// - Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
582	if (getRapPicFlag() && getLayerId()==0)
583	#else
584	// - If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
585	// - Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
586	if (getRapPicFlag())
587	#endif
588	{
589	assert(numPocTotalCurr == 0);
590	}
591
592	if (m_eSliceType == I_SLICE)
593	{
594	::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
595	::memset( m_aiNumRefIdx, 0, sizeof ( m_aiNumRefIdx ));
596
597	return;
598	}
599
600	assert(numPocTotalCurr > 0);
601
602	m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
603	m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
604	}
605
606	Int cIdx = 0;
607	for ( i=0; i<NumPocStCurr0; i++, cIdx++)
608	{
609	rpsCurrList0[cIdx] = RefPicSetStCurr0[i];
610	}
611
612	#if SVC_EXTENSION
613	#if RPL_INIT_N0316_N0082
614	if( m_layerId > 0 )
615	{
616	for( i = 0; i < m_activeNumILRRefIdx && cIdx < numPocTotalCurr; cIdx ++, i ++)
617	{
618	Int refLayerIdc = m_interLayerPredLayerIdc[i];
619	Int maxTidIlRefPicsPlus1 = getVPS()->getMaxTidIlRefPicsPlus1(ilpPic[refLayerIdc]->getSlice(0)->getLayerIdx(), getLayerIdx());
620	if( ((Int)(ilpPic[refLayerIdc]->getSlice(0)->getTLayer())<=maxTidIlRefPicsPlus1-1) \|\| (maxTidIlRefPicsPlus1==0 && ilpPic[refLayerIdc]->getSlice(0)->getRapPicFlag()) )
621	{
622	rpsCurrList0[cIdx] = ilpPic[refLayerIdc];
623	}
624	}
625	}
626	#endif
627	#endif //SVC_EXTENSION
628	for ( i=0; i<NumPocStCurr1; i++, cIdx++)
629	{
630	rpsCurrList0[cIdx] = RefPicSetStCurr1[i];
631	}
632	for ( i=0; i<NumPocLtCurr; i++, cIdx++)
633	{
634	rpsCurrList0[cIdx] = RefPicSetLtCurr[i];
635	}
636	#if !RPL_INIT_N0316_N0082
637	#if SVC_EXTENSION
638	if( m_layerId > 0 )
639	{
640	for( i = 0; i < m_activeNumILRRefIdx && cIdx < numPocTotalCurr; cIdx ++, i ++)
641	{
642	Int refLayerIdc = m_interLayerPredLayerIdc[i];
643	Int maxTidIlRefPicsPlus1 = getVPS()->getMaxTidIlRefPicsPlus1(ilpPic[refLayerIdc]->getSlice(0)->getLayerIdx(), getLayerIdx());
644	if( ((Int)(ilpPic[refLayerIdc]->getSlice(0)->getTLayer())<=maxTidIlRefPicsPlus1-1) \|\| (maxTidIlRefPicsPlus1==0 && ilpPic[refLayerIdc]->getSlice(0)->getRapPicFlag()) )
645	{
646	rpsCurrList0[cIdx] = ilpPic[refLayerIdc];
647	}
648	}
649	}
650	#endif
651	#endif
652	assert(cIdx == numPocTotalCurr);
653
654	if (m_eSliceType==B_SLICE)
655	{
656	cIdx = 0;
657	for ( i=0; i<NumPocStCurr1; i++, cIdx++)
658	{
659	rpsCurrList1[cIdx] = RefPicSetStCurr1[i];
660	}
661	for ( i=0; i<NumPocStCurr0; i++, cIdx++)
662	{
663	rpsCurrList1[cIdx] = RefPicSetStCurr0[i];
664	}
665	for ( i=0; i<NumPocLtCurr; i++, cIdx++)
666	{
667	rpsCurrList1[cIdx] = RefPicSetLtCurr[i];
668	}
669
670	#if SVC_EXTENSION
671	if( m_layerId > 0 )
672	{
673	for( i = 0; i < m_activeNumILRRefIdx && cIdx < numPocTotalCurr; cIdx ++, i ++)
674	{
675	Int refLayerIdc = m_interLayerPredLayerIdc[i];
676	Int maxTidIlRefPicsPlus1 = getVPS()->getMaxTidIlRefPicsPlus1( ilpPic[refLayerIdc]->getSlice(0)->getLayerIdx(), getLayerIdx() );
677	if( ((Int)(ilpPic[refLayerIdc]->getSlice(0)->getTLayer())<=maxTidIlRefPicsPlus1-1) \|\| (maxTidIlRefPicsPlus1==0 && ilpPic[refLayerIdc]->getSlice(0)->getRapPicFlag()) )
678	{
679	rpsCurrList1[cIdx] = ilpPic[refLayerIdc];
680	}
681	}
682	}
683	#endif //SVC_EXTENSION
684
685	assert(cIdx == numPocTotalCurr);
686	}
687
688	::memset(m_bIsUsedAsLongTerm, 0, sizeof(m_bIsUsedAsLongTerm));
689
690	for (Int rIdx = 0; rIdx < m_aiNumRefIdx[REF_PIC_LIST_0]; rIdx ++)
691	{
692	cIdx = m_RefPicListModification.getRefPicListModificationFlagL0() ? m_RefPicListModification.getRefPicSetIdxL0(rIdx) : rIdx % numPocTotalCurr;
693	assert(cIdx >= 0 && cIdx < numPocTotalCurr);
694	m_apcRefPicList[REF_PIC_LIST_0][rIdx] = rpsCurrList0[ cIdx ];
695	#if RPL_INIT_N0316_N0082
696	m_bIsUsedAsLongTerm[0][rIdx] = ( cIdx >= NumPocStCurr0 && cIdx < NumPocStCurr0 + m_activeNumILRRefIdx ) \|\| ( cIdx >= NumPocStCurr0 + NumPocStCurr1 + m_activeNumILRRefIdx );
697	#else
698	m_bIsUsedAsLongTerm[REF_PIC_LIST_0][rIdx] = ( cIdx >= NumPocStCurr0 + NumPocStCurr1 );
699	#endif
700	}
701	if ( m_eSliceType != B_SLICE )
702	{
703	m_aiNumRefIdx[REF_PIC_LIST_1] = 0;
704	::memset( m_apcRefPicList[REF_PIC_LIST_1], 0, sizeof(m_apcRefPicList[REF_PIC_LIST_1]));
705	}
706	else
707	{
708	for (Int rIdx = 0; rIdx < m_aiNumRefIdx[REF_PIC_LIST_1]; rIdx ++)
709	{
710	cIdx = m_RefPicListModification.getRefPicListModificationFlagL1() ? m_RefPicListModification.getRefPicSetIdxL1(rIdx) : rIdx % numPocTotalCurr;
711	assert(cIdx >= 0 && cIdx < numPocTotalCurr);
712	m_apcRefPicList[REF_PIC_LIST_1][rIdx] = rpsCurrList1[ cIdx ];
713	m_bIsUsedAsLongTerm[REF_PIC_LIST_1][rIdx] = ( cIdx >= NumPocStCurr0 + NumPocStCurr1 );
714	}
715	}
716	}
717
718	Int TComSlice::getNumRpsCurrTempList()
719	{
720	Int numRpsCurrTempList = 0;
721
722	#if SVC_EXTENSION
723	if( m_eSliceType == I_SLICE \|\| ( m_layerId &&
724	(m_eNalUnitType >= NAL_UNIT_CODED_SLICE_BLA_W_LP) &&
725	(m_eNalUnitType <= NAL_UNIT_CODED_SLICE_CRA) ) )
726	#else
727	if (m_eSliceType == I_SLICE)
728	#endif
729	{
730	#if SVC_EXTENSION
731	return m_activeNumILRRefIdx;
732	#else
733	return 0;
734	#endif
735	}
736	for(UInt i=0; i < m_pcRPS->getNumberOfNegativePictures()+ m_pcRPS->getNumberOfPositivePictures() + m_pcRPS->getNumberOfLongtermPictures(); i++)
737	{
738	if(m_pcRPS->getUsed(i))
739	{
740	numRpsCurrTempList++;
741	}
742	}
743	#if SVC_EXTENSION
744	if( m_layerId > 0 )
745	{
746	numRpsCurrTempList += m_activeNumILRRefIdx;
747	}
748	#endif
749
750	return numRpsCurrTempList;
751	}
752
753	Void TComSlice::initEqualRef()
754	{
755	for (Int iDir = 0; iDir < NUM_REF_PIC_LIST_01; iDir++)
756	{
757	for (Int iRefIdx1 = 0; iRefIdx1 < MAX_NUM_REF; iRefIdx1++)
758	{
759	for (Int iRefIdx2 = iRefIdx1; iRefIdx2 < MAX_NUM_REF; iRefIdx2++)
760	{
761	m_abEqualRef[iDir][iRefIdx1][iRefIdx2] = m_abEqualRef[iDir][iRefIdx2][iRefIdx1] = (iRefIdx1 == iRefIdx2? true : false);
762	}
763	}
764	}
765	}
766
767	Void TComSlice::checkColRefIdx(UInt curSliceIdx, TComPic* pic)
768	{
769	Int i;
770	TComSlice* curSlice = pic->getSlice(curSliceIdx);
771	Int currColRefPOC = curSlice->getRefPOC( RefPicList(1 - curSlice->getColFromL0Flag()), curSlice->getColRefIdx());
772	TComSlice* preSlice;
773	Int preColRefPOC;
774	for(i=curSliceIdx-1; i>=0; i--)
775	{
776	preSlice = pic->getSlice(i);
777	if(preSlice->getSliceType() != I_SLICE)
778	{
779	preColRefPOC = preSlice->getRefPOC( RefPicList(1 - preSlice->getColFromL0Flag()), preSlice->getColRefIdx());
780	if(currColRefPOC != preColRefPOC)
781	{
782	printf("Collocated_ref_idx shall always be the same for all slices of a coded picture!\n");
783	exit(EXIT_FAILURE);
784	}
785	else
786	{
787	break;
788	}
789	}
790	}
791	}
792
793	Void TComSlice::checkCRA(TComReferencePictureSet pReferencePictureSet, Int& pocCRA, NalUnitType& associatedIRAPType, TComList<TComPic >& rcListPic)
794	{
795	for(Int i = 0; i < pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures(); i++)
796	{
797	if(pocCRA < MAX_UINT && getPOC() > pocCRA)
798	{
799	assert(getPOC()+pReferencePictureSet->getDeltaPOC(i) >= pocCRA);
800	}
801	}
802	for(Int i = pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures(); i < pReferencePictureSet->getNumberOfPictures(); i++)
803	{
804	if(pocCRA < MAX_UINT && getPOC() > pocCRA)
805	{
806	if (!pReferencePictureSet->getCheckLTMSBPresent(i))
807	{
808	assert(xGetLongTermRefPic(rcListPic, pReferencePictureSet->getPOC(i), false)->getPOC() >= pocCRA);
809	}
810	else
811	{
812	assert(pReferencePictureSet->getPOC(i) >= pocCRA);
813	}
814	}
815	}
816	if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL \|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ) // IDR picture found
817	{
818	pocCRA = getPOC();
819	associatedIRAPType = getNalUnitType();
820	}
821	else if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA ) // CRA picture found
822	{
823	pocCRA = getPOC();
824	associatedIRAPType = getNalUnitType();
825	}
826	else if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
827	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
828	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP ) // BLA picture found
829	{
830	pocCRA = getPOC();
831	associatedIRAPType = getNalUnitType();
832	}
833	}
834
835	/** Function for marking the reference pictures when an IDR/CRA/CRANT/BLA/BLANT is encountered.
836	* \param pocCRA POC of the CRA/CRANT/BLA/BLANT picture
837	* \param bRefreshPending flag indicating if a deferred decoding refresh is pending
838	* \param rcListPic reference to the reference picture list
839	* This function marks the reference pictures as "unused for reference" in the following conditions.
840	* If the nal_unit_type is IDR/BLA/BLANT, all pictures in the reference picture list
841	* are marked as "unused for reference"
842	* If the nal_unit_type is BLA/BLANT, set the pocCRA to the temporal reference of the current picture.
843	* Otherwise
844	* If the bRefreshPending flag is true (a deferred decoding refresh is pending) and the current
845	* temporal reference is greater than the temporal reference of the latest CRA/CRANT/BLA/BLANT picture (pocCRA),
846	* mark all reference pictures except the latest CRA/CRANT/BLA/BLANT picture as "unused for reference" and set
847	* the bRefreshPending flag to false.
848	* If the nal_unit_type is CRA/CRANT, set the bRefreshPending flag to true and pocCRA to the temporal
849	* reference of the current picture.
850	* Note that the current picture is already placed in the reference list and its marking is not changed.
851	* If the current picture has a nal_ref_idc that is not 0, it will remain marked as "used for reference".
852	*/
853	#if NO_CLRAS_OUTPUT_FLAG
854	Void TComSlice::decodingRefreshMarking( TComList<TComPic*>& rcListPic, Bool noClrasOutputFlag, UInt smallestLayerId )
855	{
856	if( !isIRAP() )
857	{
858	return;
859	}
860
861	Int pocCurr = getPOC();
862	TComPic* rpcPic = NULL;
863
864	// When the current picture is an IRAP picture with nuh_layer_id equal to 0 and NoClrasOutputFlag is equal to 1,
865	// all reference pictures with any value of nuh_layer_id currently in the DPB (if any) are marked as "unused for reference".
866	if (m_layerId == smallestLayerId && noClrasOutputFlag)
867	{
868	// mark all pictures for all layers as not used for reference
869	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
870	while( iterPic != rcListPic.end() )
871	{
872	rpcPic = *(iterPic);
873	if( rpcPic->getPOC() != pocCurr )
874	{
875	rpcPic->getSlice(0)->setReferenced(false);
876	}
877	iterPic++;
878	}
879	}
880
881	// When the current picture is an IRAP picture with NoRaslOutputFlag equal to 1,
882	// all reference pictures with nuh_layer_id equal to currPicLayerId currently in the DPB (if any) are marked as "unused for reference".
883	if( m_noRaslOutputFlag )
884	{
885	// mark all pictures of a current layer as not used for reference
886	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
887	while( iterPic != rcListPic.end() )
888	{
889	rpcPic = *(iterPic);
890	if( rpcPic->getPOC() != pocCurr && rpcPic->getLayerId() == m_layerId )
891	{
892	rpcPic->getSlice(0)->setReferenced(false);
893	}
894	iterPic++;
895	}
896	}
897	}
898
899	Void TComSlice::decodingRefreshMarking(Int& pocCRA, Bool& bRefreshPending, TComList<TComPic*>& rcListPic, Bool noClrasOutputFlag)
900	#else
901	Void TComSlice::decodingRefreshMarking(Int& pocCRA, Bool& bRefreshPending, TComList<TComPic*>& rcListPic)
902	#endif
903	{
904	TComPic* rpcPic;
905	Int pocCurr = getPOC();
906
907	if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
908	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
909	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
910	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
911	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ) // IDR or BLA picture
912	{
913	// mark all pictures as not used for reference
914	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
915	while (iterPic != rcListPic.end())
916	{
917	rpcPic = *(iterPic);
918	rpcPic->setCurrSliceIdx(0);
919	#if NO_CLRAS_OUTPUT_FLAG
920	#if POC_RESET_IDC_ENCODER
921	if (noClrasOutputFlag)
922	{
923	rpcPic->getSlice(0)->setReferenced(false); // all layers // TODO. This does not mark all layers
924	}
925	else
926	{
927	if (rpcPic->getLayerId() == m_layerId) rpcPic->getSlice(0)->setReferenced(false); // only current layer
928	}
929	#else
930	if (noClrasOutputFlag)
931	{
932	if (rpcPic->getPOC() != pocCurr) rpcPic->getSlice(0)->setReferenced(false); // all layers
933	}
934	else
935	{
936	if (rpcPic->getPOC() != pocCurr && rpcPic->getLayerId() == m_layerId) rpcPic->getSlice(0)->setReferenced(false); // only current layer
937	}
938	#endif
939	#else
940	if (rpcPic->getPOC() != pocCurr) rpcPic->getSlice(0)->setReferenced(false);
941	#endif
942	iterPic++;
943	}
944	#if POC_RESET_IDC_ENCODER
945	this->getPic()->getSlice(0)->setReferenced(true); // Mark the current picture back as refererced.
946	#endif
947	if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
948	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
949	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
950	{
951	pocCRA = pocCurr;
952	}
953	#if EFFICIENT_FIELD_IRAP
954	bRefreshPending = true;
955	#endif
956	}
957	else // CRA or No DR
958	{
959	#if EFFICIENT_FIELD_IRAP
960	if(getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_IDR_N_LP \|\| getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL)
961	{
962	if (bRefreshPending==true && pocCurr > m_iLastIDR) // IDR reference marking pending
963	{
964	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
965	while (iterPic != rcListPic.end())
966	{
967	rpcPic = *(iterPic);
968	if (rpcPic->getPOC() != pocCurr && rpcPic->getPOC() != m_iLastIDR)
969	{
970	rpcPic->getSlice(0)->setReferenced(false);
971	}
972	iterPic++;
973	}
974	bRefreshPending = false;
975	}
976	}
977	else
978	{
979	#endif
980	if (bRefreshPending==true && pocCurr > pocCRA) // CRA reference marking pending
981	{
982	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
983	while (iterPic != rcListPic.end())
984	{
985	rpcPic = *(iterPic);
986	if (rpcPic->getPOC() != pocCurr && rpcPic->getPOC() != pocCRA)
987	{
988	rpcPic->getSlice(0)->setReferenced(false);
989	}
990	iterPic++;
991	}
992	bRefreshPending = false;
993	}
994	#if EFFICIENT_FIELD_IRAP
995	}
996	#endif
997	if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA ) // CRA picture found
998	{
999	bRefreshPending = true;
1000	pocCRA = pocCurr;
1001	}
1002	}
1003	}
1004
1005	Void TComSlice::copySliceInfo(TComSlice *pSrc)
1006	{
1007	assert( pSrc != NULL );
1008
1009	Int i, j, k;
1010
1011	m_iPOC = pSrc->m_iPOC;
1012	m_eNalUnitType = pSrc->m_eNalUnitType;
1013	m_eSliceType = pSrc->m_eSliceType;
1014	m_iSliceQp = pSrc->m_iSliceQp;
1015	#if ADAPTIVE_QP_SELECTION
1016	m_iSliceQpBase = pSrc->m_iSliceQpBase;
1017	#endif
1018	m_ChromaQpAdjEnabled = pSrc->m_ChromaQpAdjEnabled;
1019	m_deblockingFilterDisable = pSrc->m_deblockingFilterDisable;
1020	m_deblockingFilterOverrideFlag = pSrc->m_deblockingFilterOverrideFlag;
1021	m_deblockingFilterBetaOffsetDiv2 = pSrc->m_deblockingFilterBetaOffsetDiv2;
1022	m_deblockingFilterTcOffsetDiv2 = pSrc->m_deblockingFilterTcOffsetDiv2;
1023
1024	for (i = 0; i < NUM_REF_PIC_LIST_01; i++)
1025	{
1026	m_aiNumRefIdx[i] = pSrc->m_aiNumRefIdx[i];
1027	}
1028
1029	for (i = 0; i < MAX_NUM_REF; i++)
1030	{
1031	m_list1IdxToList0Idx[i] = pSrc->m_list1IdxToList0Idx[i];
1032	}
1033
1034	m_bCheckLDC = pSrc->m_bCheckLDC;
1035	m_iSliceQpDelta = pSrc->m_iSliceQpDelta;
1036	for (UInt component = 0; component < MAX_NUM_COMPONENT; component++) m_iSliceChromaQpDelta[component] = pSrc->m_iSliceChromaQpDelta[component];
1037	for (i = 0; i < NUM_REF_PIC_LIST_01; i++)
1038	{
1039	for (j = 0; j < MAX_NUM_REF; j++)
1040	{
1041	m_apcRefPicList[i][j] = pSrc->m_apcRefPicList[i][j];
1042	m_aiRefPOCList[i][j] = pSrc->m_aiRefPOCList[i][j];
1043	m_bIsUsedAsLongTerm[i][j] = pSrc->m_bIsUsedAsLongTerm[i][j];
1044	}
1045	m_bIsUsedAsLongTerm[i][MAX_NUM_REF] = pSrc->m_bIsUsedAsLongTerm[i][MAX_NUM_REF];
1046	}
1047	m_iDepth = pSrc->m_iDepth;
1048
1049	// referenced slice
1050	m_bRefenced = pSrc->m_bRefenced;
1051
1052	// access channel
1053	#if SVC_EXTENSION
1054	m_pcVPS = pSrc->m_pcVPS;
1055	m_layerId = pSrc->m_layerId;
1056	m_activeNumILRRefIdx = pSrc->m_activeNumILRRefIdx;
1057	m_interLayerPredEnabledFlag = pSrc->m_interLayerPredEnabledFlag;
1058	memcpy( m_interLayerPredLayerIdc, pSrc->m_interLayerPredLayerIdc, sizeof( m_interLayerPredLayerIdc ) );
1059	#endif
1060	m_pcSPS = pSrc->m_pcSPS;
1061	m_pcPPS = pSrc->m_pcPPS;
1062	m_pcRPS = pSrc->m_pcRPS;
1063	m_iLastIDR = pSrc->m_iLastIDR;
1064
1065	m_pcPic = pSrc->m_pcPic;
1066
1067	m_colFromL0Flag = pSrc->m_colFromL0Flag;
1068	m_colRefIdx = pSrc->m_colRefIdx;
1069
1070	setLambdas(pSrc->getLambdas());
1071
1072	for (i = 0; i < NUM_REF_PIC_LIST_01; i++)
1073	{
1074	for (j = 0; j < MAX_NUM_REF; j++)
1075	{
1076	for (k =0; k < MAX_NUM_REF; k++)
1077	{
1078	m_abEqualRef[i][j][k] = pSrc->m_abEqualRef[i][j][k];
1079	}
1080	}
1081	}
1082
1083	m_uiTLayer = pSrc->m_uiTLayer;
1084	m_bTLayerSwitchingFlag = pSrc->m_bTLayerSwitchingFlag;
1085
1086	m_sliceMode = pSrc->m_sliceMode;
1087	m_sliceArgument = pSrc->m_sliceArgument;
1088	m_sliceCurStartCtuTsAddr = pSrc->m_sliceCurStartCtuTsAddr;
1089	m_sliceCurEndCtuTsAddr = pSrc->m_sliceCurEndCtuTsAddr;
1090	m_sliceIdx = pSrc->m_sliceIdx;
1091	m_sliceSegmentMode = pSrc->m_sliceSegmentMode;
1092	m_sliceSegmentArgument = pSrc->m_sliceSegmentArgument;
1093	m_sliceSegmentCurStartCtuTsAddr = pSrc->m_sliceSegmentCurStartCtuTsAddr;
1094	m_sliceSegmentCurEndCtuTsAddr = pSrc->m_sliceSegmentCurEndCtuTsAddr;
1095	m_nextSlice = pSrc->m_nextSlice;
1096	m_nextSliceSegment = pSrc->m_nextSliceSegment;
1097
1098	for ( UInt e=0 ; e<NUM_REF_PIC_LIST_01 ; e++ )
1099	{
1100	for ( UInt n=0 ; n<MAX_NUM_REF ; n++ )
1101	{
1102	memcpy(m_weightPredTable[e][n], pSrc->m_weightPredTable[e][n], sizeof(WPScalingParam)*MAX_NUM_COMPONENT );
1103	}
1104	}
1105
1106	for( UInt ch = 0 ; ch < MAX_NUM_CHANNEL_TYPE; ch++)
1107	{
1108	m_saoEnabledFlag[ch] = pSrc->m_saoEnabledFlag[ch];
1109	}
1110
1111	m_cabacInitFlag = pSrc->m_cabacInitFlag;
1112
1113	m_bLMvdL1Zero = pSrc->m_bLMvdL1Zero;
1114	m_LFCrossSliceBoundaryFlag = pSrc->m_LFCrossSliceBoundaryFlag;
1115	m_enableTMVPFlag = pSrc->m_enableTMVPFlag;
1116	m_maxNumMergeCand = pSrc->m_maxNumMergeCand;
1117	}
1118
1119
1120	Int TComSlice::m_prevTid0POC = 0;
1121
1122	/** Function for setting the slice's temporal layer ID and corresponding temporal_layer_switching_point_flag.
1123	* \param uiTLayer Temporal layer ID of the current slice
1124	* The decoder calls this function to set temporal_layer_switching_point_flag for each temporal layer based on
1125	* the SPS's temporal_id_nesting_flag and the parsed PPS. Then, current slice's temporal layer ID and
1126	* temporal_layer_switching_point_flag is set accordingly.
1127	*/
1128	Void TComSlice::setTLayerInfo( UInt uiTLayer )
1129	{
1130	m_uiTLayer = uiTLayer;
1131	}
1132
1133	/** Function for checking if this is a switching-point
1134	*/
1135	Bool TComSlice::isTemporalLayerSwitchingPoint(TComList<TComPic*>& rcListPic)
1136	{
1137	TComPic* rpcPic;
1138	// loop through all pictures in the reference picture buffer
1139	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1140	while ( iterPic != rcListPic.end())
1141	{
1142	rpcPic = *(iterPic++);
1143	if(rpcPic->getSlice(0)->isReferenced() && rpcPic->getPOC() != getPOC())
1144	{
1145	if(rpcPic->getTLayer() >= getTLayer())
1146	{
1147	return false;
1148	}
1149	}
1150	}
1151	return true;
1152	}
1153
1154	/** Function for checking if this is a STSA candidate
1155	*/
1156	Bool TComSlice::isStepwiseTemporalLayerSwitchingPointCandidate(TComList<TComPic*>& rcListPic)
1157	{
1158	TComPic* rpcPic;
1159
1160	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1161	while ( iterPic != rcListPic.end())
1162	{
1163	rpcPic = *(iterPic++);
1164	if(rpcPic->getSlice(0)->isReferenced() && (rpcPic->getUsedByCurr()==true) && rpcPic->getPOC() != getPOC())
1165	{
1166	if(rpcPic->getTLayer() >= getTLayer())
1167	{
1168	return false;
1169	}
1170	}
1171	}
1172	return true;
1173	}
1174
1175	#if POC_RESET_IDC_ENCODER
1176	Void TComSlice::checkLeadingPictureRestrictions(TComList<TComPic*>& rcListPic, Bool usePocBeforeReset)
1177	#else
1178	Void TComSlice::checkLeadingPictureRestrictions(TComList<TComPic*>& rcListPic)
1179	#endif
1180	{
1181	TComPic* rpcPic;
1182
1183	Int nalUnitType = this->getNalUnitType();
1184
1185	// When a picture is a leading picture, it shall be a RADL or RASL picture.
1186	if(this->getAssociatedIRAPPOC() > this->getPOC())
1187	{
1188	// Do not check IRAP pictures since they may get a POC lower than their associated IRAP
1189	if(nalUnitType < NAL_UNIT_CODED_SLICE_BLA_W_LP \|\|
1190	nalUnitType > NAL_UNIT_RESERVED_IRAP_VCL23)
1191	{
1192	assert(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N \|\|
1193	nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R \|\|
1194	nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N \|\|
1195	nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R);
1196	}
1197	}
1198
1199	// When a picture is a trailing picture, it shall not be a RADL or RASL picture.
1200	if(this->getAssociatedIRAPPOC() < this->getPOC())
1201	{
1202	assert(nalUnitType != NAL_UNIT_CODED_SLICE_RASL_N &&
1203	nalUnitType != NAL_UNIT_CODED_SLICE_RASL_R &&
1204	nalUnitType != NAL_UNIT_CODED_SLICE_RADL_N &&
1205	nalUnitType != NAL_UNIT_CODED_SLICE_RADL_R);
1206	}
1207
1208	// No RASL pictures shall be present in the bitstream that are associated
1209	// with a BLA picture having nal_unit_type equal to BLA_W_RADL or BLA_N_LP.
1210	if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N \|\|
1211	nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1212	{
1213	assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_W_RADL &&
1214	this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_N_LP);
1215	}
1216
1217	// No RASL pictures shall be present in the bitstream that are associated with
1218	// an IDR picture.
1219	if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N \|\|
1220	nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1221	{
1222	assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_N_LP &&
1223	this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_W_RADL);
1224	}
1225
1226	// No RADL pictures shall be present in the bitstream that are associated with
1227	// a BLA picture having nal_unit_type equal to BLA_N_LP or that are associated
1228	// with an IDR picture having nal_unit_type equal to IDR_N_LP.
1229	if(nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N \|\|
1230	nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R)
1231	{
1232	assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_N_LP &&
1233	this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_N_LP);
1234	}
1235
1236	// loop through all pictures in the reference picture buffer
1237	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1238	while ( iterPic != rcListPic.end())
1239	{
1240	rpcPic = *(iterPic++);
1241	#if BUGFIX_INTRAPERIOD
1242	if(!rpcPic->getReconMark())
1243	{
1244	continue;
1245	}
1246	#endif
1247	if (rpcPic->getPOC() == this->getPOC())
1248	{
1249	continue;
1250	}
1251
1252	// Any picture that has PicOutputFlag equal to 1 that precedes an IRAP picture
1253	// in decoding order shall precede the IRAP picture in output order.
1254	// (Note that any picture following in output order would be present in the DPB)
1255	if(rpcPic->getSlice(0)->getPicOutputFlag() == 1 && !this->getNoOutputPriorPicsFlag())
1256	{
1257	if(nalUnitType == NAL_UNIT_CODED_SLICE_BLA_N_LP \|\|
1258	nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_LP \|\|
1259	nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_RADL \|\|
1260	nalUnitType == NAL_UNIT_CODED_SLICE_CRA \|\|
1261	nalUnitType == NAL_UNIT_CODED_SLICE_IDR_N_LP \|\|
1262	nalUnitType == NAL_UNIT_CODED_SLICE_IDR_W_RADL)
1263	{
1264	#if POC_RESET_IDC_ENCODER
1265	if( usePocBeforeReset )
1266	{
1267	assert(rpcPic->getSlice(0)->getPocValueBeforeReset() < this->getPocValueBeforeReset());
1268	}
1269	else
1270	{
1271	assert(rpcPic->getPOC() < this->getPOC());
1272	}
1273	#else
1274	assert(rpcPic->getPOC() < this->getPOC());
1275	#endif
1276	}
1277	}
1278
1279	// Any picture that has PicOutputFlag equal to 1 that precedes an IRAP picture
1280	// in decoding order shall precede any RADL picture associated with the IRAP
1281	// picture in output order.
1282	if(rpcPic->getSlice(0)->getPicOutputFlag() == 1)
1283	{
1284	if((nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N \|\|
1285	nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R))
1286	{
1287	// rpcPic precedes the IRAP in decoding order
1288	if(this->getAssociatedIRAPPOC() > rpcPic->getSlice(0)->getAssociatedIRAPPOC())
1289	{
1290	// rpcPic must not be the IRAP picture
1291	if(this->getAssociatedIRAPPOC() != rpcPic->getPOC())
1292	{
1293	#if POC_RESET_IDC_ENCODER
1294	if( usePocBeforeReset )
1295	{
1296	assert(rpcPic->getSlice(0)->getPocValueBeforeReset() < this->getPocValueBeforeReset());
1297	}
1298	else
1299	{
1300	assert(rpcPic->getPOC() < this->getPOC());
1301	}
1302	#else
1303	assert(rpcPic->getPOC() < this->getPOC());
1304	#endif
1305	}
1306	}
1307	}
1308	}
1309
1310	// When a picture is a leading picture, it shall precede, in decoding order,
1311	// all trailing pictures that are associated with the same IRAP picture.
1312	if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N \|\|
1313	nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R \|\|
1314	nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N \|\|
1315	nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R)
1316	{
1317	if(rpcPic->getSlice(0)->getAssociatedIRAPPOC() == this->getAssociatedIRAPPOC())
1318	{
1319	// rpcPic is a picture that preceded the leading in decoding order since it exist in the DPB
1320	// rpcPic would violate the constraint if it was a trailing picture
1321	#if POC_RESET_IDC_ENCODER
1322	if( usePocBeforeReset )
1323	{
1324	assert(rpcPic->getPOC() <= this->getAssociatedIrapPocBeforeReset());
1325	}
1326	else
1327	{
1328	assert(rpcPic->getPOC() <= this->getAssociatedIRAPPOC());
1329	}
1330	#else
1331	assert(rpcPic->getPOC() <= this->getAssociatedIRAPPOC());
1332	#endif
1333	}
1334	}
1335
1336	// Any RASL picture associated with a CRA or BLA picture shall precede any
1337	// RADL picture associated with the CRA or BLA picture in output order
1338	if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N \|\|
1339	nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1340	{
1341	if((this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_N_LP \|\|
1342	this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_W_LP \|\|
1343	this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL \|\|
1344	this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_CRA) &&
1345	this->getAssociatedIRAPPOC() == rpcPic->getSlice(0)->getAssociatedIRAPPOC())
1346	{
1347	if(rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N \|\|
1348	rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_R)
1349	{
1350	assert(rpcPic->getPOC() > this->getPOC());
1351	}
1352	}
1353	}
1354
1355	// Any RASL picture associated with a CRA picture shall follow, in output
1356	// order, any IRAP picture that precedes the CRA picture in decoding order.
1357	if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N \|\|
1358	nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1359	{
1360	if(this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_CRA)
1361	{
1362	if(rpcPic->getSlice(0)->getPOC() < this->getAssociatedIRAPPOC() &&
1363	(rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP \|\|
1364	rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP \|\|
1365	rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL \|\|
1366	rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP \|\|
1367	rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL \|\|
1368	rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA))
1369	{
1370	assert(this->getPOC() > rpcPic->getSlice(0)->getPOC());
1371	}
1372	}
1373	}
1374	}
1375	}
1376
1377
1378
1379	/** Function for applying picture marking based on the Reference Picture Set in pReferencePictureSet.
1380	*/
1381	Void TComSlice::applyReferencePictureSet( TComList<TComPic>& rcListPic, TComReferencePictureSet pReferencePictureSet)
1382	{
1383	TComPic* rpcPic;
1384	Int i, isReference;
1385
1386	#if !ALIGNED_BUMPING
1387	checkLeadingPictureRestrictions(rcListPic);
1388	#endif
1389
1390	// loop through all pictures in the reference picture buffer
1391	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1392	while ( iterPic != rcListPic.end())
1393	{
1394	rpcPic = *(iterPic++);
1395
1396	if(!rpcPic->getSlice( 0 )->isReferenced())
1397	{
1398	continue;
1399	}
1400
1401	isReference = 0;
1402	// loop through all pictures in the Reference Picture Set
1403	// to see if the picture should be kept as reference picture
1404	for(i=0;i<pReferencePictureSet->getNumberOfPositivePictures()+pReferencePictureSet->getNumberOfNegativePictures();i++)
1405	{
1406	if(!rpcPic->getIsLongTerm() && rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i))
1407	{
1408	isReference = 1;
1409	rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1410	rpcPic->setIsLongTerm(0);
1411	}
1412	}
1413	for(;i<pReferencePictureSet->getNumberOfPictures();i++)
1414	{
1415	if(pReferencePictureSet->getCheckLTMSBPresent(i)==true)
1416	{
1417	if(rpcPic->getIsLongTerm() && (rpcPic->getPicSym()->getSlice(0)->getPOC()) == pReferencePictureSet->getPOC(i))
1418	{
1419	isReference = 1;
1420	rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1421	}
1422	}
1423	else
1424	{
1425	Int pocCycle = 1<<rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
1426	Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC() & (pocCycle-1);
1427	Int refPoc = pReferencePictureSet->getPOC(i) & (pocCycle-1);
1428	if(rpcPic->getIsLongTerm() && curPoc == refPoc)
1429	{
1430	isReference = 1;
1431	rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1432	}
1433	}
1434
1435	}
1436	#if DISCARDABLE_PIC_RPS
1437	if( isReference ) // Current picture is in the temporal RPS
1438	{
1439	assert( rpcPic->getSlice(0)->getDiscardableFlag() == 0 ); // Temporal RPS shall not contain picture with discardable_flag equal to 1
1440	}
1441	#endif
1442	// mark the picture as "unused for reference" if it is not in
1443	// the Reference Picture Set
1444	if(rpcPic->getPicSym()->getSlice(0)->getPOC() != this->getPOC() && isReference == 0)
1445	{
1446	rpcPic->getSlice( 0 )->setReferenced( false );
1447	rpcPic->setUsedByCurr(0);
1448	rpcPic->setIsLongTerm(0);
1449	}
1450	//check that pictures of higher temporal layers are not used
1451	assert(rpcPic->getSlice( 0 )->isReferenced()==0\|\|rpcPic->getUsedByCurr()==0\|\|rpcPic->getTLayer()<=this->getTLayer());
1452	//check that pictures of higher or equal temporal layer are not in the RPS if the current picture is a TSA picture
1453	if(this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_R \|\| this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N)
1454	{
1455	assert(rpcPic->getSlice( 0 )->isReferenced()==0\|\|rpcPic->getTLayer()<this->getTLayer());
1456	}
1457	//check that pictures marked as temporal layer non-reference pictures are not used for reference
1458	if(rpcPic->getPicSym()->getSlice(0)->getPOC() != this->getPOC() && rpcPic->getTLayer()==this->getTLayer())
1459	{
1460	assert(rpcPic->getSlice( 0 )->isReferenced()==0\|\|rpcPic->getUsedByCurr()==0\|\|rpcPic->getSlice( 0 )->getTemporalLayerNonReferenceFlag()==false);
1461	}
1462	}
1463	}
1464
1465	/** Function for applying picture marking based on the Reference Picture Set in pReferencePictureSet.
1466	*/
1467	#if ALLOW_RECOVERY_POINT_AS_RAP
1468	Int TComSlice::checkThatAllRefPicsAreAvailable( TComList<TComPic>& rcListPic, TComReferencePictureSet pReferencePictureSet, Bool printErrors, Int pocRandomAccess, Bool bUseRecoveryPoint)
1469	#else
1470	Int TComSlice::checkThatAllRefPicsAreAvailable( TComList<TComPic>& rcListPic, TComReferencePictureSet pReferencePictureSet, Bool printErrors, Int pocRandomAccess)
1471	#endif
1472	{
1473	#if ALLOW_RECOVERY_POINT_AS_RAP
1474	Int atLeastOneUnabledByRecoveryPoint = 0;
1475	Int atLeastOneFlushedByPreviousIDR = 0;
1476	#endif
1477	TComPic* rpcPic;
1478	Int i, isAvailable;
1479	Int atLeastOneLost = 0;
1480	Int atLeastOneRemoved = 0;
1481	Int iPocLost = 0;
1482
1483	// loop through all long-term pictures in the Reference Picture Set
1484	// to see if the picture should be kept as reference picture
1485	for(i=pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();i<pReferencePictureSet->getNumberOfPictures();i++)
1486	{
1487	isAvailable = 0;
1488	// loop through all pictures in the reference picture buffer
1489	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1490	while ( iterPic != rcListPic.end())
1491	{
1492	rpcPic = *(iterPic++);
1493	if(pReferencePictureSet->getCheckLTMSBPresent(i)==true)
1494	{
1495	if(rpcPic->getIsLongTerm() && (rpcPic->getPicSym()->getSlice(0)->getPOC()) == pReferencePictureSet->getPOC(i) && rpcPic->getSlice(0)->isReferenced())
1496	{
1497	#if ALLOW_RECOVERY_POINT_AS_RAP
1498	if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + pReferencePictureSet->getDeltaPOC(i) < pocRandomAccess)
1499	{
1500	isAvailable = 0;
1501	}
1502	else
1503	{
1504	isAvailable = 1;
1505	}
1506	#else
1507	isAvailable = 1;
1508	#endif
1509	}
1510	}
1511	else
1512	{
1513	Int pocCycle = 1<<rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
1514	Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC() & (pocCycle-1);
1515	Int refPoc = pReferencePictureSet->getPOC(i) & (pocCycle-1);
1516	if(rpcPic->getIsLongTerm() && curPoc == refPoc && rpcPic->getSlice(0)->isReferenced())
1517	{
1518	#if ALLOW_RECOVERY_POINT_AS_RAP
1519	if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + pReferencePictureSet->getDeltaPOC(i) < pocRandomAccess)
1520	{
1521	isAvailable = 0;
1522	}
1523	else
1524	{
1525	isAvailable = 1;
1526	}
1527	#else
1528	isAvailable = 1;
1529	#endif
1530	}
1531	}
1532	}
1533	// if there was no such long-term check the short terms
1534	if(!isAvailable)
1535	{
1536	iterPic = rcListPic.begin();
1537	while ( iterPic != rcListPic.end())
1538	{
1539	rpcPic = *(iterPic++);
1540
1541	Int pocCycle = 1 << rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
1542	Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC();
1543	Int refPoc = pReferencePictureSet->getPOC(i);
1544	if (!pReferencePictureSet->getCheckLTMSBPresent(i))
1545	{
1546	curPoc = curPoc & (pocCycle - 1);
1547	refPoc = refPoc & (pocCycle - 1);
1548	}
1549
1550	if (rpcPic->getSlice(0)->isReferenced() && curPoc == refPoc)
1551	{
1552	#if ALLOW_RECOVERY_POINT_AS_RAP
1553	if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + pReferencePictureSet->getDeltaPOC(i) < pocRandomAccess)
1554	{
1555	isAvailable = 0;
1556	}
1557	else
1558	{
1559	isAvailable = 1;
1560	rpcPic->setIsLongTerm(1);
1561	break;
1562	}
1563	#else
1564	isAvailable = 1;
1565	rpcPic->setIsLongTerm(1);
1566	break;
1567	#endif
1568	}
1569	}
1570	}
1571	// report that a picture is lost if it is in the Reference Picture Set
1572	// but not available as reference picture
1573	if(isAvailable == 0)
1574	{
1575	if (this->getPOC() + pReferencePictureSet->getDeltaPOC(i) >= pocRandomAccess)
1576	{
1577	if(!pReferencePictureSet->getUsed(i) )
1578	{
1579	if(printErrors)
1580	{
1581	printf("\nLong-term reference picture with POC = %3d seems to have been removed or not correctly decoded.", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1582	}
1583	atLeastOneRemoved = 1;
1584	}
1585	else
1586	{
1587	if(printErrors)
1588	{
1589	printf("\nLong-term reference picture with POC = %3d is lost or not correctly decoded!", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1590	}
1591	atLeastOneLost = 1;
1592	iPocLost=this->getPOC() + pReferencePictureSet->getDeltaPOC(i);
1593	}
1594	}
1595	#if ALLOW_RECOVERY_POINT_AS_RAP
1596	else if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess)
1597	{
1598	atLeastOneUnabledByRecoveryPoint = 1;
1599	}
1600	else if(bUseRecoveryPoint && (this->getAssociatedIRAPType()==NAL_UNIT_CODED_SLICE_IDR_N_LP \|\| this->getAssociatedIRAPType()==NAL_UNIT_CODED_SLICE_IDR_W_RADL))
1601	{
1602	atLeastOneFlushedByPreviousIDR = 1;
1603	}
1604	#endif
1605	}
1606	}
1607	// loop through all short-term pictures in the Reference Picture Set
1608	// to see if the picture should be kept as reference picture
1609	for(i=0;i<pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();i++)
1610	{
1611	isAvailable = 0;
1612	// loop through all pictures in the reference picture buffer
1613	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1614	while ( iterPic != rcListPic.end())
1615	{
1616	rpcPic = *(iterPic++);
1617
1618	if(!rpcPic->getIsLongTerm() && rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i) && rpcPic->getSlice(0)->isReferenced())
1619	{
1620	#if ALLOW_RECOVERY_POINT_AS_RAP
1621	if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + pReferencePictureSet->getDeltaPOC(i) < pocRandomAccess)
1622	{
1623	isAvailable = 0;
1624	}
1625	else
1626	{
1627	isAvailable = 1;
1628	}
1629	#else
1630	isAvailable = 1;
1631	#endif
1632	}
1633	}
1634	// report that a picture is lost if it is in the Reference Picture Set
1635	// but not available as reference picture
1636	if(isAvailable == 0)
1637	{
1638	#if !UNAVAILABLE_PIC_BUGFIX
1639	if (this->getPOC() + pReferencePictureSet->getDeltaPOC(i) >= pocRandomAccess)
1640	#endif
1641	{
1642	if(!pReferencePictureSet->getUsed(i) )
1643	{
1644	if(printErrors)
1645	{
1646	printf("\nShort-term reference picture with POC = %3d seems to have been removed or not correctly decoded.", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1647	}
1648	atLeastOneRemoved = 1;
1649	}
1650	else
1651	{
1652	if(printErrors)
1653	{
1654	printf("\nShort-term reference picture with POC = %3d is lost or not correctly decoded!", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1655	}
1656	atLeastOneLost = 1;
1657	iPocLost=this->getPOC() + pReferencePictureSet->getDeltaPOC(i);
1658	}
1659	}
1660	#if ALLOW_RECOVERY_POINT_AS_RAP
1661	#if UNAVAILABLE_PIC_BUGFIX
1662	if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess)
1663	#else
1664	else if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess)
1665	#endif
1666	{
1667	atLeastOneUnabledByRecoveryPoint = 1;
1668	}
1669	else if(bUseRecoveryPoint && (this->getAssociatedIRAPType()==NAL_UNIT_CODED_SLICE_IDR_N_LP \|\| this->getAssociatedIRAPType()==NAL_UNIT_CODED_SLICE_IDR_W_RADL))
1670	{
1671	atLeastOneFlushedByPreviousIDR = 1;
1672	}
1673	#endif
1674	}
1675	}
1676
1677	#if ALLOW_RECOVERY_POINT_AS_RAP
1678	if(atLeastOneUnabledByRecoveryPoint \|\| atLeastOneFlushedByPreviousIDR)
1679	{
1680	return -1;
1681	}
1682	#endif
1683	if(atLeastOneLost)
1684	{
1685	return iPocLost+1;
1686	}
1687	if(atLeastOneRemoved)
1688	{
1689	return -2;
1690	}
1691	else
1692	{
1693	return 0;
1694	}
1695	}
1696
1697	/** Function for constructing an explicit Reference Picture Set out of the available pictures in a referenced Reference Picture Set
1698	*/
1699	#if ALLOW_RECOVERY_POINT_AS_RAP
1700	Void TComSlice::createExplicitReferencePictureSetFromReference( TComList<TComPic>& rcListPic, TComReferencePictureSet pReferencePictureSet, Bool isRAP, Int pocRandomAccess, Bool bUseRecoveryPoint)
1701	#else
1702	Void TComSlice::createExplicitReferencePictureSetFromReference( TComList<TComPic>& rcListPic, TComReferencePictureSet pReferencePictureSet, Bool isRAP)
1703	#endif
1704	{
1705	TComPic* rpcPic;
1706	Int i, j;
1707	Int k = 0;
1708	Int nrOfNegativePictures = 0;
1709	Int nrOfPositivePictures = 0;
1710	TComReferencePictureSet* pcRPS = this->getLocalRPS();
1711	#if EFFICIENT_FIELD_IRAP
1712	Bool irapIsInRPS = false;
1713	#endif
1714	#if P0297_VPS_POC_LSB_ALIGNED_FLAG
1715	Bool pocsAdjusted = false;
1716	#endif
1717
1718	// loop through all pictures in the Reference Picture Set
1719	for(i=0;i<pReferencePictureSet->getNumberOfPictures();i++)
1720	{
1721	j = 0;
1722	// loop through all pictures in the reference picture buffer
1723	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1724	while ( iterPic != rcListPic.end())
1725	{
1726	j++;
1727	rpcPic = *(iterPic++);
1728
1729	#if P0297_VPS_POC_LSB_ALIGNED_FLAG
1730	// poc adjustement by poc reset needs to be taken into account here
1731	Int deltaPOC = pReferencePictureSet->getDeltaPOC(i) - rpcPic->getPicSym()->getSlice(0)->getPocResetDeltaPoc();
1732	if (rpcPic->getPicSym()->getSlice(0)->getPocResetDeltaPoc() != 0)
1733	{
1734	pocsAdjusted = true;
1735	}
1736
1737	if (rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + deltaPOC && rpcPic->getSlice(0)->isReferenced())
1738	#else
1739	if(rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i) && rpcPic->getSlice(0)->isReferenced())
1740	#endif
1741	{
1742	// This picture exists as a reference picture
1743	// and should be added to the explicit Reference Picture Set
1744	#if P0297_VPS_POC_LSB_ALIGNED_FLAG
1745	pcRPS->setDeltaPOC(k, deltaPOC);
1746	#else
1747	pcRPS->setDeltaPOC(k, pReferencePictureSet->getDeltaPOC(i));
1748	#endif
1749	pcRPS->setUsed(k, pReferencePictureSet->getUsed(i) && (!isRAP));
1750	#if ALLOW_RECOVERY_POINT_AS_RAP
1751	#if P0297_VPS_POC_LSB_ALIGNED_FLAG
1752	pcRPS->setUsed(k, pcRPS->getUsed(k) && !(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + deltaPOC < pocRandomAccess) );
1753	#else
1754	pcRPS->setUsed(k, pcRPS->getUsed(k) && !(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + pReferencePictureSet->getDeltaPOC(i) < pocRandomAccess) );
1755	#endif
1756	#endif
1757	if(pcRPS->getDeltaPOC(k) < 0)
1758	{
1759	nrOfNegativePictures++;
1760	}
1761	else
1762	{
1763	#if EFFICIENT_FIELD_IRAP
1764	if(rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getAssociatedIRAPPOC() && this->getAssociatedIRAPPOC() == this->getPOC()+1)
1765	{
1766	irapIsInRPS = true;
1767	}
1768	#endif
1769	nrOfPositivePictures++;
1770	}
1771	k++;
1772	}
1773	}
1774	}
1775
1776	#if EFFICIENT_FIELD_IRAP
1777	Bool useNewRPS = false;
1778	// if current picture is complimentary field associated to IRAP, add the IRAP to its RPS.
1779	if(m_pcPic->isField() && !irapIsInRPS)
1780	{
1781	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1782	while ( iterPic != rcListPic.end())
1783	{
1784	rpcPic = *(iterPic++);
1785	if(rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getAssociatedIRAPPOC() && this->getAssociatedIRAPPOC() == this->getPOC()+1)
1786	{
1787	pcRPS->setDeltaPOC(k, 1);
1788	pcRPS->setUsed(k, true);
1789	nrOfPositivePictures++;
1790	k ++;
1791	useNewRPS = true;
1792	}
1793	}
1794	}
1795	#endif
1796	pcRPS->setNumberOfNegativePictures(nrOfNegativePictures);
1797	pcRPS->setNumberOfPositivePictures(nrOfPositivePictures);
1798	pcRPS->setNumberOfPictures(nrOfNegativePictures+nrOfPositivePictures);
1799	// This is a simplistic inter rps example. A smarter encoder will look for a better reference RPS to do the
1800	// inter RPS prediction with. Here we just use the reference used by pReferencePictureSet.
1801	// If pReferencePictureSet is not inter_RPS_predicted, then inter_RPS_prediction is for the current RPS also disabled.
1802	if (!pReferencePictureSet->getInterRPSPrediction()
1803	#if EFFICIENT_FIELD_IRAP
1804	\|\| useNewRPS
1805	#endif
1806	#if P0297_VPS_POC_LSB_ALIGNED_FLAG
1807	\|\| pocsAdjusted // inter RPS prediction does not work if POCs have been adjusted
1808	#endif
1809	)
1810	{
1811	pcRPS->setInterRPSPrediction(false);
1812	pcRPS->setNumRefIdc(0);
1813	}
1814	else
1815	{
1816	Int rIdx = this->getRPSidx() - pReferencePictureSet->getDeltaRIdxMinus1() - 1;
1817	Int deltaRPS = pReferencePictureSet->getDeltaRPS();
1818	TComReferencePictureSet* pcRefRPS = this->getSPS()->getRPSList()->getReferencePictureSet(rIdx);
1819	Int iRefPics = pcRefRPS->getNumberOfPictures();
1820	Int iNewIdc=0;
1821	for(i=0; i<= iRefPics; i++)
1822	{
1823	Int deltaPOC = ((i != iRefPics)? pcRefRPS->getDeltaPOC(i) : 0); // check if the reference abs POC is >= 0
1824	Int iRefIdc = 0;
1825	for (j=0; j < pcRPS->getNumberOfPictures(); j++) // loop through the pictures in the new RPS
1826	{
1827	if ( (deltaPOC + deltaRPS) == pcRPS->getDeltaPOC(j))
1828	{
1829	if (pcRPS->getUsed(j))
1830	{
1831	iRefIdc = 1;
1832	}
1833	else
1834	{
1835	iRefIdc = 2;
1836	}
1837	}
1838	}
1839	pcRPS->setRefIdc(i, iRefIdc);
1840	iNewIdc++;
1841	}
1842	pcRPS->setInterRPSPrediction(true);
1843	pcRPS->setNumRefIdc(iNewIdc);
1844	pcRPS->setDeltaRPS(deltaRPS);
1845	pcRPS->setDeltaRIdxMinus1(pReferencePictureSet->getDeltaRIdxMinus1() + this->getSPS()->getRPSList()->getNumberOfReferencePictureSets() - this->getRPSidx());
1846	}
1847
1848	this->setRPS(pcRPS);
1849	this->setRPSidx(-1);
1850	}
1851
1852	/** get AC and DC values for weighted pred
1853	* \param *wp
1854	* \returns Void
1855	*/
1856	Void TComSlice::getWpAcDcParam(WPACDCParam *&wp)
1857	{
1858	wp = m_weightACDCParam;
1859	}
1860
1861	/** init AC and DC values for weighted pred
1862	* \returns Void
1863	*/
1864	Void TComSlice::initWpAcDcParam()
1865	{
1866	for(Int iComp = 0; iComp < MAX_NUM_COMPONENT; iComp++ )
1867	{
1868	m_weightACDCParam[iComp].iAC = 0;
1869	m_weightACDCParam[iComp].iDC = 0;
1870	}
1871	}
1872
1873	/** get WP tables for weighted pred
1874	* \param RefPicList
1875	* \param iRefIdx
1876	* \param *&WPScalingParam
1877	* \returns Void
1878	*/
1879	Void TComSlice::getWpScaling( RefPicList e, Int iRefIdx, WPScalingParam *&wp )
1880	{
1881	assert (e<NUM_REF_PIC_LIST_01);
1882	wp = m_weightPredTable[e][iRefIdx];
1883	}
1884
1885	/** reset Default WP tables settings : no weight.
1886	* \param WPScalingParam
1887	* \returns Void
1888	*/
1889	Void TComSlice::resetWpScaling()
1890	{
1891	for ( Int e=0 ; e<NUM_REF_PIC_LIST_01 ; e++ )
1892	{
1893	for ( Int i=0 ; i<MAX_NUM_REF ; i++ )
1894	{
1895	for ( Int yuv=0 ; yuv<MAX_NUM_COMPONENT ; yuv++ )
1896	{
1897	WPScalingParam *pwp = &(m_weightPredTable[e][i][yuv]);
1898	pwp->bPresentFlag = false;
1899	pwp->uiLog2WeightDenom = 0;
1900	pwp->uiLog2WeightDenom = 0;
1901	pwp->iWeight = 1;
1902	pwp->iOffset = 0;
1903	}
1904	}
1905	}
1906	}
1907
1908	/** init WP table
1909	* \returns Void
1910	*/
1911	Void TComSlice::initWpScaling()
1912	{
1913	const Bool bUseHighPrecisionPredictionWeighting = getSPS()->getUseHighPrecisionPredictionWeighting();
1914	for ( Int e=0 ; e<NUM_REF_PIC_LIST_01 ; e++ )
1915	{
1916	for ( Int i=0 ; i<MAX_NUM_REF ; i++ )
1917	{
1918	for ( Int yuv=0 ; yuv<MAX_NUM_COMPONENT ; yuv++ )
1919	{
1920	WPScalingParam *pwp = &(m_weightPredTable[e][i][yuv]);
1921	if ( !pwp->bPresentFlag )
1922	{
1923	// Inferring values not present :
1924	pwp->iWeight = (1 << pwp->uiLog2WeightDenom);
1925	pwp->iOffset = 0;
1926	}
1927
1928	const Int offsetScalingFactor = bUseHighPrecisionPredictionWeighting ? 1 : (1 << (g_bitDepth[toChannelType(ComponentID(yuv))]-8));
1929
1930	pwp->w = pwp->iWeight;
1931	pwp->o = pwp->iOffset * offsetScalingFactor; //NOTE: This value of the ".o" variable is never used - .o is set immediately before it gets used
1932	pwp->shift = pwp->uiLog2WeightDenom;
1933	pwp->round = (pwp->uiLog2WeightDenom>=1) ? (1 << (pwp->uiLog2WeightDenom-1)) : (0);
1934	}
1935	}
1936	}
1937	}
1938
1939	// ------------------------------------------------------------------------------------------------
1940	// Video parameter set (VPS)
1941	// ------------------------------------------------------------------------------------------------
1942	#if SVC_EXTENSION
1943	TComVPS::TComVPS()
1944	: m_VPSId ( 0)
1945	, m_uiMaxTLayers ( 1)
1946	, m_uiMaxLayers ( 1)
1947	, m_bTemporalIdNestingFlag (false)
1948	, m_numHrdParameters ( 0)
1949	, m_hrdParameters (NULL)
1950	, m_hrdOpSetIdx (NULL)
1951	, m_cprmsPresentFlag (NULL)
1952	, m_baseLayerInternalFlag (true)
1953	, m_baseLayerAvailableFlag (true)
1954	, m_maxLayerId (0)
1955	, m_numLayerSets (0)
1956	, m_numOutputLayerSets (0)
1957	, m_numProfileTierLevel (0)
1958	, m_numAddOutputLayerSets (0)
1959	, m_defaultTargetOutputLayerIdc(0)
1960	, m_bitRatePresentVpsFlag (false)
1961	, m_picRatePresentVpsFlag (false)
1962	#if REPN_FORMAT_IN_VPS
1963	, m_repFormatIdxPresentFlag (false)
1964	, m_vpsNumRepFormats (1)
1965	#endif
1966	#if VIEW_ID_RELATED_SIGNALING
1967	#if O0109_VIEW_ID_LEN
1968	, m_viewIdLen (0)
1969	#else
1970	, m_viewIdLenMinus1 (0)
1971	#endif
1972	#endif
1973	, m_vpsNonVuiExtLength (0)
1974	#if P0297_VPS_POC_LSB_ALIGNED_FLAG
1975	, m_vpsPocLsbAlignedFlag(false)
1976	#endif
1977	{
1978	for( Int i = 0; i < MAX_TLAYER; i++)
1979	{
1980	m_numReorderPics[i] = 0;
1981	m_uiMaxDecPicBuffering[i] = 1;
1982	m_uiMaxLatencyIncrease[i] = 0;
1983	}
1984
1985	m_nonHEVCBaseLayerFlag = false;
1986	m_splittingFlag = false;
1987	m_nuhLayerIdPresentFlag = false;
1988	::memset(m_scalabilityMask, 0, sizeof(m_scalabilityMask));
1989	::memset(m_dimensionIdLen, 0, sizeof(m_dimensionIdLen));
1990	::memset(m_layerIdInNuh, 0, sizeof(m_layerIdInNuh));
1991	::memset(m_dimensionId, 0, sizeof(m_dimensionId));
1992
1993	m_numScalabilityTypes = 0;
1994	::memset(m_layerIdxInVps, 0, sizeof(m_layerIdxInVps));
1995	::memset(m_profilePresentFlag, 0, sizeof(m_profilePresentFlag));
1996
1997	::memset(m_layerIdIncludedFlag, 0, sizeof(m_layerIdIncludedFlag));
1998	// Consider dynamic allocation for outputLayerSetIdx and outputLayerFlag
1999	::memset(m_outputLayerSetIdx, 0, sizeof(m_outputLayerSetIdx));
2000	::memset(m_outputLayerFlag, 0, sizeof(m_outputLayerFlag));
2001
2002	::memset(m_directDependencyFlag, 0, sizeof(m_directDependencyFlag));
2003	::memset(m_numDirectRefLayers, 0, sizeof(m_numDirectRefLayers ));
2004	::memset(m_refLayerId, 0, sizeof(m_refLayerId ));
2005	m_directDepTypeLen = 2;
2006	::memset(m_directDependencyType, 0, sizeof(m_directDependencyType));
2007
2008	m_maxOneActiveRefLayerFlag = true;
2009	#if O0062_POC_LSB_NOT_PRESENT_FLAG
2010	::memset(m_pocLsbNotPresentFlag, 0, sizeof(m_pocLsbNotPresentFlag));
2011	#endif
2012	m_crossLayerPictureTypeAlignFlag = true;
2013	m_crossLayerIrapAlignFlag = true;
2014	m_crossLayerAlignedIdrOnlyFlag = false;
2015	m_maxTidRefPresentFlag = true;
2016	for( Int i = 0; i < MAX_VPS_LAYER_IDX_PLUS1 - 1; i++)
2017	{
2018	for( Int j = 0; j < MAX_VPS_LAYER_IDX_PLUS1; j++)
2019	{
2020	m_maxTidIlRefPicsPlus1[i][j] = m_uiMaxTLayers + 1;
2021	}
2022	}
2023
2024	m_tilesNotInUseFlag = true;
2025	m_wppNotInUseFlag = true;
2026	::memset(m_tilesInUseFlag, 0, sizeof(m_tilesInUseFlag));
2027	::memset(m_loopFilterNotAcrossTilesFlag, 0, sizeof(m_loopFilterNotAcrossTilesFlag));
2028	::memset(m_tileBoundariesAlignedFlag, 0, sizeof(m_tileBoundariesAlignedFlag));
2029	::memset(m_wppInUseFlag, 0, sizeof(m_wppInUseFlag));
2030
2031	m_ilpRestrictedRefLayersFlag = false;
2032	::memset(m_minSpatialSegmentOffsetPlus1, 0, sizeof(m_minSpatialSegmentOffsetPlus1));
2033	::memset(m_ctuBasedOffsetEnabledFlag, 0, sizeof(m_ctuBasedOffsetEnabledFlag));
2034	::memset(m_minHorizontalCtuOffsetPlus1, 0, sizeof(m_minHorizontalCtuOffsetPlus1));
2035
2036	m_vidSigPresentVpsFlag=true;
2037	m_vpsVidSigInfo=1;
2038	::memset( m_vpsVidSigIdx, 0, sizeof(m_vpsVidSigIdx) );
2039	m_vpsVidSigIdx[0]=0;
2040	for (Int i=0; i < 16; i++)
2041	{
2042	m_vpsVidFormat[i] = 5;
2043	m_vpsFullRangeFlag[i] = false;
2044	m_vpsColorPrimaries[i] = 2;
2045	m_vpsTransChar[i] = 2;
2046	m_vpsMatCoeff[i] = 2;
2047	}
2048
2049	::memset(m_bitRatePresentFlag, 0, sizeof(m_bitRatePresentFlag));
2050	::memset(m_picRatePresentFlag, 0, sizeof(m_picRatePresentFlag));
2051	::memset(m_avgBitRate , 0, sizeof(m_avgBitRate) );
2052	::memset(m_maxBitRate , 0, sizeof(m_maxBitRate) );
2053	::memset(m_constPicRateIdc , 0, sizeof(m_constPicRateIdc) );
2054	::memset(m_avgPicRate , 0, sizeof(m_avgPicRate) );
2055	#if REPN_FORMAT_IN_VPS
2056	::memset( m_vpsRepFormatIdx, 0, sizeof(m_vpsRepFormatIdx) );
2057	#endif
2058	#if VIEW_ID_RELATED_SIGNALING
2059	::memset(m_viewIdVal, 0, sizeof(m_viewIdVal));
2060	#endif
2061
2062	for( Int i = 0; i < MAX_NUM_LAYER_IDS; i++ )
2063	{
2064	m_numberRefLayers[i] = 0;
2065	for( Int j = 0; j < MAX_NUM_LAYER_IDS; j++ )
2066	{
2067	m_recursiveRefLayerFlag[i][j] = 0;
2068	}
2069	}
2070
2071	#if VPS_DPB_SIZE_TABLE
2072	::memset( m_subLayerFlagInfoPresentFlag, 0, sizeof(m_subLayerFlagInfoPresentFlag ) );
2073	::memset( m_subLayerDpbInfoPresentFlag, 0, sizeof(m_subLayerDpbInfoPresentFlag ) );
2074	::memset( m_maxVpsDecPicBufferingMinus1, 0, sizeof(m_maxVpsDecPicBufferingMinus1 ) );
2075	::memset( m_maxVpsNumReorderPics, 0, sizeof(m_maxVpsNumReorderPics ) );
2076	::memset( m_maxVpsLatencyIncreasePlus1, 0, sizeof(m_maxVpsLatencyIncreasePlus1 ) );
2077	::memset( m_numSubDpbs , 0, sizeof(m_numSubDpbs) );
2078	#endif
2079	::memset( m_baseLayerPSCompatibilityFlag, 0, sizeof(m_baseLayerPSCompatibilityFlag) );
2080	}
2081	#else
2082	TComVPS::TComVPS()
2083	: m_VPSId ( 0)
2084	, m_uiMaxTLayers ( 1)
2085	, m_uiMaxLayers ( 1)
2086	, m_bTemporalIdNestingFlag (false)
2087	, m_numHrdParameters ( 0)
2088	, m_maxNuhReservedZeroLayerId ( 0)
2089	, m_hrdParameters (NULL)
2090	, m_hrdOpSetIdx (NULL)
2091	, m_cprmsPresentFlag (NULL)
2092	{
2093
2094	for( Int i = 0; i < MAX_TLAYER; i++)
2095	{
2096	m_numReorderPics[i] = 0;
2097	m_uiMaxDecPicBuffering[i] = 1;
2098	m_uiMaxLatencyIncrease[i] = 0;
2099	}
2100	}
2101	#endif //SVC_EXTENSION
2102
2103	TComVPS::~TComVPS()
2104	{
2105	if( m_hrdParameters != NULL ) delete[] m_hrdParameters;
2106	if( m_hrdOpSetIdx != NULL ) delete[] m_hrdOpSetIdx;
2107	if( m_cprmsPresentFlag != NULL ) delete[] m_cprmsPresentFlag;
2108	}
2109
2110	// ------------------------------------------------------------------------------------------------
2111	// Sequence parameter set (SPS)
2112	// ------------------------------------------------------------------------------------------------
2113
2114	TComSPS::TComSPS()
2115	: m_SPSId ( 0)
2116	, m_VPSId ( 0)
2117	, m_chromaFormatIdc (CHROMA_420)
2118	, m_uiMaxTLayers ( 1)
2119	// Structure
2120	, m_picWidthInLumaSamples (352)
2121	, m_picHeightInLumaSamples (288)
2122	, m_log2MinCodingBlockSize ( 0)
2123	, m_log2DiffMaxMinCodingBlockSize(0)
2124	, m_uiMaxCUWidth ( 32)
2125	, m_uiMaxCUHeight ( 32)
2126	, m_uiMaxCUDepth ( 3)
2127	, m_bLongTermRefsPresent (false)
2128	, m_uiQuadtreeTULog2MaxSize ( 0)
2129	, m_uiQuadtreeTULog2MinSize ( 0)
2130	, m_uiQuadtreeTUMaxDepthInter ( 0)
2131	, m_uiQuadtreeTUMaxDepthIntra ( 0)
2132	// Tool list
2133	, m_usePCM (false)
2134	, m_pcmLog2MaxSize ( 5)
2135	, m_uiPCMLog2MinSize ( 7)
2136	, m_useExtendedPrecision (false)
2137	, m_useHighPrecisionPredictionWeighting(false)
2138	, m_useResidualRotation (false)
2139	, m_useSingleSignificanceMapContext(false)
2140	, m_useGolombRiceParameterAdaptation(false)
2141	, m_alignCABACBeforeBypass (false)
2142	, m_bPCMFilterDisableFlag (false)
2143	, m_disableIntraReferenceSmoothing(false)
2144	, m_uiBitsForPOC ( 8)
2145	, m_numLongTermRefPicSPS ( 0)
2146	, m_uiMaxTrSize ( 32)
2147	, m_bUseSAO (false)
2148	, m_bTemporalIdNestingFlag (false)
2149	, m_scalingListEnabledFlag (false)
2150	, m_useStrongIntraSmoothing (false)
2151	, m_vuiParametersPresentFlag (false)
2152	, m_vuiParameters ()
2153	#if SVC_EXTENSION
2154	, m_layerId ( 0 )
2155	, m_extensionFlag ( false )
2156	, m_bV1CompatibleSPSFlag ( 0)
2157	#if REPN_FORMAT_IN_VPS
2158	, m_updateRepFormatFlag (false)
2159	, m_updateRepFormatIndex (0)
2160	#endif
2161	#if SCALINGLIST_INFERRING
2162	, m_inferScalingListFlag ( false )
2163	, m_scalingListRefLayerId ( 0 )
2164	#endif
2165	#endif //SVC_EXTENSION
2166	{
2167	for(Int ch=0; ch<MAX_NUM_CHANNEL_TYPE; ch++)
2168	{
2169	m_uiBitDepth [ch] = 8;
2170	m_uiPCMBitDepth[ch] = 8;
2171	m_qpBDOffset [ch] = 0;
2172	}
2173
2174	for ( Int i = 0; i < MAX_TLAYER; i++ )
2175	{
2176	m_uiMaxLatencyIncrease[i] = 0;
2177	m_uiMaxDecPicBuffering[i] = 1;
2178	m_numReorderPics[i] = 0;
2179	}
2180
2181	for (UInt signallingModeIndex = 0; signallingModeIndex < NUMBER_OF_RDPCM_SIGNALLING_MODES; signallingModeIndex++)
2182	{
2183	m_useResidualDPCM[signallingModeIndex] = false;
2184	}
2185
2186	m_scalingList = new TComScalingList;
2187	::memset(m_ltRefPicPocLsbSps, 0, sizeof(m_ltRefPicPocLsbSps));
2188	::memset(m_usedByCurrPicLtSPSFlag, 0, sizeof(m_usedByCurrPicLtSPSFlag));
2189	}
2190
2191	TComSPS::~TComSPS()
2192	{
2193	#if SCALINGLIST_INFERRING
2194	if( !m_inferScalingListFlag )
2195	#endif
2196	delete m_scalingList;
2197	m_RPSList.destroy();
2198	}
2199
2200	Void TComSPS::createRPSList( Int numRPS )
2201	{
2202	m_RPSList.destroy();
2203	m_RPSList.create(numRPS);
2204	}
2205
2206	Void TComSPS::setHrdParameters( UInt frameRate, UInt numDU, UInt bitRate, Bool randomAccess )
2207	{
2208	if( !getVuiParametersPresentFlag() )
2209	{
2210	return;
2211	}
2212
2213	TComVUI *vui = getVuiParameters();
2214	TComHRD *hrd = vui->getHrdParameters();
2215
2216	TimingInfo *timingInfo = vui->getTimingInfo();
2217	#if SVC_EXTENSION
2218	if( m_layerId > 0 )
2219	{
2220	timingInfo->setTimingInfoPresentFlag( false );
2221	return;
2222	}
2223	#endif
2224
2225	timingInfo->setTimingInfoPresentFlag( true );
2226	switch( frameRate )
2227	{
2228	case 24:
2229	timingInfo->setNumUnitsInTick( 1125000 ); timingInfo->setTimeScale ( 27000000 );
2230	break;
2231	case 25:
2232	timingInfo->setNumUnitsInTick( 1080000 ); timingInfo->setTimeScale ( 27000000 );
2233	break;
2234	case 30:
2235	timingInfo->setNumUnitsInTick( 900900 ); timingInfo->setTimeScale ( 27000000 );
2236	break;
2237	case 50:
2238	timingInfo->setNumUnitsInTick( 540000 ); timingInfo->setTimeScale ( 27000000 );
2239	break;
2240	case 60:
2241	timingInfo->setNumUnitsInTick( 450450 ); timingInfo->setTimeScale ( 27000000 );
2242	break;
2243	default:
2244	timingInfo->setNumUnitsInTick( 1001 ); timingInfo->setTimeScale ( 60000 );
2245	break;
2246	}
2247
2248	Bool rateCnt = ( bitRate > 0 );
2249	hrd->setNalHrdParametersPresentFlag( rateCnt );
2250	hrd->setVclHrdParametersPresentFlag( rateCnt );
2251
2252	hrd->setSubPicCpbParamsPresentFlag( ( numDU > 1 ) );
2253
2254	if( hrd->getSubPicCpbParamsPresentFlag() )
2255	{
2256	hrd->setTickDivisorMinus2( 100 - 2 ); //
2257	hrd->setDuCpbRemovalDelayLengthMinus1( 7 ); // 8-bit precision ( plus 1 for last DU in AU )
2258	hrd->setSubPicCpbParamsInPicTimingSEIFlag( true );
2259	hrd->setDpbOutputDelayDuLengthMinus1( 5 + 7 ); // With sub-clock tick factor of 100, at least 7 bits to have the same value as AU dpb delay
2260	}
2261	else
2262	{
2263	hrd->setSubPicCpbParamsInPicTimingSEIFlag( false );
2264	}
2265
2266	hrd->setBitRateScale( 4 ); // in units of 2~( 6 + 4 ) = 1,024 bps
2267	hrd->setCpbSizeScale( 6 ); // in units of 2~( 4 + 4 ) = 1,024 bit
2268	hrd->setDuCpbSizeScale( 6 ); // in units of 2~( 4 + 4 ) = 1,024 bit
2269
2270	hrd->setInitialCpbRemovalDelayLengthMinus1(15); // assuming 0.5 sec, log2( 90,000 * 0.5 ) = 16-bit
2271	if( randomAccess )
2272	{
2273	hrd->setCpbRemovalDelayLengthMinus1(5); // 32 = 2^5 (plus 1)
2274	hrd->setDpbOutputDelayLengthMinus1 (5); // 32 + 3 = 2^6
2275	}
2276	else
2277	{
2278	hrd->setCpbRemovalDelayLengthMinus1(9); // max. 2^10
2279	hrd->setDpbOutputDelayLengthMinus1 (9); // max. 2^10
2280	}
2281
2282	/*
2283	Note: only the case of "vps_max_temporal_layers_minus1 = 0" is supported.
2284	*/
2285	Int i, j;
2286	UInt bitrateValue, cpbSizeValue;
2287	UInt duCpbSizeValue;
2288	UInt duBitRateValue = 0;
2289
2290	for( i = 0; i < MAX_TLAYER; i ++ )
2291	{
2292	hrd->setFixedPicRateFlag( i, 1 );
2293	hrd->setPicDurationInTcMinus1( i, 0 );
2294	hrd->setLowDelayHrdFlag( i, 0 );
2295	hrd->setCpbCntMinus1( i, 0 );
2296
2297	bitrateValue = bitRate;
2298	cpbSizeValue = bitRate; // 1 second
2299	duCpbSizeValue = bitRate/numDU;
2300	duBitRateValue = bitRate;
2301
2302	for( j = 0; j < ( hrd->getCpbCntMinus1( i ) + 1 ); j ++ )
2303	{
2304	hrd->setBitRateValueMinus1( i, j, 0, ( bitrateValue - 1 ) );
2305	hrd->setCpbSizeValueMinus1( i, j, 0, ( cpbSizeValue - 1 ) );
2306	hrd->setDuCpbSizeValueMinus1( i, j, 0, ( duCpbSizeValue - 1 ) );
2307	hrd->setCbrFlag( i, j, 0, ( j == 0 ) );
2308
2309	hrd->setBitRateValueMinus1( i, j, 1, ( bitrateValue - 1) );
2310	hrd->setCpbSizeValueMinus1( i, j, 1, ( cpbSizeValue - 1 ) );
2311	hrd->setDuCpbSizeValueMinus1( i, j, 1, ( duCpbSizeValue - 1 ) );
2312	hrd->setDuBitRateValueMinus1( i, j, 1, ( duBitRateValue - 1 ) );
2313	hrd->setCbrFlag( i, j, 1, ( j == 0 ) );
2314	}
2315	}
2316	}
2317
2318	const Int TComSPS::m_winUnitX[]={1,2,2,1};
2319	const Int TComSPS::m_winUnitY[]={1,2,1,1};
2320
2321	TComPPS::TComPPS()
2322	: m_PPSId (0)
2323	, m_SPSId (0)
2324	, m_picInitQPMinus26 (0)
2325	, m_useDQP (false)
2326	, m_bConstrainedIntraPred (false)
2327	, m_bSliceChromaQpFlag (false)
2328	, m_pcSPS (NULL)
2329	, m_uiMaxCuDQPDepth (0)
2330	, m_uiMinCuDQPSize (0)
2331	, m_MaxCuChromaQpAdjDepth (0)
2332	, m_MinCuChromaQpAdjSize (0)
2333	, m_ChromaQpAdjTableSize (0)
2334	, m_chromaCbQpOffset (0)
2335	, m_chromaCrQpOffset (0)
2336	, m_numRefIdxL0DefaultActive (1)
2337	, m_numRefIdxL1DefaultActive (1)
2338	, m_useCrossComponentPrediction (false)
2339	, m_TransquantBypassEnableFlag (false)
2340	, m_useTransformSkip (false)
2341	, m_transformSkipLog2MaxSize (2)
2342	, m_dependentSliceSegmentsEnabledFlag(false)
2343	, m_tilesEnabledFlag (false)
2344	, m_entropyCodingSyncEnabledFlag (false)
2345	, m_loopFilterAcrossTilesEnabledFlag (true)
2346	, m_uniformSpacingFlag (false)
2347	, m_numTileColumnsMinus1 (0)
2348	, m_numTileRowsMinus1 (0)
2349	, m_numSubstreams (1)
2350	, m_signHideFlag (0)
2351	, m_cabacInitPresentFlag (false)
2352	, m_encCABACTableIdx (I_SLICE)
2353	, m_sliceHeaderExtensionPresentFlag (false)
2354	, m_loopFilterAcrossSlicesEnabledFlag(false)
2355	, m_listsModificationPresentFlag (0)
2356	, m_numExtraSliceHeaderBits (0)
2357
2358	#if SVC_EXTENSION
2359	, m_extensionFlag(false)
2360	#if SCALINGLIST_INFERRING
2361	, m_layerId(0)
2362	, m_inferScalingListFlag ( false )
2363	, m_scalingListRefLayerId ( 0 )
2364	#endif
2365	#if POC_RESET_IDC
2366	, m_pocResetInfoPresentFlag (false)
2367	#endif
2368	, m_numRefLayerLocationOffsets ( 0 )
2369	#if Q0048_CGS_3D_ASYMLUT
2370	, m_nCGSFlag(0)
2371	, m_nCGSOutputBitDepthY(0)
2372	, m_nCGSOutputBitDepthC(0)
2373	#endif
2374	#endif //SVC_EXTENSION
2375	{
2376	m_scalingList = new TComScalingList;
2377	for(Int ch=0; ch<MAX_NUM_CHANNEL_TYPE; ch++)
2378	{
2379	m_saoOffsetBitShift[ch] = 0;
2380	}
2381	m_ChromaQpAdjTable[0].u.comp.CbOffset = 0;
2382	m_ChromaQpAdjTable[0].u.comp.CrOffset = 0;
2383
2384	#if SVC_EXTENSION
2385	::memset(m_scaledRefLayerOffsetPresentFlag, 0, sizeof(m_scaledRefLayerOffsetPresentFlag));
2386	::memset(m_refRegionOffsetPresentFlag, 0, sizeof(m_refRegionOffsetPresentFlag));
2387	::memset(m_resamplePhaseSetPresentFlag, 0, sizeof(m_resamplePhaseSetPresentFlag));
2388	::memset(m_phaseHorLuma, 0, sizeof(m_phaseHorLuma));
2389	::memset(m_phaseVerLuma, 0, sizeof(m_phaseVerLuma));
2390	::memset(m_phaseHorChroma, 0, sizeof(m_phaseHorChroma));
2391	::memset(m_phaseVerChroma, 0, sizeof(m_phaseVerChroma));
2392	#endif //SVC_EXTENSION
2393	}
2394
2395	TComPPS::~TComPPS()
2396	{
2397	#if SCALINGLIST_INFERRING
2398	if( !m_inferScalingListFlag )
2399	#endif
2400	delete m_scalingList;
2401	}
2402
2403	TComReferencePictureSet::TComReferencePictureSet()
2404	: m_numberOfPictures (0)
2405	, m_numberOfNegativePictures (0)
2406	, m_numberOfPositivePictures (0)
2407	, m_numberOfLongtermPictures (0)
2408	, m_interRPSPrediction (0)
2409	, m_deltaRIdxMinus1 (0)
2410	, m_deltaRPS (0)
2411	, m_numRefIdc (0)
2412	{
2413	::memset( m_deltaPOC, 0, sizeof(m_deltaPOC) );
2414	::memset( m_POC, 0, sizeof(m_POC) );
2415	::memset( m_used, 0, sizeof(m_used) );
2416	::memset( m_refIdc, 0, sizeof(m_refIdc) );
2417	}
2418
2419	TComReferencePictureSet::~TComReferencePictureSet()
2420	{
2421	}
2422
2423	Void TComReferencePictureSet::setUsed(Int bufferNum, Bool used)
2424	{
2425	m_used[bufferNum] = used;
2426	}
2427
2428	Void TComReferencePictureSet::setDeltaPOC(Int bufferNum, Int deltaPOC)
2429	{
2430	m_deltaPOC[bufferNum] = deltaPOC;
2431	}
2432
2433	Void TComReferencePictureSet::setNumberOfPictures(Int numberOfPictures)
2434	{
2435	m_numberOfPictures = numberOfPictures;
2436	}
2437
2438	Int TComReferencePictureSet::getUsed(Int bufferNum)
2439	{
2440	return m_used[bufferNum];
2441	}
2442
2443	Int TComReferencePictureSet::getDeltaPOC(Int bufferNum)
2444	{
2445	return m_deltaPOC[bufferNum];
2446	}
2447
2448	Int TComReferencePictureSet::getNumberOfPictures()
2449	{
2450	return m_numberOfPictures;
2451	}
2452
2453	Int TComReferencePictureSet::getPOC(Int bufferNum)
2454	{
2455	return m_POC[bufferNum];
2456	}
2457
2458	Void TComReferencePictureSet::setPOC(Int bufferNum, Int POC)
2459	{
2460	m_POC[bufferNum] = POC;
2461	}
2462
2463	Bool TComReferencePictureSet::getCheckLTMSBPresent(Int bufferNum)
2464	{
2465	return m_bCheckLTMSB[bufferNum];
2466	}
2467
2468	Void TComReferencePictureSet::setCheckLTMSBPresent(Int bufferNum, Bool b)
2469	{
2470	m_bCheckLTMSB[bufferNum] = b;
2471	}
2472
2473	/** set the reference idc value at uiBufferNum entry to the value of iRefIdc
2474	* \param uiBufferNum
2475	* \param iRefIdc
2476	* \returns Void
2477	*/
2478	Void TComReferencePictureSet::setRefIdc(Int bufferNum, Int refIdc)
2479	{
2480	m_refIdc[bufferNum] = refIdc;
2481	}
2482
2483	/** get the reference idc value at uiBufferNum
2484	* \param uiBufferNum
2485	* \returns Int
2486	*/
2487	Int TComReferencePictureSet::getRefIdc(Int bufferNum)
2488	{
2489	return m_refIdc[bufferNum];
2490	}
2491
2492	/** Sorts the deltaPOC and Used by current values in the RPS based on the deltaPOC values.
2493	* deltaPOC values are sorted with -ve values before the +ve values. -ve values are in decreasing order.
2494	* +ve values are in increasing order.
2495	* \returns Void
2496	*/
2497	Void TComReferencePictureSet::sortDeltaPOC()
2498	{
2499	// sort in increasing order (smallest first)
2500	for(Int j=1; j < getNumberOfPictures(); j++)
2501	{
2502	Int deltaPOC = getDeltaPOC(j);
2503	Bool used = getUsed(j);
2504	for (Int k=j-1; k >= 0; k--)
2505	{
2506	Int temp = getDeltaPOC(k);
2507	if (deltaPOC < temp)
2508	{
2509	setDeltaPOC(k+1, temp);
2510	setUsed(k+1, getUsed(k));
2511	setDeltaPOC(k, deltaPOC);
2512	setUsed(k, used);
2513	}
2514	}
2515	}
2516	// flip the negative values to largest first
2517	Int numNegPics = getNumberOfNegativePictures();
2518	for(Int j=0, k=numNegPics-1; j < numNegPics>>1; j++, k--)
2519	{
2520	Int deltaPOC = getDeltaPOC(j);
2521	Bool used = getUsed(j);
2522	setDeltaPOC(j, getDeltaPOC(k));
2523	setUsed(j, getUsed(k));
2524	setDeltaPOC(k, deltaPOC);
2525	setUsed(k, used);
2526	}
2527	}
2528
2529	/** Prints the deltaPOC and RefIdc (if available) values in the RPS.
2530	* A "*" is added to the deltaPOC value if it is Used bu current.
2531	* \returns Void
2532	*/
2533	Void TComReferencePictureSet::printDeltaPOC()
2534	{
2535	printf("DeltaPOC = { ");
2536	for(Int j=0; j < getNumberOfPictures(); j++)
2537	{
2538	printf("%d%s ", getDeltaPOC(j), (getUsed(j)==1)?"*":"");
2539	}
2540	if (getInterRPSPrediction())
2541	{
2542	printf("}, RefIdc = { ");
2543	for(Int j=0; j < getNumRefIdc(); j++)
2544	{
2545	printf("%d ", getRefIdc(j));
2546	}
2547	}
2548	printf("}\n");
2549	}
2550
2551	TComRPSList::TComRPSList()
2552	:m_referencePictureSets (NULL)
2553	{
2554	}
2555
2556	TComRPSList::~TComRPSList()
2557	{
2558	}
2559
2560	Void TComRPSList::create( Int numberOfReferencePictureSets)
2561	{
2562	m_numberOfReferencePictureSets = numberOfReferencePictureSets;
2563	m_referencePictureSets = new TComReferencePictureSet[numberOfReferencePictureSets];
2564	}
2565
2566	Void TComRPSList::destroy()
2567	{
2568	if (m_referencePictureSets)
2569	{
2570	delete [] m_referencePictureSets;
2571	}
2572	m_numberOfReferencePictureSets = 0;
2573	m_referencePictureSets = NULL;
2574	}
2575
2576
2577
2578	TComReferencePictureSet* TComRPSList::getReferencePictureSet(Int referencePictureSetNum)
2579	{
2580	return &m_referencePictureSets[referencePictureSetNum];
2581	}
2582
2583	Int TComRPSList::getNumberOfReferencePictureSets()
2584	{
2585	return m_numberOfReferencePictureSets;
2586	}
2587
2588	Void TComRPSList::setNumberOfReferencePictureSets(Int numberOfReferencePictureSets)
2589	{
2590	m_numberOfReferencePictureSets = numberOfReferencePictureSets;
2591	}
2592
2593	TComRefPicListModification::TComRefPicListModification()
2594	: m_bRefPicListModificationFlagL0 (false)
2595	, m_bRefPicListModificationFlagL1 (false)
2596	{
2597	::memset( m_RefPicSetIdxL0, 0, sizeof(m_RefPicSetIdxL0) );
2598	::memset( m_RefPicSetIdxL1, 0, sizeof(m_RefPicSetIdxL1) );
2599	}
2600
2601	TComRefPicListModification::~TComRefPicListModification()
2602	{
2603	}
2604
2605	TComScalingList::TComScalingList()
2606	{
2607	init();
2608	}
2609
2610	TComScalingList::~TComScalingList()
2611	{
2612	destroy();
2613	}
2614
2615	/** set default quantization matrix to array
2616	*/
2617	Void TComSlice::setDefaultScalingList()
2618	{
2619	for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2620	{
2621	for(UInt listId=0;listId<SCALING_LIST_NUM;listId++)
2622	{
2623	getScalingList()->processDefaultMatrix(sizeId, listId);
2624	}
2625	}
2626	}
2627	/** check if use default quantization matrix
2628	* \returns true if use default quantization matrix in all size
2629	*/
2630	Bool TComSlice::checkDefaultScalingList()
2631	{
2632	UInt defaultCounter=0;
2633
2634	for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2635	{
2636	for(UInt listId=0;listId<SCALING_LIST_NUM;listId++)
2637	{
2638	if( !memcmp(getScalingList()->getScalingListAddress(sizeId,listId), getScalingList()->getScalingListDefaultAddress(sizeId, listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])) // check value of matrix
2639	&& ((sizeId < SCALING_LIST_16x16) \|\| (getScalingList()->getScalingListDC(sizeId,listId) == 16))) // check DC value
2640	{
2641	defaultCounter++;
2642	}
2643	}
2644	}
2645
2646	return (defaultCounter == (SCALING_LIST_NUM * SCALING_LIST_SIZE_NUM )) ? false : true;
2647	}
2648
2649	/** get scaling matrix from RefMatrixID
2650	* \param sizeId size index
2651	* \param Index of input matrix
2652	* \param Index of reference matrix
2653	*/
2654	Void TComScalingList::processRefMatrix( UInt sizeId, UInt listId , UInt refListId )
2655	{
2656	::memcpy(getScalingListAddress(sizeId, listId),((listId == refListId)? getScalingListDefaultAddress(sizeId, refListId): getScalingListAddress(sizeId, refListId)),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
2657	}
2658
2659	/** parse syntax infomation
2660	* \param pchFile syntax infomation
2661	* \returns false if successful
2662	*/
2663
2664	static Void outputScalingListHelp(std::ostream &os)
2665	{
2666	os << "The scaling list file specifies all matrices and their DC values; none can be missing,\n"
2667	"but their order is arbitrary.\n\n"
2668	"The matrices are specified by:\n"
2669	"<matrix name><unchecked data>\n"
2670	" <value>,<value>,<value>,....\n\n"
2671	" Line-feeds can be added arbitrarily between values, and the number of values needs to be\n"
2672	" at least the number of entries for the matrix (superfluous entries are ignored).\n"
2673	" The <unchecked data> is text on the same line as the matrix that is not checked\n"
2674	" except to ensure that the matrix name token is unique. It is recommended that it is ' ='\n"
2675	" The values in the matrices are the absolute values (0-255), not the delta values as\n"
2676	" exchanged between the encoder and decoder\n\n"
2677	"The DC values (for matrix sizes larger than 8x8) are specified by:\n"
2678	"<matrix name>_DC<unchecked data>\n"
2679	" <value>\n";
2680
2681	os << "The permitted matrix names are:\n";
2682	for(UInt sizeIdc = 0; sizeIdc < SCALING_LIST_SIZE_NUM; sizeIdc++)
2683	{
2684	for(UInt listIdc = 0; listIdc < SCALING_LIST_NUM; listIdc++)
2685	{
2686	if ((sizeIdc!=SCALING_LIST_32x32) \|\| (listIdc%(SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES) == 0))
2687	{
2688	os << " " << MatrixType[sizeIdc][listIdc] << '\n';
2689	}
2690	}
2691	}
2692	}
2693
2694	Void TComScalingList::outputScalingLists(std::ostream &os) const
2695	{
2696	for(UInt sizeIdc = 0; sizeIdc < SCALING_LIST_SIZE_NUM; sizeIdc++)
2697	{
2698	const UInt size = min(8,4<<(sizeIdc));
2699	for(UInt listIdc = 0; listIdc < SCALING_LIST_NUM; listIdc++)
2700	{
2701	if ((sizeIdc!=SCALING_LIST_32x32) \|\| (listIdc%(SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES) == 0))
2702	{
2703	const Int *src = getScalingListAddress(sizeIdc, listIdc);
2704	os << (MatrixType[sizeIdc][listIdc]) << " =\n ";
2705	for(UInt y=0; y<size; y++)
2706	{
2707	for(UInt x=0; x<size; x++, src++)
2708	{
2709	os << std::setw(3) << (*src) << ", ";
2710	}
2711	os << (y+1<size?"\n ":"\n");
2712	}
2713	if(sizeIdc > SCALING_LIST_8x8)
2714	{
2715	os << MatrixType_DC[sizeIdc][listIdc] << " = \n " << std::setw(3) << getScalingListDC(sizeIdc, listIdc) << "\n";
2716	}
2717	os << "\n";
2718	}
2719	}
2720	}
2721	}
2722
2723	Bool TComScalingList::xParseScalingList(Char* pchFile)
2724	{
2725	static const Int LINE_SIZE=1024;
2726	FILE *fp = NULL;
2727	Char line[LINE_SIZE];
2728
2729	if (pchFile == NULL)
2730	{
2731	fprintf(stderr, "Error: no scaling list file specified. Help on scaling lists being output\n");
2732	outputScalingListHelp(std::cout);
2733	std::cout << "\n\nExample scaling list file using default values:\n\n";
2734	outputScalingLists(std::cout);
2735	exit (1);
2736	return true;
2737	}
2738	else if ((fp = fopen(pchFile,"r")) == (FILE*)NULL)
2739	{
2740	fprintf(stderr, "Error: cannot open scaling list file %s for reading\n",pchFile);
2741	return true;
2742	}
2743
2744	for(UInt sizeIdc = 0; sizeIdc < SCALING_LIST_SIZE_NUM; sizeIdc++)
2745	{
2746	const UInt size = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeIdc]);
2747
2748	for(UInt listIdc = 0; listIdc < SCALING_LIST_NUM; listIdc++)
2749	{
2750	Int * const src = getScalingListAddress(sizeIdc, listIdc);
2751
2752	if ((sizeIdc==SCALING_LIST_32x32) && (listIdc%(SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES) != 0)) // derive chroma32x32 from chroma16x16
2753	{
2754	const Int *srcNextSmallerSize = getScalingListAddress(sizeIdc-1, listIdc);
2755	for(UInt i=0; i<size; i++)
2756	{
2757	src[i] = srcNextSmallerSize[i];
2758	}
2759	setScalingListDC(sizeIdc,listIdc,(sizeIdc > SCALING_LIST_8x8) ? getScalingListDC(sizeIdc-1, listIdc) : src[0]);
2760	}
2761	else
2762	{
2763	{
2764	fseek(fp, 0, SEEK_SET);
2765	Bool bFound=false;
2766	while ((!feof(fp)) && (!bFound))
2767	{
2768	Char *ret = fgets(line, LINE_SIZE, fp);
2769	Char *findNamePosition= ret==NULL ? NULL : strstr(line, MatrixType[sizeIdc][listIdc]);
2770	// This could be a match against the DC string as well, so verify it isn't
2771	if (findNamePosition!= NULL && (MatrixType_DC[sizeIdc][listIdc]==NULL \|\| strstr(line, MatrixType_DC[sizeIdc][listIdc])==NULL))
2772	{
2773	bFound=true;
2774	}
2775	}
2776	if (!bFound)
2777	{
2778	fprintf(stderr, "Error: cannot find Matrix %s from scaling list file %s\n", MatrixType[sizeIdc][listIdc], pchFile);
2779	return true;
2780	}
2781	}
2782	for (UInt i=0; i<size; i++)
2783	{
2784	Int data;
2785	if (fscanf(fp, "%d,", &data)!=1)
2786	{
2787	fprintf(stderr, "Error: cannot read value #%d for Matrix %s from scaling list file %s at file position %ld\n", i, MatrixType[sizeIdc][listIdc], pchFile, ftell(fp));
2788	return true;
2789	}
2790	if (data<0 \|\| data>255)
2791	{
2792	fprintf(stderr, "Error: QMatrix entry #%d of value %d for Matrix %s from scaling list file %s at file position %ld is out of range (0 to 255)\n", i, data, MatrixType[sizeIdc][listIdc], pchFile, ftell(fp));
2793	return true;
2794	}
2795	src[i] = data;
2796	}
2797
2798	//set DC value for default matrix check
2799	setScalingListDC(sizeIdc,listIdc,src[0]);
2800
2801	if(sizeIdc > SCALING_LIST_8x8)
2802	{
2803	{
2804	fseek(fp, 0, SEEK_SET);
2805	Bool bFound=false;
2806	while ((!feof(fp)) && (!bFound))
2807	{
2808	Char *ret = fgets(line, LINE_SIZE, fp);
2809	Char *findNamePosition= ret==NULL ? NULL : strstr(line, MatrixType_DC[sizeIdc][listIdc]);
2810	if (findNamePosition!= NULL)
2811	{
2812	// This won't be a match against the non-DC string.
2813	bFound=true;
2814	}
2815	}
2816	if (!bFound)
2817	{
2818	fprintf(stderr, "Error: cannot find DC Matrix %s from scaling list file %s\n", MatrixType_DC[sizeIdc][listIdc], pchFile);
2819	return true;
2820	}
2821	}
2822	Int data;
2823	if (fscanf(fp, "%d,", &data)!=1)
2824	{
2825	fprintf(stderr, "Error: cannot read DC %s from scaling list file %s at file position %ld\n", MatrixType_DC[sizeIdc][listIdc], pchFile, ftell(fp));
2826	return true;
2827	}
2828	if (data<0 \|\| data>255)
2829	{
2830	fprintf(stderr, "Error: DC value %d for Matrix %s from scaling list file %s at file position %ld is out of range (0 to 255)\n", data, MatrixType[sizeIdc][listIdc], pchFile, ftell(fp));
2831	return true;
2832	}
2833	//overwrite DC value when size of matrix is larger than 16x16
2834	setScalingListDC(sizeIdc,listIdc,data);
2835	}
2836	}
2837	}
2838	}
2839	// std::cout << "\n\nRead scaling lists of:\n\n";
2840	// outputScalingLists(std::cout);
2841
2842	fclose(fp);
2843	return false;
2844	}
2845
2846	/** initialization process of quantization matrix array
2847	*/
2848	Void TComScalingList::init()
2849	{
2850	for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2851	{
2852	for(UInt listId = 0; listId < SCALING_LIST_NUM; listId++)
2853	{
2854	m_scalingListCoef[sizeId][listId] = new Int [min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])];
2855	}
2856	}
2857	}
2858
2859	/** destroy quantization matrix array
2860	*/
2861	Void TComScalingList::destroy()
2862	{
2863	for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2864	{
2865	for(UInt listId = 0; listId < SCALING_LIST_NUM; listId++)
2866	{
2867	if(m_scalingListCoef[sizeId][listId]) delete [] m_scalingListCoef[sizeId][listId];
2868	}
2869	}
2870	}
2871
2872	/** get default address of quantization matrix
2873	* \param sizeId size index
2874	* \param listId list index
2875	* \returns pointer of quantization matrix
2876	*/
2877	Int* TComScalingList::getScalingListDefaultAddress(UInt sizeId, UInt listId)
2878	{
2879	Int *src = 0;
2880	switch(sizeId)
2881	{
2882	case SCALING_LIST_4x4:
2883	src = g_quantTSDefault4x4;
2884	break;
2885	case SCALING_LIST_8x8:
2886	case SCALING_LIST_16x16:
2887	case SCALING_LIST_32x32:
2888	src = (listId < (SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES) ) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
2889	break;
2890	default:
2891	assert(0);
2892	src = NULL;
2893	break;
2894	}
2895	return src;
2896	}
2897
2898	/** process of default matrix
2899	* \param sizeId size index
2900	* \param Index of input matrix
2901	*/
2902	Void TComScalingList::processDefaultMatrix(UInt sizeId, UInt listId)
2903	{
2904	::memcpy(getScalingListAddress(sizeId, listId),getScalingListDefaultAddress(sizeId,listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
2905	setScalingListDC(sizeId,listId,SCALING_LIST_DC);
2906	}
2907
2908	/** check DC value of matrix for default matrix signaling
2909	*/
2910	Void TComScalingList::checkDcOfMatrix()
2911	{
2912	for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2913	{
2914	for(UInt listId = 0; listId < SCALING_LIST_NUM; listId++)
2915	{
2916	//check default matrix?
2917	if(getScalingListDC(sizeId,listId) == 0)
2918	{
2919	processDefaultMatrix(sizeId, listId);
2920	}
2921	}
2922	}
2923	}
2924
2925	ParameterSetManager::ParameterSetManager()
2926	#if SVC_EXTENSION
2927	: m_activeSPSId(-1)
2928	, m_activePPSId(-1)
2929	#else
2930	: m_vpsMap(MAX_NUM_VPS)
2931	, m_spsMap(MAX_NUM_SPS)
2932	, m_ppsMap(MAX_NUM_PPS)
2933	, m_activeVPSId(-1)
2934	, m_activeSPSId(-1)
2935	, m_activePPSId(-1)
2936	#endif
2937	{
2938	}
2939
2940
2941	ParameterSetManager::~ParameterSetManager()
2942	{
2943	}
2944
2945	//! activate a SPS from a active parameter sets SEI message
2946	//! \returns true, if activation is successful
2947	Bool ParameterSetManager::activateSPSWithSEI(Int spsId)
2948	{
2949	TComSPS *sps = m_spsMap.getPS(spsId);
2950	if (sps)
2951	{
2952	Int vpsId = sps->getVPSId();
2953	if (m_vpsMap.getPS(vpsId))
2954	{
2955	m_activeVPSId = vpsId;
2956	m_activeSPSId = spsId;
2957	return true;
2958	}
2959	else
2960	{
2961	printf("Warning: tried to activate SPS using an Active parameter sets SEI message. Referenced VPS does not exist.");
2962	}
2963	}
2964	else
2965	{
2966	printf("Warning: tried to activate non-existing SPS using an Active parameter sets SEI message.");
2967	}
2968	return false;
2969	}
2970
2971	//! activate a PPS and depending on isIDR parameter also SPS and VPS
2972	//! \returns true, if activation is successful
2973	Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP)
2974	{
2975	TComPPS *pps = m_ppsMap.getPS(ppsId);
2976	if (pps)
2977	{
2978	Int spsId = pps->getSPSId();
2979	if (!isIRAP && (spsId != m_activeSPSId))
2980	{
2981	printf("Warning: tried to activate PPS referring to a inactive SPS at non-IDR.");
2982	return false;
2983	}
2984	TComSPS *sps = m_spsMap.getPS(spsId);
2985	if (sps)
2986	{
2987	Int vpsId = sps->getVPSId();
2988	if (!isIRAP && (vpsId != m_activeVPSId))
2989	{
2990	printf("Warning: tried to activate PPS referring to a inactive VPS at non-IDR.");
2991	return false;
2992	}
2993	if (m_vpsMap.getPS(vpsId))
2994	{
2995	m_activePPSId = ppsId;
2996	m_activeVPSId = vpsId;
2997	m_activeSPSId = spsId;
2998	return true;
2999	}
3000	else
3001	{
3002	printf("Warning: tried to activate PPS that refers to a non-existing VPS.");
3003	}
3004	}
3005	else
3006	{
3007	printf("Warning: tried to activate a PPS that refers to a non-existing SPS.");
3008	}
3009	}
3010	else
3011	{
3012	printf("Warning: tried to activate non-existing PPS.");
3013	}
3014	return false;
3015	}
3016
3017	ProfileTierLevel::ProfileTierLevel()
3018	: m_profileSpace (0)
3019	, m_tierFlag (Level::MAIN)
3020	, m_profileIdc (Profile::NONE)
3021	, m_levelIdc (Level::NONE)
3022	, m_progressiveSourceFlag (false)
3023	, m_interlacedSourceFlag (false)
3024	, m_nonPackedConstraintFlag(false)
3025	, m_frameOnlyConstraintFlag(false)
3026	{
3027	::memset(m_profileCompatibilityFlag, 0, sizeof(m_profileCompatibilityFlag));
3028	}
3029
3030	TComPTL::TComPTL()
3031	{
3032	::memset(m_subLayerProfilePresentFlag, 0, sizeof(m_subLayerProfilePresentFlag));
3033	::memset(m_subLayerLevelPresentFlag, 0, sizeof(m_subLayerLevelPresentFlag ));
3034	}
3035
3036	#if SVC_EXTENSION
3037	Void ProfileTierLevel::copyProfileInfo(ProfileTierLevel *ptl)
3038	{
3039	this->setProfileSpace ( ptl->getProfileSpace() );
3040	this->setTierFlag ( ptl->getTierFlag() );
3041	this->setProfileIdc ( ptl->getProfileIdc() );
3042	for(Int j = 0; j < 32; j++)
3043	{
3044	this->setProfileCompatibilityFlag(j, ptl->getProfileCompatibilityFlag(j));
3045	}
3046	this->setProgressiveSourceFlag ( ptl->getProgressiveSourceFlag() );
3047	this->setInterlacedSourceFlag ( ptl->getInterlacedSourceFlag() );
3048	this->setNonPackedConstraintFlag( ptl->getNonPackedConstraintFlag());
3049	this->setFrameOnlyConstraintFlag( ptl->getFrameOnlyConstraintFlag());
3050	}
3051
3052	Window& TComPPS::getScaledRefLayerWindowForLayer(Int layerId)
3053	{
3054	static Window win;
3055
3056	for( Int i = m_numRefLayerLocationOffsets-1; i >= 0; i-- )
3057	{
3058	if( layerId == m_refLocationOffsetLayerId[i] )
3059	{
3060	return m_scaledRefLayerWindow[i];
3061	}
3062	}
3063
3064	win.resetWindow(); // scaled reference layer offsets are inferred to be zero when not present
3065	return win;
3066	}
3067
3068	Window& TComPPS::getRefLayerWindowForLayer(Int layerId)
3069	{
3070	static Window win;
3071
3072	for( Int i = m_numRefLayerLocationOffsets-1; i >= 0; i-- )
3073	{
3074	if( layerId == m_refLocationOffsetLayerId[i] )
3075	{
3076	return m_refLayerWindow[i];
3077	}
3078	}
3079
3080	win.resetWindow(); // reference region offsets are inferred to be zero when not present
3081	return win;
3082	}
3083
3084	Bool TComPPS::hasZeroResamplingPhase(Int refLayerId)
3085	{
3086	Bool phaseSetPresentFlag;
3087	Int phaseHorLuma, phaseVerLuma, phaseHorChroma, phaseVerChroma;
3088
3089	getResamplingPhase(refLayerId, phaseSetPresentFlag, phaseHorLuma, phaseVerLuma, phaseHorChroma, phaseVerChroma);
3090
3091	return ( phaseHorLuma == 0 && phaseHorChroma == 0 && phaseVerLuma == 0 && phaseVerChroma == 0);
3092	}
3093
3094	Void TComPPS::getResamplingPhase(Int refLayerId, Bool& phaseSetPresentFlag, Int& phaseHorLuma, Int& phaseVerLuma, Int& phaseHorChroma, Int& phaseVerChroma)
3095	{
3096	phaseSetPresentFlag = false;
3097	phaseHorLuma = 0, phaseVerLuma = 0, phaseHorChroma = 0, phaseVerChroma = 0;
3098
3099	for( Int i = m_numRefLayerLocationOffsets-1; i >= 0; i-- )
3100	{
3101	if( refLayerId == m_refLocationOffsetLayerId[i] )
3102	{
3103	phaseSetPresentFlag = m_resamplePhaseSetPresentFlag[i];
3104	phaseHorLuma = m_phaseHorLuma[i];
3105	phaseVerLuma = m_phaseVerLuma[i];
3106	phaseHorChroma = m_phaseHorChroma[i];
3107	phaseVerChroma = m_phaseVerChroma[i];
3108
3109	return;
3110	}
3111	}
3112	}
3113
3114	Void TComVPS::deriveLayerIdListVariables()
3115	{
3116	// For layer 0
3117	m_numLayerInIdList.push_back(1);
3118	m_layerSetLayerIdList.resize(m_vpsNumLayerSetsMinus1 + 1);
3119	m_layerSetLayerIdList[0].push_back(0);
3120
3121	// For other layers
3122	for (Int i = 1; i <= m_vpsNumLayerSetsMinus1; i++)
3123	{
3124	for( Int m = 0; m <= m_maxLayerId; m++)
3125	{
3126	if( m_layerIdIncludedFlag[i][m] )
3127	{
3128	m_layerSetLayerIdList[i].push_back(m);
3129	}
3130	}
3131	m_numLayerInIdList.push_back((Int)m_layerSetLayerIdList[i].size());
3132	}
3133	}
3134
3135	#if VPS_DPB_SIZE_TABLE
3136	Void TComVPS::deriveNumberOfSubDpbs()
3137	{
3138	// Derive number of sub-DPBs
3139	// For layer set 0
3140	m_numSubDpbs[0] = 1;
3141	// For other layer sets
3142	for( Int i = 1; i < m_numLayerSets; i++)
3143	{
3144	m_numSubDpbs[i] = m_numLayerInIdList[i];
3145	}
3146	}
3147	#endif
3148
3149	Void TComVPS::setTilesNotInUseFlag(Bool x)
3150	{
3151	m_tilesNotInUseFlag = x;
3152
3153	if( m_tilesNotInUseFlag )
3154	{
3155	for( Int i = 0; i < getMaxLayers(); i++ )
3156	{
3157	m_tilesInUseFlag[i] = m_loopFilterNotAcrossTilesFlag[i] = m_tilesNotInUseFlag;
3158	}
3159
3160	for( Int i = 1; i < getMaxLayers(); i++ )
3161	{
3162	for( Int j = 0; j < getNumDirectRefLayers(getLayerIdInNuh(i)); j++)
3163	{
3164	setTileBoundariesAlignedFlag(i, j, m_tilesNotInUseFlag);
3165	}
3166	}
3167	}
3168	}
3169
3170	Void TComVPS::setWppNotInUseFlag(Bool x)
3171	{
3172	m_wppNotInUseFlag = x;
3173
3174	if( m_wppNotInUseFlag )
3175	{
3176	for( Int i = 0; i < getMaxLayers(); i++ )
3177	{
3178	m_wppInUseFlag[i] = m_wppNotInUseFlag;
3179	}
3180	}
3181	}
3182
3183	Void TComVPS::setRefLayersFlags(Int currLayerId)
3184	{
3185	for (Int i = 0; i < m_numDirectRefLayers[currLayerId]; i++)
3186	{
3187	UInt refLayerId = getRefLayerId(currLayerId, i);
3188	m_recursiveRefLayerFlag[currLayerId][refLayerId] = true;
3189	for (Int k = 0; k < MAX_NUM_LAYER_IDS; k++)
3190	{
3191	m_recursiveRefLayerFlag[currLayerId][k] = m_recursiveRefLayerFlag[currLayerId][k] \| m_recursiveRefLayerFlag[refLayerId][k];
3192	}
3193	}
3194	}
3195
3196	Void TComVPS::setNumRefLayers()
3197	{
3198	memset( m_numberRefLayers, 0, sizeof( m_numberRefLayers ) );
3199
3200	for (Int i = 0; i < m_uiMaxLayers; i++)
3201	{
3202	UInt iNuhLId = m_layerIdInNuh[i];
3203	setRefLayersFlags(iNuhLId);
3204	for (UInt j = 0; j < MAX_NUM_LAYER_IDS; j++)
3205	{
3206	m_numberRefLayers[iNuhLId] += (m_recursiveRefLayerFlag[iNuhLId][j] == true ? 1 : 0);
3207	}
3208	}
3209	}
3210
3211	Void TComVPS::setPredictedLayerIds()
3212	{
3213	for (UInt i = 0; i < m_uiMaxLayers - 1; i++)
3214	{
3215	UInt iNuhLId = m_layerIdInNuh[i];
3216	UInt predIdx = 0;
3217	for (UInt j = iNuhLId + 1; j < MAX_NUM_LAYER_IDS; j++)
3218	{
3219	if( m_recursiveRefLayerFlag[j][iNuhLId] )
3220	{
3221	m_predictedLayerId[iNuhLId][predIdx] = j;
3222	predIdx++;
3223	}
3224	}
3225	m_numPredictedLayers[iNuhLId] = predIdx;
3226	}
3227	m_numPredictedLayers[m_layerIdInNuh[m_uiMaxLayers-1]] = 0;
3228	}
3229
3230	Void TComVPS::setTreePartitionLayerIdList()
3231	{
3232	Bool countedLayerIdxFlag[MAX_NUM_LAYER_IDS];
3233	memset( countedLayerIdxFlag, 0, sizeof(countedLayerIdxFlag) );
3234
3235	Int numIndependentLayers = 0;
3236
3237	for (UInt i = 0; i < m_uiMaxLayers; i++)
3238	{
3239	UInt iNuhLId = m_layerIdInNuh[i];
3240	if( m_numDirectRefLayers[iNuhLId] == 0 )
3241	{
3242	m_treePartitionLayerIdList[numIndependentLayers][0] = iNuhLId;
3243	m_numLayersInTreePartition[numIndependentLayers] = 1;
3244	for( UInt j = 0; j < m_numPredictedLayers[iNuhLId]; j++ )
3245	{
3246	if( !countedLayerIdxFlag[m_layerIdxInVps[iNuhLId]] )
3247	{
3248	m_treePartitionLayerIdList[numIndependentLayers][m_numLayersInTreePartition[numIndependentLayers]] = m_predictedLayerId[iNuhLId][j];
3249	m_numLayersInTreePartition[numIndependentLayers] = m_numLayersInTreePartition[numIndependentLayers] + 1;
3250	countedLayerIdxFlag[m_layerIdxInVps[m_predictedLayerId[iNuhLId][j]]] = true;
3251	}
3252	}
3253	numIndependentLayers++;
3254	}
3255	}
3256
3257	m_numIndependentLayers = numIndependentLayers;
3258	}
3259
3260	Void TComVPS::deriveLayerIdListVariablesForAddLayerSets()
3261	{
3262	m_layerSetLayerIdList.resize(m_vpsNumLayerSetsMinus1 + 1 + m_numAddLayerSets);
3263
3264	for (UInt i = 0; i < m_numAddLayerSets; i++)
3265	{
3266	Int layerNum = 0;
3267	Int lsIdx = m_vpsNumLayerSetsMinus1 + 1 + i;
3268	for (Int treeIdx = 1; treeIdx < m_numIndependentLayers; treeIdx++)
3269	{
3270	for (Int layerCnt = 0; layerCnt < m_highestLayerIdxPlus1[i][treeIdx]; layerCnt++)
3271	{
3272	m_layerSetLayerIdList[lsIdx].push_back(m_treePartitionLayerIdList[treeIdx][layerCnt]);
3273	layerNum++;
3274	}
3275	}
3276	m_numLayerInIdList.push_back(layerNum);
3277	}
3278	}
3279
3280	#if VIEW_ID_RELATED_SIGNALING
3281	Int TComVPS::getNumViews()
3282	{
3283	Int numViews = 1;
3284	for( Int i = 0; i <= getMaxLayers() - 1; i++ )
3285	{
3286	Int lId = getLayerIdInNuh( i );
3287	if ( i > 0 && ( getViewIndex( lId ) != getScalabilityId( i - 1, VIEW_ORDER_INDEX ) ) )
3288	{
3289	numViews++;
3290	}
3291	}
3292
3293	return numViews;
3294	}
3295	Int TComVPS::getScalabilityId( Int layerIdInVps, ScalabilityType scalType )
3296	{
3297	return getScalabilityMask( scalType ) ? getDimensionId( layerIdInVps, scalTypeToScalIdx( scalType ) ) : 0;
3298	}
3299	Int TComVPS::scalTypeToScalIdx( ScalabilityType scalType )
3300	{
3301	assert( scalType >= 0 && scalType <= MAX_VPS_NUM_SCALABILITY_TYPES );
3302	assert( scalType == MAX_VPS_NUM_SCALABILITY_TYPES \|\| getScalabilityMask( scalType ) );
3303	Int scalIdx = 0;
3304	for( Int curScalType = 0; curScalType < scalType; curScalType++ )
3305	{
3306	scalIdx += ( getScalabilityMask( curScalType ) ? 1 : 0 );
3307
3308	}
3309
3310	return scalIdx;
3311	}
3312	#endif
3313	#if VPS_DPB_SIZE_TABLE
3314	Int TComVPS::getLayerIdcForOls( Int olsIdx, Int layerId )
3315	{
3316	Int layerIdc = -1;
3317	UInt lsIdx = m_outputLayerSetIdx[olsIdx];
3318
3319	std::vector<Int>::iterator it = std::find( m_layerSetLayerIdList[lsIdx].begin(), m_layerSetLayerIdList[lsIdx].end(), layerId );
3320
3321	if( it != m_layerSetLayerIdList[lsIdx].end() )
3322	{
3323	layerIdc = (Int)std::distance( m_layerSetLayerIdList[lsIdx].begin(), it );
3324	}
3325
3326	assert( layerIdc >= 0 );
3327
3328	return layerIdc;
3329	}
3330
3331	Void TComVPS::determineSubDpbInfoFlags()
3332	{
3333	for(Int i = 1; i < getNumOutputLayerSets(); i++)
3334	{
3335	Int layerSetIdxForOutputLayerSet = getOutputLayerSetIdx( i );
3336	// For each output layer set, set the DPB size for each layer and the reorder/latency value the maximum for all layers
3337	Bool checkFlagOuter = false; // Used to calculate sub_layer_flag_info_present_flag
3338	Bool checkFlagInner[MAX_TLAYER]; // Used to calculate sub_layer_dpb_info_present_flag
3339
3340	for(Int j = 0; j < getMaxTLayers(); j++)
3341	{
3342	// --------------------------------------------------------
3343	// To determine value of m_subLayerDpbInfoPresentFlag
3344	// --------------------------------------------------------
3345	if( j == 0 ) // checkFlagInner[0] is always 1
3346	{
3347	checkFlagInner[j] = true; // Always signal sub-layer DPB information for the first sub-layer
3348	}
3349	else
3350	{
3351	checkFlagInner[j] = false; // Initialize to be false. If the values of the current sub-layers matches with the earlier sub-layer,
3352	// then will be continue to be false - i.e. the j-th sub-layer DPB info is not signaled
3353	checkFlagInner[j] \|= ( getMaxVpsNumReorderPics(i, j) != getMaxVpsNumReorderPics(i, j - 1) );
3354
3355	for(Int subDpbIdx = 0; subDpbIdx < getNumSubDpbs(layerSetIdxForOutputLayerSet) && !checkFlagInner[j]; subDpbIdx++) // If checkFlagInner[j] is true, break and signal the values
3356	{
3357	checkFlagInner[j] \|= ( getMaxVpsDecPicBufferingMinus1(i, subDpbIdx, j - 1) != getMaxVpsDecPicBufferingMinus1(i, subDpbIdx, j) );
3358	}
3359	}
3360	// If checkFlagInner[j] = true, then some value needs to be signalled for the j-th sub-layer
3361	setSubLayerDpbInfoPresentFlag( i, j, checkFlagInner[j] );
3362	}
3363
3364	// --------------------------------------------------------
3365	// To determine value of m_subLayerFlagInfoPresentFlag
3366	// --------------------------------------------------------
3367
3368	for(Int j = 1; j < getMaxTLayers(); j++) // Check if DPB info of any of non-zero sub-layers is signaled. If so set flag to one
3369	{
3370	if( getSubLayerDpbInfoPresentFlag(i, j) )
3371	{
3372	checkFlagOuter = true;
3373	break;
3374	}
3375	}
3376	setSubLayerFlagInfoPresentFlag( i, checkFlagOuter );
3377	}
3378	}
3379	#endif
3380
3381	#if O0164_MULTI_LAYER_HRD
3382	Void TComVPS::setBspHrdParameters( UInt hrdIdx, UInt frameRate, UInt numDU, UInt bitRate, Bool randomAccess )
3383	{
3384	if( !getVpsVuiBspHrdPresentFlag() )
3385	{
3386	return;
3387	}
3388
3389	TComHRD *hrd = getBspHrd(hrdIdx);
3390
3391	Bool rateCnt = ( bitRate > 0 );
3392	hrd->setNalHrdParametersPresentFlag( rateCnt );
3393	hrd->setVclHrdParametersPresentFlag( rateCnt );
3394
3395	hrd->setSubPicCpbParamsPresentFlag( ( numDU > 1 ) );
3396
3397	if( hrd->getSubPicCpbParamsPresentFlag() )
3398	{
3399	hrd->setTickDivisorMinus2( 100 - 2 ); //
3400	hrd->setDuCpbRemovalDelayLengthMinus1( 7 ); // 8-bit precision ( plus 1 for last DU in AU )
3401	hrd->setSubPicCpbParamsInPicTimingSEIFlag( true );
3402	hrd->setDpbOutputDelayDuLengthMinus1( 5 + 7 ); // With sub-clock tick factor of 100, at least 7 bits to have the same value as AU dpb delay
3403	}
3404	else
3405	{
3406	hrd->setSubPicCpbParamsInPicTimingSEIFlag( false );
3407	}
3408
3409	hrd->setBitRateScale( 4 ); // in units of 2~( 6 + 4 ) = 1,024 bps
3410	hrd->setCpbSizeScale( 6 ); // in units of 2~( 4 + 4 ) = 1,024 bit
3411	hrd->setDuCpbSizeScale( 6 ); // in units of 2~( 4 + 4 ) = 1,024 bit
3412
3413	hrd->setInitialCpbRemovalDelayLengthMinus1(15); // assuming 0.5 sec, log2( 90,000 * 0.5 ) = 16-bit
3414	if( randomAccess )
3415	{
3416	hrd->setCpbRemovalDelayLengthMinus1(5); // 32 = 2^5 (plus 1)
3417	hrd->setDpbOutputDelayLengthMinus1 (5); // 32 + 3 = 2^6
3418	}
3419	else
3420	{
3421	hrd->setCpbRemovalDelayLengthMinus1(9); // max. 2^10
3422	hrd->setDpbOutputDelayLengthMinus1 (9); // max. 2^10
3423	}
3424
3425	/*
3426	Note: only the case of "vps_max_temporal_layers_minus1 = 0" is supported.
3427	*/
3428	Int i, j;
3429	UInt birateValue, cpbSizeValue;
3430	UInt ducpbSizeValue;
3431	UInt duBitRateValue = 0;
3432
3433	for( i = 0; i < MAX_TLAYER; i ++ )
3434	{
3435	hrd->setFixedPicRateFlag( i, 1 );
3436	hrd->setPicDurationInTcMinus1( i, 0 );
3437	hrd->setLowDelayHrdFlag( i, 0 );
3438	hrd->setCpbCntMinus1( i, 0 );
3439
3440	birateValue = bitRate;
3441	cpbSizeValue = bitRate; // 1 second
3442	ducpbSizeValue = bitRate/numDU;
3443	duBitRateValue = bitRate;
3444	for( j = 0; j < ( hrd->getCpbCntMinus1( i ) + 1 ); j ++ )
3445	{
3446	hrd->setBitRateValueMinus1( i, j, 0, ( birateValue - 1 ) );
3447	hrd->setCpbSizeValueMinus1( i, j, 0, ( cpbSizeValue - 1 ) );
3448	hrd->setDuCpbSizeValueMinus1( i, j, 0, ( ducpbSizeValue - 1 ) );
3449	hrd->setCbrFlag( i, j, 0, ( j == 0 ) );
3450
3451	hrd->setBitRateValueMinus1( i, j, 1, ( birateValue - 1) );
3452	hrd->setCpbSizeValueMinus1( i, j, 1, ( cpbSizeValue - 1 ) );
3453	hrd->setDuCpbSizeValueMinus1( i, j, 1, ( ducpbSizeValue - 1 ) );
3454	hrd->setDuBitRateValueMinus1( i, j, 1, ( duBitRateValue - 1 ) );
3455	hrd->setCbrFlag( i, j, 1, ( j == 0 ) );
3456	}
3457	}
3458	}
3459	#endif
3460
3461	Void TComVPS::deriveNecessaryLayerFlag()
3462	{
3463	m_necessaryLayerFlag.empty();
3464	m_numNecessaryLayers.empty();
3465	// Assumed that output layer sets and variables RecursiveRefLayer are already derived
3466	for( Int olsIdx = 0; olsIdx < m_numOutputLayerSets; olsIdx++)
3467	{
3468	deriveNecessaryLayerFlag(olsIdx);
3469	}
3470	}
3471
3472	Void TComVPS::deriveNecessaryLayerFlag(Int const olsIdx)
3473	{
3474	Int lsIdx = m_outputLayerSetIdx[olsIdx];
3475	Int numLayersInLs = m_numLayerInIdList[lsIdx];
3476	assert( m_necessaryLayerFlag.size() == olsIdx ); // Function should be called in the correct order.
3477	m_necessaryLayerFlag.push_back( std::vector<Bool>( numLayersInLs, false ) ); // Initialize to false
3478	for( Int lsLayerIdx = 0; lsLayerIdx < numLayersInLs; lsLayerIdx++ )
3479	{
3480	if( m_outputLayerFlag[olsIdx][lsLayerIdx] )
3481	{
3482	m_necessaryLayerFlag[olsIdx][lsLayerIdx] = true;
3483	Int currNuhLayerId = m_layerSetLayerIdList[lsIdx][lsLayerIdx];
3484	for( Int rLsLayerIdx = 0; rLsLayerIdx < lsLayerIdx; rLsLayerIdx++ )
3485	{
3486	Int refNuhLayerId = m_layerSetLayerIdList[lsIdx][rLsLayerIdx];
3487	if( m_recursiveRefLayerFlag[currNuhLayerId][refNuhLayerId] )
3488	{
3489	m_necessaryLayerFlag[olsIdx][rLsLayerIdx] = true;
3490	}
3491	}
3492	}
3493	}
3494	m_numNecessaryLayers.push_back(std::accumulate(m_necessaryLayerFlag[olsIdx].begin(), m_necessaryLayerFlag[olsIdx].end(), 0));
3495	}
3496
3497	Void TComVPS::checkNecessaryLayerFlagCondition()
3498	{
3499	/* It is a requirement of bitstream conformance that for each layer index layerIdx in the range of
3500	( vps_base_layer_internal_flag ? 0 : 1 ) to MaxLayersMinus1, inclusive, there shall be at least one OLS with index olsIdx such that
3501	NecessaryLayerFlag[ olsIdx ][ lsLayerIdx ] is equal to 1 for the value of lsLayerIdx
3502	for which LayerSetLayerIdList[ OlsIdxToLsIdx[ olsIdx ] ][ lsLayerIdx ] is equal to layer_id_in_nuh[ layerIdx ]. */
3503	for(Int layerIdx = m_baseLayerInternalFlag ? 0 : 1; layerIdx < m_uiMaxLayers; layerIdx++)
3504	{
3505	Bool layerFoundNecessaryLayerFlag = false;
3506	for(Int olsIdx = 0; olsIdx < m_numOutputLayerSets; olsIdx++)
3507	{
3508	Int lsIdx = m_outputLayerSetIdx[olsIdx];
3509	Int currNuhLayerId = m_layerIdInNuh[layerIdx];
3510	std::vector<Int>::iterator iter = std::find( m_layerSetLayerIdList[lsIdx].begin(), m_layerSetLayerIdList[lsIdx].end(), currNuhLayerId );
3511	if( iter != m_layerSetLayerIdList[lsIdx].end() ) // Layer present in layer set
3512	{
3513	size_t positionLayer = iter - m_layerSetLayerIdList[lsIdx].begin();
3514	if( *(m_necessaryLayerFlag[olsIdx].begin() + positionLayer) == true )
3515	{
3516	layerFoundNecessaryLayerFlag = true;
3517	break;
3518	}
3519	}
3520	}
3521	assert( layerFoundNecessaryLayerFlag );
3522	}
3523	}
3524
3525	Int TComVPS::calculateLenOfSyntaxElement( Int const numVal )
3526	{
3527	Int numBits = 1;
3528	while((1 << numBits) < numVal)
3529	{
3530	numBits++;
3531	}
3532	return numBits;
3533	}
3534
3535	Void TComVPS::calculateMaxSLInLayerSets()
3536	{
3537	for(Int lsIdx = 0; lsIdx < getNumLayerSets(); lsIdx++)
3538	{
3539	UInt maxSLMinus1 = 0;
3540	for(Int k = 0; k < getNumLayersInIdList(lsIdx); k++ ) {
3541	Int lId = getLayerSetLayerIdList(lsIdx, k);
3542	maxSLMinus1 = std::max(maxSLMinus1, getMaxTSLayersMinus1(getLayerIdxInVps(lId)));
3543	}
3544	setMaxSLayersInLayerSetMinus1(lsIdx,maxSLMinus1);
3545	}
3546	}
3547
3548	#if REPN_FORMAT_IN_VPS
3549	UInt TComSlice::getPicWidthInLumaSamples()
3550	{
3551	TComSPS *sps = getSPS();
3552	TComVPS *vps = getVPS();
3553	UInt retVal, layerId = getLayerId();
3554
3555	if ( layerId == 0 \|\| sps->getV1CompatibleSPSFlag() == 1 )
3556	{
3557	if( layerId == 0 && vps->getNonHEVCBaseLayerFlag() )
3558	{
3559	retVal = vps->getVpsRepFormat(layerId)->getPicWidthVpsInLumaSamples();
3560	}
3561	else
3562	{
3563	retVal = sps->getPicWidthInLumaSamples();
3564	}
3565	}
3566	else
3567	{
3568	retVal = vps->getVpsRepFormat(sps->getUpdateRepFormatFlag() ? sps->getUpdateRepFormatIndex() : vps->getVpsRepFormatIdx(vps->getLayerIdxInVps(layerId)))->getPicWidthVpsInLumaSamples();
3569	}
3570
3571	return retVal;
3572	}
3573
3574	UInt TComSlice::getPicHeightInLumaSamples()
3575	{
3576	TComSPS *sps = getSPS();
3577	TComVPS *vps = getVPS();
3578	UInt retVal, layerId = getLayerId();
3579
3580	if ( layerId == 0 \|\| sps->getV1CompatibleSPSFlag() == 1 )
3581	{
3582	if( layerId == 0 && vps->getNonHEVCBaseLayerFlag() )
3583	{
3584	retVal = vps->getVpsRepFormat(layerId)->getPicHeightVpsInLumaSamples();
3585	}
3586	else
3587	{
3588	retVal = sps->getPicHeightInLumaSamples();
3589	}
3590	}
3591	else
3592	{
3593	retVal = vps->getVpsRepFormat(sps->getUpdateRepFormatFlag() ? sps->getUpdateRepFormatIndex() : vps->getVpsRepFormatIdx(vps->getLayerIdxInVps(layerId)))->getPicHeightVpsInLumaSamples();
3594	}
3595
3596	return retVal;
3597	}
3598
3599	#if AUXILIARY_PICTURES
3600	ChromaFormat TComSlice::getChromaFormatIdc()
3601	#else
3602	UInt TComSlice::getChromaFormatIdc()
3603	#endif
3604	{
3605	TComSPS *sps = getSPS();
3606	TComVPS *vps = getVPS();
3607	#if AUXILIARY_PICTURES
3608	ChromaFormat retVal;
3609	UInt layerId = getLayerId();
3610	#else
3611	UInt retVal, layerId = getLayerId();
3612	#endif
3613
3614	if ( layerId == 0 \|\| sps->getV1CompatibleSPSFlag() == 1 )
3615	{
3616	if( layerId == 0 && vps->getNonHEVCBaseLayerFlag() )
3617	{
3618	retVal = vps->getVpsRepFormat(layerId)->getChromaFormatVpsIdc();
3619	}
3620	else
3621	{
3622	retVal = sps->getChromaFormatIdc();
3623	}
3624	}
3625	else
3626	{
3627	retVal = vps->getVpsRepFormat(sps->getUpdateRepFormatFlag() ? sps->getUpdateRepFormatIndex() : vps->getVpsRepFormatIdx(vps->getLayerIdxInVps(layerId)))->getChromaFormatVpsIdc();
3628	}
3629
3630	return retVal;
3631	}
3632
3633	UInt TComSlice::getBitDepthY()
3634	{
3635	TComSPS *sps = getSPS();
3636	TComVPS *vps = getVPS();
3637	UInt retVal, layerId = getLayerId();
3638
3639	if ( layerId == 0 \|\| sps->getV1CompatibleSPSFlag() == 1 )
3640	{
3641	if( layerId == 0 && vps->getNonHEVCBaseLayerFlag() )
3642	{
3643	retVal = vps->getVpsRepFormat(layerId)->getBitDepthVpsLuma();
3644	}
3645	else
3646	{
3647	retVal = sps->getBitDepth(CHANNEL_TYPE_LUMA);
3648	}
3649	}
3650	else
3651	{
3652	retVal = vps->getVpsRepFormat(sps->getUpdateRepFormatFlag() ? sps->getUpdateRepFormatIndex() : vps->getVpsRepFormatIdx(vps->getLayerIdxInVps(layerId)))->getBitDepthVpsLuma();
3653	}
3654
3655	return retVal;
3656	}
3657
3658	UInt TComSlice::getBitDepthC()
3659	{
3660	TComSPS *sps = getSPS();
3661	TComVPS *vps = getVPS();
3662	UInt retVal, layerId = getLayerId();
3663
3664	if ( layerId == 0 \|\| sps->getV1CompatibleSPSFlag() == 1 )
3665	{
3666	if( layerId == 0 && vps->getNonHEVCBaseLayerFlag() )
3667	{
3668	retVal = vps->getVpsRepFormat(layerId)->getBitDepthVpsChroma();
3669	}
3670	else
3671	{
3672	retVal = sps->getBitDepth(CHANNEL_TYPE_CHROMA);
3673	}
3674	}
3675	else
3676	{
3677	retVal = vps->getVpsRepFormat(sps->getUpdateRepFormatFlag() ? sps->getUpdateRepFormatIndex() : vps->getVpsRepFormatIdx(vps->getLayerIdxInVps(layerId)))->getBitDepthVpsChroma();
3678	}
3679
3680	return retVal;
3681	}
3682
3683	Int TComSlice::getQpBDOffsetY()
3684	{
3685	return (getBitDepthY() - 8) * 6;
3686	}
3687
3688	Int TComSlice::getQpBDOffsetC()
3689	{
3690	return (getBitDepthC() - 8) * 6;
3691	}
3692
3693	Window& TComSlice::getConformanceWindow()
3694	{
3695	TComSPS *sps = getSPS();
3696	TComVPS *vps = getVPS();
3697	UInt layerId = getLayerId();
3698
3699	if ( layerId == 0 \|\| sps->getV1CompatibleSPSFlag() == 1 )
3700	{
3701	if( layerId == 0 && vps->getNonHEVCBaseLayerFlag() )
3702	{
3703	return vps->getVpsRepFormat(layerId)->getConformanceWindowVps();
3704	}
3705	else
3706	{
3707	return sps->getConformanceWindow();
3708	}
3709	}
3710	else
3711	{
3712	return vps->getVpsRepFormat(sps->getUpdateRepFormatFlag() ? sps->getUpdateRepFormatIndex() : vps->getVpsRepFormatIdx(vps->getLayerIdxInVps(layerId)))->getConformanceWindowVps();
3713	}
3714	}
3715
3716	RepFormat::RepFormat()
3717	#if AUXILIARY_PICTURES
3718	: m_chromaFormatVpsIdc (CHROMA_420)
3719	#else
3720	: m_chromaFormatVpsIdc (0)
3721	#endif
3722	, m_separateColourPlaneVpsFlag (false)
3723	, m_picWidthVpsInLumaSamples (0)
3724	, m_picHeightVpsInLumaSamples (0)
3725	, m_bitDepthVpsLuma (0)
3726	, m_bitDepthVpsChroma (0)
3727	{}
3728	#endif //REPN_FORMAT_IN_VPS
3729
3730	Void TComPTL::copyProfileInfo(TComPTL *ptl)
3731	{
3732	// Copy all information related to general profile
3733	this->getGeneralPTL()->copyProfileInfo(ptl->getGeneralPTL());
3734	}
3735
3736	Bool TComSlice::setBaseColPic( TComList<TComPic*>& rcListPic, UInt refLayerIdc )
3737	{
3738	if(m_layerId == 0)
3739	{
3740	memset( m_pcBaseColPic, 0, sizeof( m_pcBaseColPic ) );
3741	return false;
3742	}
3743	#if POC_RESET_IDC_DECODER
3744	TComPic* pic = xGetRefPic( rcListPic, getPOC() );
3745
3746	if( pic )
3747	{
3748	setBaseColPic(refLayerIdc, pic );
3749	}
3750	else
3751	{
3752	return false;
3753	}
3754
3755	return true;
3756	#else
3757	setBaseColPic(refLayerIdc, xGetRefPic(rcListPic, getPOC()));
3758	return true;
3759	#endif
3760	}
3761
3762	#if MFM_ENCCONSTRAINT
3763	TComPic* TComSlice::getBaseColPic( TComList<TComPic*>& rcListPic )
3764	{
3765	return xGetRefPic( rcListPic, m_iPOC );
3766	}
3767	#endif
3768
3769	Void TComSlice::setILRPic(TComPic **pcIlpPic)
3770	{
3771	for( Int i = 0; i < m_activeNumILRRefIdx; i++ )
3772	{
3773	Int refLayerIdc = m_interLayerPredLayerIdc[i];
3774
3775	if( pcIlpPic[refLayerIdc] )
3776	{
3777	TComPic* pcRefPicBL = m_pcBaseColPic[refLayerIdc];
3778
3779	// copy scalability ratio, it is needed to get the correct location for the motion field of the corresponding reference layer block
3780	pcIlpPic[refLayerIdc]->setSpatialEnhLayerFlag( refLayerIdc, m_pcPic->isSpatialEnhLayer(refLayerIdc) );
3781
3782	pcIlpPic[refLayerIdc]->copyUpsampledPictureYuv( m_pcPic->getFullPelBaseRec( refLayerIdc ), pcIlpPic[refLayerIdc]->getPicYuvRec() );
3783	pcIlpPic[refLayerIdc]->getSlice(0)->setBaseColPic( refLayerIdc, pcRefPicBL );
3784
3785	//set reference picture POC of each ILP reference
3786	pcIlpPic[refLayerIdc]->getSlice(0)->setPOC( m_iPOC );
3787
3788	//set temporal Id
3789	pcIlpPic[refLayerIdc]->getSlice(0)->setTLayer( m_uiTLayer );
3790
3791	//copy layer id from the reference layer
3792	pcIlpPic[refLayerIdc]->setLayerId( pcRefPicBL->getLayerId() );
3793	pcIlpPic[refLayerIdc]->getSlice(0)->setLayerId(pcRefPicBL->getLayerId());
3794
3795	pcIlpPic[refLayerIdc]->getPicYuvRec()->setBorderExtension( false );
3796	pcIlpPic[refLayerIdc]->getPicYuvRec()->extendPicBorder();
3797	for (Int j=0; j<pcIlpPic[refLayerIdc]->getPicSym()->getNumberOfCtusInFrame(); j++) // set reference CU layerId
3798	{
3799	pcIlpPic[refLayerIdc]->getPicSym()->getCtu(j)->setLayerId( pcIlpPic[refLayerIdc]->getLayerId() );
3800	}
3801	pcIlpPic[refLayerIdc]->setIsLongTerm(1);
3802
3803	// assign PPS to ILRP to be used for reference location offsets
3804	pcIlpPic[refLayerIdc]->getSlice(0)->setPPS( m_pcPic->getSlice(0)->getPPS() );
3805
3806	// assing VPS to ILRP to be used for deriving layerIdx
3807	pcIlpPic[refLayerIdc]->getSlice(0)->setVPS( m_pcPic->getSlice(0)->getVPS() );
3808
3809	#if REF_IDX_MFM
3810	if( m_bMFMEnabledFlag && !(m_eNalUnitType >= NAL_UNIT_CODED_SLICE_BLA_W_LP && m_eNalUnitType <= NAL_UNIT_CODED_SLICE_CRA) )
3811	{
3812	//set reference picture POC of each ILP reference
3813	assert( pcIlpPic[refLayerIdc]->getPOC() == pcRefPicBL->getPOC() );
3814
3815	//copy slice type from the reference layer
3816	pcIlpPic[refLayerIdc]->getSlice(0)->setSliceType( pcRefPicBL->getSlice(0)->getSliceType() );
3817
3818	//copy "used for reference"
3819	pcIlpPic[refLayerIdc]->getSlice(0)->setReferenced( pcRefPicBL->getSlice(0)->isReferenced() );
3820
3821	for( Int refList = 0; refList < 2; refList++ )
3822	{
3823	RefPicList refPicList = RefPicList( refList );
3824
3825	//set reference POC of ILP
3826	pcIlpPic[refLayerIdc]->getSlice(0)->setNumRefIdx(refPicList, pcRefPicBL->getSlice(0)->getNumRefIdx(refPicList));
3827	assert(pcIlpPic[refLayerIdc]->getSlice(0)->getNumRefIdx(refPicList) >= 0);
3828	assert(pcIlpPic[refLayerIdc]->getSlice(0)->getNumRefIdx(refPicList) <= MAX_NUM_REF);
3829
3830	//initialize reference POC of ILP
3831	for(Int refIdx = 0; refIdx < pcRefPicBL->getSlice(0)->getNumRefIdx(refPicList); refIdx++)
3832	{
3833	pcIlpPic[refLayerIdc]->getSlice(0)->setRefPOC(pcRefPicBL->getSlice(0)->getRefPOC(refPicList, refIdx), refPicList, refIdx);
3834	pcIlpPic[refLayerIdc]->getSlice(0)->setRefPic(pcRefPicBL->getSlice(0)->getRefPic(refPicList, refIdx), refPicList, refIdx);
3835	}
3836
3837	for(Int refIdx = pcRefPicBL->getSlice(0)->getNumRefIdx(refPicList); refIdx < MAX_NUM_REF; refIdx++)
3838	{
3839	pcIlpPic[refLayerIdc]->getSlice(0)->setRefPOC(0, refPicList, refIdx);
3840	pcIlpPic[refLayerIdc]->getSlice(0)->setRefPic(NULL, refPicList, refIdx);
3841	}
3842
3843	//copy reference pictures' marking from the reference layer
3844	for(Int j = 0; j < MAX_NUM_REF + 1; j++)
3845	{
3846	pcIlpPic[refLayerIdc]->getSlice(0)->setIsUsedAsLongTerm(refList, j, pcRefPicBL->getSlice(0)->getIsUsedAsLongTerm(refList, j));
3847	}
3848	}
3849
3850	pcIlpPic[refLayerIdc]->copyUpsampledMvField( refLayerIdc, m_pcBaseColPic[refLayerIdc] );
3851	}
3852	else
3853	{
3854	pcIlpPic[refLayerIdc]->initUpsampledMvField();
3855	}
3856	#endif
3857
3858	Int maxTidIlRefPicsPlus1 = m_pcVPS->getMaxTidIlRefPicsPlus1( pcIlpPic[refLayerIdc]->getSlice(0)->getLayerIdx(), getLayerIdx() );
3859	assert( (Int)pcIlpPic[refLayerIdc]->getSlice(0)->getTLayer() < maxTidIlRefPicsPlus1 \|\| ( !maxTidIlRefPicsPlus1 && pcIlpPic[refLayerIdc]->getSlice(0)->getRapPicFlag() ) );
3860
3861	}
3862	}
3863	}
3864
3865	Int TComSlice::getReferenceLayerIdc( UInt refLayerId )
3866	{
3867	for( Int i = 0; i < m_activeNumILRRefIdx; i++ )
3868	{
3869	if( m_pcVPS->getRefLayerId(m_layerId, m_interLayerPredLayerIdc[i]) == refLayerId )
3870	{
3871	return m_interLayerPredLayerIdc[i];
3872	}
3873	}
3874
3875	return -1;
3876	}
3877
3878	Bool TComSlice::getBlaPicFlag ()
3879	{
3880	return getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
3881	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
3882	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP;
3883	}
3884
3885	Bool TComSlice::getCraPicFlag ()
3886	{
3887	return getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA;
3888	}
3889
3890	#if POC_RESET_IDC_DECODER
3891	Bool TComSlice::getRaslPicFlag ()
3892	{
3893	return getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_R
3894	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N;
3895	}
3896	Bool TComSlice::getRadlPicFlag ()
3897	{
3898	return getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_R
3899	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N;
3900	}
3901	#endif
3902	#if POC_RESET_IDC_ENCODER
3903	Void TComSlice::decrementRefPocValues(Int const decrementValue)
3904	{
3905	for(Int listNum = 0; listNum < 2; listNum++)
3906	{
3907	RefPicList dpbPicSliceList = (listNum == 1) ? REF_PIC_LIST_1 : REF_PIC_LIST_0;
3908	for(Int listIdx = 0; listIdx < getNumRefIdx( dpbPicSliceList ); listIdx++)
3909	{
3910	setRefPOC( getRefPOC(dpbPicSliceList, listIdx) - decrementValue,
3911	dpbPicSliceList,
3912	listIdx
3913	);
3914	}
3915	}
3916	}
3917
3918	Int TComSlice::getCurrMsb( Int currLsb, Int prevLsb, Int prevMsb, Int maxLsbVal )
3919	{
3920	if( prevLsb - currLsb >= (maxLsbVal >> 1) )
3921	{
3922	return prevMsb + maxLsbVal;
3923	}
3924	else if( currLsb - prevLsb > (maxLsbVal >> 1) )
3925	{
3926	return prevMsb - maxLsbVal;
3927	}
3928	else
3929	{
3930	return prevMsb;
3931	}
3932	}
3933	#endif
3934
3935	Void TComSlice::setRefPicListModificationSvc()
3936	{
3937	if( !m_pcPPS->getListsModificationPresentFlag())
3938	{
3939	return;
3940	}
3941
3942	if(m_eNalUnitType >= NAL_UNIT_CODED_SLICE_BLA_W_LP && m_eNalUnitType <= NAL_UNIT_CODED_SLICE_CRA)
3943	{
3944	return;
3945	}
3946
3947	TComRefPicListModification* refPicListModification = &m_RefPicListModification;
3948	Int numberOfRpsCurrTempList = this->getNumRpsCurrTempList(); // total number of ref pics in listTemp0 including inter-layer ref pics
3949	#if RPL_INIT_N0316_N0082
3950	Int numberOfPocBeforeCurr = this->getNumNegativeRpsCurrTempList(); // number of negative temporal ref pics
3951	#endif
3952
3953	assert(m_aiNumRefIdx[REF_PIC_LIST_0] > 0);
3954	assert(m_aiNumRefIdx[REF_PIC_LIST_1] > 0);
3955
3956	//set L0 inter-layer reference picture modification
3957	#if RPL_INIT_N0316_N0082
3958	Bool hasModification = (m_aiNumRefIdx[REF_PIC_LIST_0] == (numberOfPocBeforeCurr + m_activeNumILRRefIdx)) ? false : true;
3959
3960	if( m_activeNumILRRefIdx > 1 )
3961	{
3962	hasModification = (m_aiNumRefIdx[REF_PIC_LIST_0] >= (numberOfPocBeforeCurr + m_activeNumILRRefIdx)) ? false : true;
3963	}
3964	#else
3965	Bool hasModification = (m_aiNumRefIdx[REF_PIC_LIST_0] == numberOfRpsCurrTempList) ? false : true;
3966	#endif
3967	hasModification = hasModification && ( m_aiNumRefIdx[REF_PIC_LIST_0] > 1 );
3968	refPicListModification->setRefPicListModificationFlagL0(hasModification);
3969	if(hasModification)
3970	{
3971	for(Int i = 0; i < min(m_aiNumRefIdx[REF_PIC_LIST_0], numberOfRpsCurrTempList); i++)
3972	{
3973	refPicListModification->setRefPicSetIdxL0(i, i);
3974	}
3975
3976	if(m_aiNumRefIdx[REF_PIC_LIST_0] > numberOfRpsCurrTempList)
3977	{
3978	// repeat last ref pic when the number of active ref idx are more than RPS entries
3979	for (Int i = numberOfRpsCurrTempList; i < m_aiNumRefIdx[REF_PIC_LIST_0]; i ++)
3980	{
3981	refPicListModification->setRefPicSetIdxL0(i, numberOfRpsCurrTempList - 1);
3982	}
3983	}
3984	else
3985	{
3986	// number of ILRPs included into the reference picture list with the list modification
3987	Int includeNumILRP = min( max(1, m_aiNumRefIdx[REF_PIC_LIST_0]-numberOfPocBeforeCurr), m_activeNumILRRefIdx);
3988
3989	for(Int i = includeNumILRP; i > 0; i-- )
3990	{
3991	#if RPL_INIT_N0316_N0082
3992	if((numberOfPocBeforeCurr) >= m_aiNumRefIdx[REF_PIC_LIST_0])
3993	{
3994	refPicListModification->setRefPicSetIdxL0(m_aiNumRefIdx[REF_PIC_LIST_0] - i, numberOfPocBeforeCurr + includeNumILRP - i);
3995	}
3996	else
3997	{
3998	refPicListModification->setRefPicSetIdxL0(m_aiNumRefIdx[REF_PIC_LIST_0] - i, numberOfPocBeforeCurr + includeNumILRP - i);
3999	for (Int j = numberOfPocBeforeCurr; j < (m_aiNumRefIdx[REF_PIC_LIST_0] - i); j++)
4000	{
4001	assert( j + includeNumILRP < numberOfRpsCurrTempList );
4002	refPicListModification->setRefPicSetIdxL0(j, j + includeNumILRP);
4003	}
4004	}
4005	#else
4006	refPicListModification->setRefPicSetIdxL0(m_aiNumRefIdx[REF_PIC_LIST_0] - i, numberOfRpsCurrTempList - i);
4007	#endif
4008	}
4009	}
4010	}
4011
4012	//set L1 inter-layer reference picture modification
4013	hasModification = (m_aiNumRefIdx[REF_PIC_LIST_1] >= numberOfRpsCurrTempList) ? false : true;
4014	hasModification = hasModification && ( m_aiNumRefIdx[REF_PIC_LIST_1] > 1 );
4015
4016	refPicListModification->setRefPicListModificationFlagL1(hasModification);
4017	if(hasModification)
4018	{
4019	for(Int i = 0; i < min(m_aiNumRefIdx[REF_PIC_LIST_1], numberOfRpsCurrTempList); i++)
4020	{
4021	refPicListModification->setRefPicSetIdxL1(i, i);
4022	}
4023	if(m_aiNumRefIdx[REF_PIC_LIST_1] > numberOfRpsCurrTempList)
4024	{
4025	for (Int i = numberOfRpsCurrTempList; i < m_aiNumRefIdx[REF_PIC_LIST_1]; i ++)
4026	{
4027	// repeat last ref pic when the number of active ref idx are more than RPS entries
4028	refPicListModification->setRefPicSetIdxL1(i, numberOfRpsCurrTempList - 1);
4029	}
4030	}
4031	else
4032	{
4033	Int includeNumILRP = min(m_aiNumRefIdx[REF_PIC_LIST_1], m_activeNumILRRefIdx);
4034
4035	for(Int i = includeNumILRP; i > 0; i-- )
4036	{
4037	refPicListModification->setRefPicSetIdxL1(m_aiNumRefIdx[REF_PIC_LIST_1] - i, numberOfRpsCurrTempList - i);
4038	}
4039	}
4040	}
4041	return;
4042	}
4043
4044	#if RPL_INIT_N0316_N0082
4045	Int TComSlice::getNumNegativeRpsCurrTempList()
4046	{
4047	if( m_eSliceType == I_SLICE )
4048	{
4049	return 0;
4050	}
4051
4052	Int numPocBeforeCurr = 0;
4053	for( UInt i = 0; i < m_pcRPS->getNumberOfNegativePictures(); i++ )
4054	{
4055	if(m_pcRPS->getUsed(i))
4056	{
4057	numPocBeforeCurr++;
4058	}
4059	}
4060
4061	return numPocBeforeCurr;
4062	}
4063	#endif
4064	#endif //SVC_EXTENSION
4065
4066	//! \}

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

Download in other formats: