Context navigation

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

Visit:

Last change on this file since 501 was 494, checked in by seregin, 11 years ago
reintegrate branch SHM-4.0-dev
Property svn:eol-style set to `native`
File size: 100.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-2013, ITU/ISO/IEC
7	* All rights reserved.
8	*
9	* Redistribution and use in source and binary forms, with or without
10	* modification, are permitted provided that the following conditions are met:
11	*
12	* * Redistributions of source code must retain the above copyright notice,
13	* this list of conditions and the following disclaimer.
14	* * Redistributions in binary form must reproduce the above copyright notice,
15	* this list of conditions and the following disclaimer in the documentation
16	* and/or other materials provided with the distribution.
17	* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18	* be used to endorse or promote products derived from this software without
19	* specific prior written permission.
20	*
21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31	* THE POSSIBILITY OF SUCH DAMAGE.
32	*/
33
34	/** \file 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	//! \ingroup TLibCommon
45	//! \{
46
47	#if SVC_EXTENSION
48	ParameterSetMap<TComVPS> ParameterSetManager::m_vpsMap(MAX_NUM_VPS);
49	Int ParameterSetManager::m_activeVPSId = -1;
50	#if IL_SL_SIGNALLING_N0371
51	TComSPS* TComSPS::m_pcSPS[MAX_LAYERS];
52	TComPPS* TComPPS::m_pcPPS[MAX_LAYERS];
53	#endif
54	#endif
55
56	TComSlice::TComSlice()
57	: m_iPPSId ( -1 )
58	, m_iPOC ( 0 )
59	, m_iLastIDR ( 0 )
60	, m_eNalUnitType ( NAL_UNIT_CODED_SLICE_IDR_W_RADL )
61	, m_eSliceType ( I_SLICE )
62	, m_iSliceQp ( 0 )
63	, m_dependentSliceSegmentFlag ( false )
64	#if ADAPTIVE_QP_SELECTION
65	, m_iSliceQpBase ( 0 )
66	#endif
67	, m_deblockingFilterDisable ( false )
68	, m_deblockingFilterOverrideFlag ( false )
69	, m_deblockingFilterBetaOffsetDiv2 ( 0 )
70	, m_deblockingFilterTcOffsetDiv2 ( 0 )
71	, m_bCheckLDC ( false )
72	, m_iSliceQpDelta ( 0 )
73	, m_iSliceQpDeltaCb ( 0 )
74	, m_iSliceQpDeltaCr ( 0 )
75	, m_iDepth ( 0 )
76	, m_bRefenced ( false )
77	, m_pcSPS ( NULL )
78	, m_pcPPS ( NULL )
79	, m_pcPic ( NULL )
80	, m_colFromL0Flag ( 1 )
81	, m_colRefIdx ( 0 )
82	#if SAO_CHROMA_LAMBDA
83	, m_dLambdaLuma( 0.0 )
84	, m_dLambdaChroma( 0.0 )
85	#else
86	, m_dLambda ( 0.0 )
87	#endif
88	, m_uiTLayer ( 0 )
89	, m_bTLayerSwitchingFlag ( false )
90	, m_sliceMode ( 0 )
91	, m_sliceArgument ( 0 )
92	, m_sliceCurStartCUAddr ( 0 )
93	, m_sliceCurEndCUAddr ( 0 )
94	, m_sliceIdx ( 0 )
95	, m_sliceSegmentMode ( 0 )
96	, m_sliceSegmentArgument ( 0 )
97	, m_sliceSegmentCurStartCUAddr ( 0 )
98	, m_sliceSegmentCurEndCUAddr ( 0 )
99	, m_nextSlice ( false )
100	, m_nextSliceSegment ( false )
101	, m_sliceBits ( 0 )
102	, m_sliceSegmentBits ( 0 )
103	, m_bFinalized ( false )
104	, m_uiTileOffstForMultES ( 0 )
105	, m_puiSubstreamSizes ( NULL )
106	, m_cabacInitFlag ( false )
107	, m_bLMvdL1Zero ( false )
108	, m_numEntryPointOffsets ( 0 )
109	, m_temporalLayerNonReferenceFlag ( false )
110	, m_enableTMVPFlag ( true )
111	#if SVC_EXTENSION
112	, m_layerId ( 0 )
113	#if REF_IDX_MFM
114	, m_bMFMEnabledFlag ( false )
115	#endif
116	#if POC_RESET_FLAG
117	, m_bPocResetFlag ( false )
118	#endif
119	, m_bDiscardableFlag ( false )
120	#endif //SVC_EXTENSION
121	{
122	m_aiNumRefIdx[0] = m_aiNumRefIdx[1] = 0;
123
124	#if SVC_EXTENSION
125	memset( m_pcBaseColPic, 0, sizeof( m_pcBaseColPic ) );
126	#if JCTVC_M0458_INTERLAYER_RPS_SIG
127	m_activeNumILRRefIdx = 0;
128	m_interLayerPredEnabledFlag = 0;
129	::memset( m_interLayerPredLayerIdc, 0, sizeof(m_interLayerPredLayerIdc) );
130	#else
131	m_numILRRefIdx = 0;
132	#endif
133	#if M0457_COL_PICTURE_SIGNALING && !REMOVE_COL_PICTURE_SIGNALING
134	m_altColIndicationFlag = false;
135	m_colRefLayerIdx = 0;
136	#endif
137	#if M0457_IL_SAMPLE_PRED_ONLY_FLAG
138	m_numSamplePredRefLayers = 0;
139	m_interLayerSamplePredOnlyFlag = false;
140	#endif
141	#endif //SVC_EXTENSION
142
143	initEqualRef();
144
145	for ( Int idx = 0; idx < MAX_NUM_REF; idx++ )
146	{
147	m_list1IdxToList0Idx[idx] = -1;
148	}
149	for(Int iNumCount = 0; iNumCount < MAX_NUM_REF; iNumCount++)
150	{
151	m_apcRefPicList [0][iNumCount] = NULL;
152	m_apcRefPicList [1][iNumCount] = NULL;
153	m_aiRefPOCList [0][iNumCount] = 0;
154	m_aiRefPOCList [1][iNumCount] = 0;
155	}
156	resetWpScaling();
157	initWpAcDcParam();
158	m_saoEnabledFlag = false;
159	}
160
161	TComSlice::~TComSlice()
162	{
163	delete[] m_puiSubstreamSizes;
164	m_puiSubstreamSizes = NULL;
165	}
166
167
168	#if SVC_EXTENSION
169	Void TComSlice::initSlice( UInt layerId )
170	#else
171	Void TComSlice::initSlice()
172	#endif
173	{
174	#if SVC_EXTENSION
175	m_layerId = layerId;
176	#if JCTVC_M0458_INTERLAYER_RPS_SIG
177	m_activeNumILRRefIdx = 0;
178	m_interLayerPredEnabledFlag = 0;
179	#else
180	m_numILRRefIdx = 0;
181	#endif
182	#if M0457_IL_SAMPLE_PRED_ONLY_FLAG
183	m_numSamplePredRefLayers = 0;
184	m_interLayerSamplePredOnlyFlag = false;
185	#endif
186	#endif
187	m_aiNumRefIdx[0] = 0;
188	m_aiNumRefIdx[1] = 0;
189
190	m_colFromL0Flag = 1;
191
192	m_colRefIdx = 0;
193	initEqualRef();
194	m_bCheckLDC = false;
195	m_iSliceQpDeltaCb = 0;
196	m_iSliceQpDeltaCr = 0;
197
198	m_maxNumMergeCand = MRG_MAX_NUM_CANDS;
199
200	m_bFinalized=false;
201
202	m_tileByteLocation.clear();
203	m_cabacInitFlag = false;
204	m_numEntryPointOffsets = 0;
205	m_enableTMVPFlag = true;
206	}
207
208	Bool TComSlice::getRapPicFlag()
209	{
210	return getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
211	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP
212	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
213	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
214	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
215	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA;
216	}
217
218	/**
219	- allocate table to contain substream sizes to be written to the slice header.
220	.
221	\param uiNumSubstreams Number of substreams -- the allocation will be this value - 1.
222	*/
223	Void TComSlice::allocSubstreamSizes(UInt uiNumSubstreams)
224	{
225	delete[] m_puiSubstreamSizes;
226	m_puiSubstreamSizes = new UInt[uiNumSubstreams > 0 ? uiNumSubstreams-1 : 0];
227	}
228
229	Void TComSlice::sortPicList(TComList<TComPic*>& rcListPic)
230	{
231	TComPic* pcPicExtract;
232	TComPic* pcPicInsert;
233
234	TComList<TComPic*>::iterator iterPicExtract;
235	TComList<TComPic*>::iterator iterPicExtract_1;
236	TComList<TComPic*>::iterator iterPicInsert;
237
238	for (Int i = 1; i < (Int)(rcListPic.size()); i++)
239	{
240	iterPicExtract = rcListPic.begin();
241	for (Int j = 0; j < i; j++) iterPicExtract++;
242	pcPicExtract = *(iterPicExtract);
243	pcPicExtract->setCurrSliceIdx(0);
244
245	iterPicInsert = rcListPic.begin();
246	while (iterPicInsert != iterPicExtract)
247	{
248	pcPicInsert = *(iterPicInsert);
249	pcPicInsert->setCurrSliceIdx(0);
250	if (pcPicInsert->getPOC() >= pcPicExtract->getPOC())
251	{
252	break;
253	}
254
255	iterPicInsert++;
256	}
257
258	iterPicExtract_1 = iterPicExtract; iterPicExtract_1++;
259
260	// swap iterPicExtract and iterPicInsert, iterPicExtract = curr. / iterPicInsert = insertion position
261	rcListPic.insert (iterPicInsert, iterPicExtract, iterPicExtract_1);
262	rcListPic.erase (iterPicExtract);
263	}
264	}
265
266	TComPic* TComSlice::xGetRefPic (TComList<TComPic*>& rcListPic,
267	Int poc)
268	{
269	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
270	TComPic* pcPic = *(iterPic);
271	while ( iterPic != rcListPic.end() )
272	{
273	if(pcPic->getPOC() == poc)
274	{
275	break;
276	}
277	iterPic++;
278	pcPic = *(iterPic);
279	}
280	#if POC_RESET_FLAG
281	assert( pcPic->getSlice(0)->isReferenced() );
282	#endif
283	return pcPic;
284	}
285
286
287	TComPic* TComSlice::xGetLongTermRefPic(TComList<TComPic*>& rcListPic, Int poc, Bool pocHasMsb)
288	{
289	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
290	TComPic* pcPic = *(iterPic);
291	TComPic* pcStPic = pcPic;
292
293	Int pocCycle = 1 << getSPS()->getBitsForPOC();
294	if (!pocHasMsb)
295	{
296	poc = poc & (pocCycle - 1);
297	}
298
299	while ( iterPic != rcListPic.end() )
300	{
301	pcPic = *(iterPic);
302	if (pcPic && pcPic->getPOC()!=this->getPOC() && pcPic->getSlice( 0 )->isReferenced())
303	{
304	Int picPoc = pcPic->getPOC();
305	if (!pocHasMsb)
306	{
307	picPoc = picPoc & (pocCycle - 1);
308	}
309
310	if (poc == picPoc)
311	{
312	if (pcPic->getIsLongTerm())
313	{
314	return pcPic;
315	}
316	else
317	{
318	pcStPic = pcPic;
319	}
320	break;
321	}
322	}
323
324	iterPic++;
325	}
326
327	return pcStPic;
328	}
329
330	Void TComSlice::setRefPOCList()
331	{
332	for (Int iDir = 0; iDir < 2; iDir++)
333	{
334	for (Int iNumRefIdx = 0; iNumRefIdx < m_aiNumRefIdx[iDir]; iNumRefIdx++)
335	{
336	m_aiRefPOCList[iDir][iNumRefIdx] = m_apcRefPicList[iDir][iNumRefIdx]->getPOC();
337	}
338	}
339
340	}
341
342	Void TComSlice::setList1IdxToList0Idx()
343	{
344	Int idxL0, idxL1;
345	for ( idxL1 = 0; idxL1 < getNumRefIdx( REF_PIC_LIST_1 ); idxL1++ )
346	{
347	m_list1IdxToList0Idx[idxL1] = -1;
348	for ( idxL0 = 0; idxL0 < getNumRefIdx( REF_PIC_LIST_0 ); idxL0++ )
349	{
350	if ( m_apcRefPicList[REF_PIC_LIST_0][idxL0]->getPOC() == m_apcRefPicList[REF_PIC_LIST_1][idxL1]->getPOC() )
351	{
352	m_list1IdxToList0Idx[idxL1] = idxL0;
353	break;
354	}
355	}
356	}
357	}
358
359	#if FIX1071
360	#if SVC_EXTENSION
361	Void TComSlice::setRefPicList( TComList<TComPic>& rcListPic, Bool checkNumPocTotalCurr, TComPic* ilpPic)
362	#else
363	Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr )
364	#endif
365	#else
366	Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic )
367	#endif
368	{
369	#if FIX1071
370	if (!checkNumPocTotalCurr)
371	#endif
372	{
373	if (m_eSliceType == I_SLICE)
374	{
375	::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
376	::memset( m_aiNumRefIdx, 0, sizeof ( m_aiNumRefIdx ));
377
378	return;
379	}
380
381	m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
382	m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
383	}
384
385	TComPic* pcRefPic= NULL;
386	TComPic* RefPicSetStCurr0[16];
387	TComPic* RefPicSetStCurr1[16];
388	TComPic* RefPicSetLtCurr[16];
389	UInt NumPocStCurr0 = 0;
390	UInt NumPocStCurr1 = 0;
391	UInt NumPocLtCurr = 0;
392	Int i;
393
394	#if SVC_EXTENSION
395	if( m_layerId == 0 \|\| ( m_layerId > 0 && ( m_activeNumILRRefIdx == 0 \|\| !((getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP) && (getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA)) ) ) )
396	{
397	#endif
398	for(i=0; i < m_pcRPS->getNumberOfNegativePictures(); i++)
399	{
400	if(m_pcRPS->getUsed(i))
401	{
402	pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
403	pcRefPic->setIsLongTerm(0);
404	pcRefPic->getPicYuvRec()->extendPicBorder();
405	RefPicSetStCurr0[NumPocStCurr0] = pcRefPic;
406	#if M0457_IL_SAMPLE_PRED_ONLY_FLAG
407	if( !m_interLayerSamplePredOnlyFlag \|\| pcRefPic->getLayerId() < getLayerId())
408	#endif
409	NumPocStCurr0++;
410	pcRefPic->setCheckLTMSBPresent(false);
411	}
412	}
413
414	for(; i < m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures(); i++)
415	{
416	if(m_pcRPS->getUsed(i))
417	{
418	pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
419	pcRefPic->setIsLongTerm(0);
420	pcRefPic->getPicYuvRec()->extendPicBorder();
421	RefPicSetStCurr1[NumPocStCurr1] = pcRefPic;
422	#if M0457_IL_SAMPLE_PRED_ONLY_FLAG
423	if( !m_interLayerSamplePredOnlyFlag \|\| pcRefPic->getLayerId() < getLayerId())
424	#endif
425	NumPocStCurr1++;
426	pcRefPic->setCheckLTMSBPresent(false);
427	}
428	}
429
430	for(i = m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()+m_pcRPS->getNumberOfLongtermPictures()-1; i > m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()-1 ; i--)
431	{
432	if(m_pcRPS->getUsed(i))
433	{
434	pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
435	pcRefPic->setIsLongTerm(1);
436	pcRefPic->getPicYuvRec()->extendPicBorder();
437	RefPicSetLtCurr[NumPocLtCurr] = pcRefPic;
438	#if M0457_IL_SAMPLE_PRED_ONLY_FLAG
439	if( !m_interLayerSamplePredOnlyFlag \|\| pcRefPic->getLayerId() < getLayerId())
440	#endif
441	NumPocLtCurr++;
442	}
443	if(pcRefPic==NULL)
444	{
445	pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
446	}
447	pcRefPic->setCheckLTMSBPresent(m_pcRPS->getCheckLTMSBPresent(i));
448	}
449	#if SVC_EXTENSION
450	}
451	#endif
452
453	#if SVC_EXTENSION
454	for( i = 0; i < m_activeNumILRRefIdx; i++ )
455	{
456	UInt refLayerIdc = m_interLayerPredLayerIdc[i];
457	//inter-layer reference picture
458	#if O0225_MAX_TID_FOR_REF_LAYERS
459	Int maxTidIlRefPicsPlus1 = ( m_layerId > 0 && m_activeNumILRRefIdx > 0)? m_pcVPS->getMaxTidIlRefPicsPlus1(ilpPic[refLayerIdc]->getSlice(0)->getLayerId(),m_layerId) : 0;
460	#else
461	Int maxTidIlRefPicsPlus1 = ( m_layerId > 0 && m_activeNumILRRefIdx > 0)? m_pcVPS->getMaxTidIlRefPicsPlus1(ilpPic[refLayerIdc]->getSlice(0)->getLayerId()) : 0;
462	#endif
463	if( m_layerId > 0 && m_activeNumILRRefIdx > 0 && ( ( (Int)(ilpPic[refLayerIdc]->getSlice(0)->getTLayer())<= maxTidIlRefPicsPlus1-1) \|\| (maxTidIlRefPicsPlus1==0 && ilpPic[refLayerIdc]->getSlice(0)->getRapPicFlag()) ) )
464	{
465	#if REF_IDX_MFM
466	#if M0457_COL_PICTURE_SIGNALING
467	if(!(m_eNalUnitType >= NAL_UNIT_CODED_SLICE_BLA_W_LP && m_eNalUnitType <= NAL_UNIT_CODED_SLICE_CRA) && getMFMEnabledFlag())
468	#else
469	if(!(m_eNalUnitType >= NAL_UNIT_CODED_SLICE_BLA_W_LP && m_eNalUnitType <= NAL_UNIT_CODED_SLICE_CRA) && m_pcSPS->getMFMEnabledFlag())
470	#endif
471	{
472	ilpPic[refLayerIdc]->copyUpsampledMvField( refLayerIdc, m_pcBaseColPic[refLayerIdc] );
473	}
474	else
475	{
476	ilpPic[refLayerIdc]->initUpsampledMvField();
477	}
478	#endif
479	ilpPic[refLayerIdc]->setIsLongTerm(1);
480	}
481	}
482	#endif
483	// ref_pic_list_init
484	TComPic* rpsCurrList0[MAX_NUM_REF+1];
485	TComPic* rpsCurrList1[MAX_NUM_REF+1];
486	#if SVC_EXTENSION
487	Int numInterLayerRPSPics = 0;
488	#if M0040_ADAPTIVE_RESOLUTION_CHANGE
489	if( m_layerId > 0 && m_activeNumILRRefIdx > 0 )
490	#else
491	if( m_layerId > 0 )
492	#endif
493	{
494	for( i=0; i < m_pcVPS->getNumDirectRefLayers( m_layerId ); i++ )
495	{
496	#if O0225_MAX_TID_FOR_REF_LAYERS
497	Int maxTidIlRefPicsPlus1 = getVPS()->getMaxTidIlRefPicsPlus1(ilpPic[i]->getSlice(0)->getLayerId(),m_layerId);
498	#else
499	Int maxTidIlRefPicsPlus1 = getVPS()->getMaxTidIlRefPicsPlus1(ilpPic[i]->getSlice(0)->getLayerId());
500	#endif
501	if( ((Int)(ilpPic[i]->getSlice(0)->getTLayer())<= maxTidIlRefPicsPlus1-1) \|\| (maxTidIlRefPicsPlus1==0 && ilpPic[i]->getSlice(0)->getRapPicFlag() ) )
502	{
503	numInterLayerRPSPics++;
504	}
505	}
506	#if JCTVC_M0458_INTERLAYER_RPS_SIG
507	if (numInterLayerRPSPics < m_activeNumILRRefIdx)
508	{
509	m_activeNumILRRefIdx = numInterLayerRPSPics;
510	}
511	#if MAX_ONE_RESAMPLING_DIRECT_LAYERS
512	#if SCALABILITY_MASK_E0104
513	if( m_pcVPS->getScalabilityMask(2) )
514	#else
515	if( m_pcVPS->getScalabilityMask(1) )
516	#endif
517	{
518	Int numResampler = 0;
519	#if MOTION_RESAMPLING_CONSTRAINT
520	Int numMotionResamplers = 0;
521	Int refResamplingLayer[MAX_LAYERS];
522	memset( refResamplingLayer, 0, sizeof( refResamplingLayer ) );
523	#endif
524	const Window &scalEL = getSPS()->getScaledRefLayerWindow(m_interLayerPredLayerIdc[i]);
525	Int scalingOffset = ((scalEL.getWindowLeftOffset() == 0 ) &&
526	(scalEL.getWindowRightOffset() == 0 ) &&
527	(scalEL.getWindowTopOffset() == 0 ) &&
528	(scalEL.getWindowBottomOffset() == 0 )
529	);
530
531	for( i=0; i < m_activeNumILRRefIdx; i++ )
532	{
533	UInt refLayerIdc = m_interLayerPredLayerIdc[i];
534	if(!( g_posScalingFactor[refLayerIdc][0] == 65536 && g_posScalingFactor[refLayerIdc][1] == 65536 ) \|\| (!scalingOffset)) // ratio 1x
535	{
536	#if MOTION_RESAMPLING_CONSTRAINT
537	UInt predType = m_pcVPS->getDirectDependencyType( m_layerId, m_pcVPS->getRefLayerId( m_layerId, refLayerIdc ) ) + 1;
538
539	if( predType & 0x1 )
540	{
541	numResampler++;
542	refResamplingLayer[i] = refLayerIdc + 1;
543	}
544
545	if( predType & 0x2 )
546	{
547	numMotionResamplers++;
548	refResamplingLayer[i] -= refLayerIdc + 1;
549	}
550	#else
551	numResampler++;
552	#endif
553	}
554	}
555
556	// 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.
557	if( m_activeNumILRRefIdx > 1 && numResampler > 0 )
558	{
559	for( i=0; i < m_activeNumILRRefIdx; i++ )
560	{
561	assert( refResamplingLayer[i] >= 0 && "Motion and sample inter-layer prediction shall be from the same layer" );
562	}
563	}
564
565	// 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.
566	assert(numResampler <= 1);
567	#if MOTION_RESAMPLING_CONSTRAINT
568	assert( numMotionResamplers <= 1 && "Up to 1 motion resampling is allowed" );
569	#endif
570	}
571	#endif
572	#else
573	if (numInterLayerRPSPics < m_numILRRefIdx)
574	{
575	m_numILRRefIdx = numInterLayerRPSPics;
576	}
577	#endif
578	}
579	#if JCTVC_M0458_INTERLAYER_RPS_SIG
580	Int numPocTotalCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr + m_activeNumILRRefIdx;
581	#else
582	Int numPocTotalCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr + m_numILRRefIdx;
583	#endif
584	#else //SVC_EXTENSION
585	Int numPocTotalCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr;
586	#endif //SVC_EXTENSION
587	#if FIX1071
588	if (checkNumPocTotalCurr)
589	{
590	// 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:
591	#if ILP_RAP // inter-layer prediction is allowed for BLA, CRA pictures of nuh_layer_id>0
592	// – 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.
593	// – Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
594	if (getRapPicFlag() && getLayerId()==0)
595	#else
596	// – If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
597	// – Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
598	if (getRapPicFlag())
599	#endif
600	{
601	assert(numPocTotalCurr == 0);
602	}
603
604	if (m_eSliceType == I_SLICE)
605	{
606	::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
607	::memset( m_aiNumRefIdx, 0, sizeof ( m_aiNumRefIdx ));
608
609	return;
610	}
611
612	assert(numPocTotalCurr > 0);
613
614	m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
615	m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
616	}
617	#endif
618
619	#if M0457_IL_SAMPLE_PRED_ONLY_FLAG
620	if( m_interLayerSamplePredOnlyFlag && getLayerId() )
621	{
622	m_aiNumRefIdx[0] = m_aiNumRefIdx[0] > m_activeNumILRRefIdx ? m_activeNumILRRefIdx : m_aiNumRefIdx[0];
623	m_aiNumRefIdx[1] = m_aiNumRefIdx[1] > m_activeNumILRRefIdx ? m_activeNumILRRefIdx : m_aiNumRefIdx[1];
624	}
625	#endif
626
627	Int cIdx = 0;
628	for ( i=0; i<NumPocStCurr0; i++, cIdx++)
629	{
630	rpsCurrList0[cIdx] = RefPicSetStCurr0[i];
631	}
632	#if SVC_EXTENSION
633	#if RPL_INIT_N0316_N0082
634	if( m_layerId > 0 )
635	{
636	#if JCTVC_M0458_INTERLAYER_RPS_SIG
637	for( i = 0; i < m_activeNumILRRefIdx && cIdx < numPocTotalCurr; cIdx ++, i ++)
638	#else
639	for( i = 0; i < m_numILRRefIdx && cIdx < numPocTotalCurr; cIdx ++, i ++)
640	#endif
641	{
642	Int refLayerIdc = m_interLayerPredLayerIdc[i];
643	#if O0225_MAX_TID_FOR_REF_LAYERS
644	Int maxTidIlRefPicsPlus1 = getVPS()->getMaxTidIlRefPicsPlus1(ilpPic[refLayerIdc]->getSlice(0)->getLayerId(),m_layerId);
645	#else
646	Int maxTidIlRefPicsPlus1 = getVPS()->getMaxTidIlRefPicsPlus1(ilpPic[refLayerIdc]->getSlice(0)->getLayerId());
647	#endif
648	if( ((Int)(ilpPic[refLayerIdc]->getSlice(0)->getTLayer())<=maxTidIlRefPicsPlus1-1) \|\| (maxTidIlRefPicsPlus1==0 && ilpPic[refLayerIdc]->getSlice(0)->getRapPicFlag()) )
649	{
650	rpsCurrList0[cIdx] = ilpPic[refLayerIdc];
651	}
652	}
653	}
654	#endif
655	#endif //SVC_EXTENSION
656	for ( i=0; i<NumPocStCurr1; i++, cIdx++)
657	{
658	rpsCurrList0[cIdx] = RefPicSetStCurr1[i];
659	}
660	for ( i=0; i<NumPocLtCurr; i++, cIdx++)
661	{
662	rpsCurrList0[cIdx] = RefPicSetLtCurr[i];
663	}
664	#if !RPL_INIT_N0316_N0082
665	#if SVC_EXTENSION
666	if( m_layerId > 0 )
667	{
668	#if JCTVC_M0458_INTERLAYER_RPS_SIG
669	for( i = 0; i < m_activeNumILRRefIdx && cIdx < numPocTotalCurr; cIdx ++, i ++)
670	#else
671	for( i = 0; i < m_numILRRefIdx && cIdx < numPocTotalCurr; cIdx ++, i ++)
672	#endif
673	{
674	Int refLayerIdc = m_interLayerPredLayerIdc[i];
675	#if O0225_MAX_TID_FOR_REF_LAYERS
676	Int maxTidIlRefPicsPlus1 = getVPS()->getMaxTidIlRefPicsPlus1(ilpPic[refLayerIdc]->getSlice(0)->getLayerId(),m_layerId);
677	#else
678	Int maxTidIlRefPicsPlus1 = getVPS()->getMaxTidIlRefPicsPlus1(ilpPic[refLayerIdc]->getSlice(0)->getLayerId());
679	#endif
680	if( ((Int)(ilpPic[refLayerIdc]->getSlice(0)->getTLayer())<=maxTidIlRefPicsPlus1-1) \|\| (maxTidIlRefPicsPlus1==0 && ilpPic[refLayerIdc]->getSlice(0)->getRapPicFlag()) )
681	{
682	rpsCurrList0[cIdx] = ilpPic[refLayerIdc];
683	}
684	}
685	}
686	#endif
687	#endif
688	assert(cIdx == numPocTotalCurr);
689
690	if (m_eSliceType==B_SLICE)
691	{
692	cIdx = 0;
693	for ( i=0; i<NumPocStCurr1; i++, cIdx++)
694	{
695	rpsCurrList1[cIdx] = RefPicSetStCurr1[i];
696	}
697	for ( i=0; i<NumPocStCurr0; i++, cIdx++)
698	{
699	rpsCurrList1[cIdx] = RefPicSetStCurr0[i];
700	}
701	for ( i=0; i<NumPocLtCurr; i++, cIdx++)
702	{
703	rpsCurrList1[cIdx] = RefPicSetLtCurr[i];
704	}
705
706	#if SVC_EXTENSION
707	if( m_layerId > 0 )
708	{
709	#if JCTVC_M0458_INTERLAYER_RPS_SIG
710	for( i = 0; i < m_activeNumILRRefIdx && cIdx < numPocTotalCurr; cIdx ++, i ++)
711	#else
712	for( i = 0; i < m_numILRRefIdx && cIdx < numPocTotalCurr; cIdx ++, i ++)
713	#endif
714	{
715	Int refLayerIdc = m_interLayerPredLayerIdc[i];
716	#if O0225_MAX_TID_FOR_REF_LAYERS
717	Int maxTidIlRefPicsPlus1 = getVPS()->getMaxTidIlRefPicsPlus1(ilpPic[refLayerIdc]->getSlice(0)->getLayerId(),m_layerId);
718	#else
719	Int maxTidIlRefPicsPlus1 = getVPS()->getMaxTidIlRefPicsPlus1(ilpPic[refLayerIdc]->getSlice(0)->getLayerId());
720	#endif
721	if( ((Int)(ilpPic[refLayerIdc]->getSlice(0)->getTLayer())<=maxTidIlRefPicsPlus1-1) \|\| (maxTidIlRefPicsPlus1==0 && ilpPic[refLayerIdc]->getSlice(0)->getRapPicFlag()) )
722	{
723	rpsCurrList1[cIdx] = ilpPic[refLayerIdc];
724	}
725	}
726	}
727	#endif //SVC_EXTENSION
728
729	assert(cIdx == numPocTotalCurr);
730	}
731
732	::memset(m_bIsUsedAsLongTerm, 0, sizeof(m_bIsUsedAsLongTerm));
733
734	for (Int rIdx = 0; rIdx < m_aiNumRefIdx[0]; rIdx ++)
735	{
736	cIdx = m_RefPicListModification.getRefPicListModificationFlagL0() ? m_RefPicListModification.getRefPicSetIdxL0(rIdx) : rIdx % numPocTotalCurr;
737	assert(cIdx >= 0 && cIdx < numPocTotalCurr);
738	m_apcRefPicList[0][rIdx] = rpsCurrList0[ cIdx ];
739	#if RPL_INIT_N0316_N0082
740	m_bIsUsedAsLongTerm[0][rIdx] = ( cIdx >= NumPocStCurr0 && cIdx < NumPocStCurr0 + m_activeNumILRRefIdx ) \|\| ( cIdx >= NumPocStCurr0 + NumPocStCurr1 + m_activeNumILRRefIdx );
741	#else
742	m_bIsUsedAsLongTerm[0][rIdx] = ( cIdx >= NumPocStCurr0 + NumPocStCurr1 );
743	#endif
744	}
745	if ( m_eSliceType != B_SLICE )
746	{
747	m_aiNumRefIdx[1] = 0;
748	::memset( m_apcRefPicList[1], 0, sizeof(m_apcRefPicList[1]));
749	}
750	else
751	{
752	for (Int rIdx = 0; rIdx < m_aiNumRefIdx[1]; rIdx ++)
753	{
754	cIdx = m_RefPicListModification.getRefPicListModificationFlagL1() ? m_RefPicListModification.getRefPicSetIdxL1(rIdx) : rIdx % numPocTotalCurr;
755	assert(cIdx >= 0 && cIdx < numPocTotalCurr);
756	m_apcRefPicList[1][rIdx] = rpsCurrList1[ cIdx ];
757	m_bIsUsedAsLongTerm[1][rIdx] = ( cIdx >= NumPocStCurr0 + NumPocStCurr1 );
758	}
759	}
760	}
761
762	#if SVC_EXTENSION
763	Void TComSlice::setRefPicListModificationSvc()
764	{
765	if( !m_pcPPS->getListsModificationPresentFlag())
766	{
767	return;
768	}
769
770	if(m_eNalUnitType >= NAL_UNIT_CODED_SLICE_BLA_W_LP && m_eNalUnitType <= NAL_UNIT_CODED_SLICE_CRA)
771	{
772	return;
773	}
774
775	TComRefPicListModification* refPicListModification = &m_RefPicListModification;
776	Int numberOfRpsCurrTempList = this->getNumRpsCurrTempList(); // total number of ref pics in listTemp0 including inter-layer ref pics
777	#if RPL_INIT_N0316_N0082
778	Int numberOfPocBeforeCurr = this->getNumNegativeRpsCurrTempList(); // number of negative temporal ref pics
779	#endif
780
781	#if N0147_IRAP_ALIGN_FLAG
782	assert(m_aiNumRefIdx[REF_PIC_LIST_0] > 0);
783	assert(m_aiNumRefIdx[REF_PIC_LIST_1] > 0);
784	#else
785	assert(m_aiNumRefIdx[REF_PIC_LIST_0] > 1);
786	assert(m_aiNumRefIdx[REF_PIC_LIST_1] > 1);
787	#endif
788
789	//set L0 inter-layer reference picture modification
790	#if RPL_INIT_N0316_N0082
791	Bool hasModification = (m_aiNumRefIdx[REF_PIC_LIST_0] == (numberOfPocBeforeCurr + m_activeNumILRRefIdx)) ? false : true;
792	#else
793	Bool hasModification = (m_aiNumRefIdx[REF_PIC_LIST_0] == numberOfRpsCurrTempList) ? false : true;
794	#endif
795	#if N0147_IRAP_ALIGN_FLAG
796	hasModification = hasModification && ( m_aiNumRefIdx[REF_PIC_LIST_0] > 1 );
797	#endif
798	refPicListModification->setRefPicListModificationFlagL0(hasModification);
799	if(hasModification)
800	{
801	for(Int i = 0; i < min(m_aiNumRefIdx[REF_PIC_LIST_0], numberOfRpsCurrTempList); i++)
802	{
803	refPicListModification->setRefPicSetIdxL0(i, i);
804	}
805	if(m_aiNumRefIdx[REF_PIC_LIST_0] > numberOfRpsCurrTempList)
806	{
807	// repeat last ref pic when the number of active ref idx are more than RPS entries
808	for (Int i = numberOfRpsCurrTempList; i < m_aiNumRefIdx[REF_PIC_LIST_0]; i ++)
809	{
810	refPicListModification->setRefPicSetIdxL0(i, numberOfRpsCurrTempList - 1);
811	}
812	}
813	else
814	{
815	#if JCTVC_M0458_INTERLAYER_RPS_SIG
816	for(Int i = m_activeNumILRRefIdx; i > 0; i-- )
817	#else
818	for(Int i = m_numILRRefIdx; i > 0; i-- )
819	#endif
820	{
821	#if RPL_INIT_N0316_N0082
822	if((numberOfPocBeforeCurr) >= m_aiNumRefIdx[REF_PIC_LIST_0])
823	{
824	refPicListModification->setRefPicSetIdxL0(m_aiNumRefIdx[REF_PIC_LIST_0] - i, numberOfPocBeforeCurr);
825	}
826	else
827	{
828	refPicListModification->setRefPicSetIdxL0(m_aiNumRefIdx[REF_PIC_LIST_0] - i, numberOfPocBeforeCurr);
829	for (Int j = numberOfPocBeforeCurr; j < (m_aiNumRefIdx[REF_PIC_LIST_0] - i); j++)
830	{
831	refPicListModification->setRefPicSetIdxL0(j, j + m_activeNumILRRefIdx);
832	}
833	}
834	#else
835	refPicListModification->setRefPicSetIdxL0(m_aiNumRefIdx[REF_PIC_LIST_0] - i, numberOfRpsCurrTempList - i);
836	#endif
837	}
838	}
839	}
840
841	//set L1 inter-layer reference picture modification
842	hasModification = (m_aiNumRefIdx[REF_PIC_LIST_1] == numberOfRpsCurrTempList) ? false : true;
843	#if N0147_IRAP_ALIGN_FLAG
844	hasModification = hasModification && ( m_aiNumRefIdx[REF_PIC_LIST_1] > 1 );
845	#endif
846
847	refPicListModification->setRefPicListModificationFlagL1(hasModification);
848	if(hasModification)
849	{
850	for(Int i = 0; i < min(m_aiNumRefIdx[REF_PIC_LIST_1], numberOfRpsCurrTempList); i++)
851	{
852	refPicListModification->setRefPicSetIdxL1(i, i);
853	}
854	if(m_aiNumRefIdx[REF_PIC_LIST_1] > numberOfRpsCurrTempList)
855	{
856	for (Int i = numberOfRpsCurrTempList; i < m_aiNumRefIdx[REF_PIC_LIST_1]; i ++)
857	{
858	// repeat last ref pic when the number of active ref idx are more than RPS entries
859	refPicListModification->setRefPicSetIdxL1(i, numberOfRpsCurrTempList - 1);
860	}
861	}
862	else
863	{
864	#if JCTVC_M0458_INTERLAYER_RPS_SIG
865	for(Int i = m_activeNumILRRefIdx; i > 0; i-- )
866	#else
867	for(Int i = m_numILRRefIdx; i > 0; i-- )
868	#endif
869	{
870	refPicListModification->setRefPicSetIdxL1(m_aiNumRefIdx[REF_PIC_LIST_1] - i, numberOfRpsCurrTempList - i);
871	}
872	}
873	}
874	return;
875	}
876	#endif
877	#if RPL_INIT_N0316_N0082
878	Int TComSlice::getNumNegativeRpsCurrTempList()
879	{
880	if( m_eSliceType == I_SLICE )
881	{
882	return 0;
883	}
884
885	Int numPocBeforeCurr = 0;
886	for( UInt i = 0; i < m_pcRPS->getNumberOfNegativePictures(); i++ )
887	{
888	if(m_pcRPS->getUsed(i))
889	{
890	numPocBeforeCurr++;
891	}
892	}
893
894	return numPocBeforeCurr;
895	}
896	#endif
897	Int TComSlice::getNumRpsCurrTempList()
898	{
899	Int numRpsCurrTempList = 0;
900
901	#if SVC_EXTENSION
902	if( m_eSliceType == I_SLICE \|\| ( m_pcSPS->getLayerId() &&
903	(m_eNalUnitType >= NAL_UNIT_CODED_SLICE_BLA_W_LP) &&
904	(m_eNalUnitType <= NAL_UNIT_CODED_SLICE_CRA) ) )
905	#else
906	if (m_eSliceType == I_SLICE)
907	#endif
908	{
909	#if SVC_EXTENSION
910	#if JCTVC_M0458_INTERLAYER_RPS_SIG
911	return m_activeNumILRRefIdx;
912	#else
913	return getNumILRRefIdx();
914	#endif
915	#else
916	return 0;
917	#endif
918	}
919	for(UInt i=0; i < m_pcRPS->getNumberOfNegativePictures()+ m_pcRPS->getNumberOfPositivePictures() + m_pcRPS->getNumberOfLongtermPictures(); i++)
920	{
921	if(m_pcRPS->getUsed(i))
922	{
923	numRpsCurrTempList++;
924	}
925	}
926	#if SVC_EXTENSION
927	if( m_layerId > 0 )
928	{
929	#if JCTVC_M0458_INTERLAYER_RPS_SIG
930	numRpsCurrTempList += m_activeNumILRRefIdx;
931	#else
932	numRpsCurrTempList += getNumILRRefIdx();
933	#endif
934	}
935	#endif
936
937	return numRpsCurrTempList;
938	}
939
940	Void TComSlice::initEqualRef()
941	{
942	for (Int iDir = 0; iDir < 2; iDir++)
943	{
944	for (Int iRefIdx1 = 0; iRefIdx1 < MAX_NUM_REF; iRefIdx1++)
945	{
946	for (Int iRefIdx2 = iRefIdx1; iRefIdx2 < MAX_NUM_REF; iRefIdx2++)
947	{
948	m_abEqualRef[iDir][iRefIdx1][iRefIdx2] = m_abEqualRef[iDir][iRefIdx2][iRefIdx1] = (iRefIdx1 == iRefIdx2? true : false);
949	}
950	}
951	}
952	}
953
954	Void TComSlice::checkColRefIdx(UInt curSliceIdx, TComPic* pic)
955	{
956	Int i;
957	TComSlice* curSlice = pic->getSlice(curSliceIdx);
958	Int currColRefPOC = curSlice->getRefPOC( RefPicList(1-curSlice->getColFromL0Flag()), curSlice->getColRefIdx());
959	TComSlice* preSlice;
960	Int preColRefPOC;
961	for(i=curSliceIdx-1; i>=0; i--)
962	{
963	preSlice = pic->getSlice(i);
964	if(preSlice->getSliceType() != I_SLICE)
965	{
966	preColRefPOC = preSlice->getRefPOC( RefPicList(1-preSlice->getColFromL0Flag()), preSlice->getColRefIdx());
967	if(currColRefPOC != preColRefPOC)
968	{
969	printf("Collocated_ref_idx shall always be the same for all slices of a coded picture!\n");
970	exit(EXIT_FAILURE);
971	}
972	else
973	{
974	break;
975	}
976	}
977	}
978	}
979
980	Void TComSlice::checkCRA(TComReferencePictureSet pReferencePictureSet, Int& pocCRA, NalUnitType& associatedIRAPType, TComList<TComPic >& rcListPic)
981	{
982	for(Int i = 0; i < pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures(); i++)
983	{
984	if(pocCRA < MAX_UINT && getPOC() > pocCRA)
985	{
986	assert(getPOC()+pReferencePictureSet->getDeltaPOC(i) >= pocCRA);
987	}
988	}
989	for(Int i = pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures(); i < pReferencePictureSet->getNumberOfPictures(); i++)
990	{
991	if(pocCRA < MAX_UINT && getPOC() > pocCRA)
992	{
993	if (!pReferencePictureSet->getCheckLTMSBPresent(i))
994	{
995	assert(xGetLongTermRefPic(rcListPic, pReferencePictureSet->getPOC(i), false)->getPOC() >= pocCRA);
996	}
997	else
998	{
999	assert(pReferencePictureSet->getPOC(i) >= pocCRA);
1000	}
1001	}
1002	}
1003	if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL \|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ) // IDR picture found
1004	{
1005	pocCRA = getPOC();
1006	associatedIRAPType = getNalUnitType();
1007	}
1008	else if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA ) // CRA picture found
1009	{
1010	pocCRA = getPOC();
1011	associatedIRAPType = getNalUnitType();
1012	}
1013	else if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
1014	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
1015	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP ) // BLA picture found
1016	{
1017	pocCRA = getPOC();
1018	associatedIRAPType = getNalUnitType();
1019	}
1020	}
1021
1022	/** Function for marking the reference pictures when an IDR/CRA/CRANT/BLA/BLANT is encountered.
1023	* \param pocCRA POC of the CRA/CRANT/BLA/BLANT picture
1024	* \param bRefreshPending flag indicating if a deferred decoding refresh is pending
1025	* \param rcListPic reference to the reference picture list
1026	* This function marks the reference pictures as "unused for reference" in the following conditions.
1027	* If the nal_unit_type is IDR/BLA/BLANT, all pictures in the reference picture list
1028	* are marked as "unused for reference"
1029	* If the nal_unit_type is BLA/BLANT, set the pocCRA to the temporal reference of the current picture.
1030	* Otherwise
1031	* If the bRefreshPending flag is true (a deferred decoding refresh is pending) and the current
1032	* temporal reference is greater than the temporal reference of the latest CRA/CRANT/BLA/BLANT picture (pocCRA),
1033	* mark all reference pictures except the latest CRA/CRANT/BLA/BLANT picture as "unused for reference" and set
1034	* the bRefreshPending flag to false.
1035	* If the nal_unit_type is CRA/CRANT, set the bRefreshPending flag to true and pocCRA to the temporal
1036	* reference of the current picture.
1037	* Note that the current picture is already placed in the reference list and its marking is not changed.
1038	* If the current picture has a nal_ref_idc that is not 0, it will remain marked as "used for reference".
1039	*/
1040	Void TComSlice::decodingRefreshMarking(Int& pocCRA, Bool& bRefreshPending, TComList<TComPic*>& rcListPic)
1041	{
1042	TComPic* rpcPic;
1043	setAssociatedIRAPPOC(pocCRA);
1044	Int pocCurr = getPOC();
1045
1046	if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
1047	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
1048	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
1049	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
1050	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ) // IDR or BLA picture
1051	{
1052	// mark all pictures as not used for reference
1053	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1054	while (iterPic != rcListPic.end())
1055	{
1056	rpcPic = *(iterPic);
1057	rpcPic->setCurrSliceIdx(0);
1058	if (rpcPic->getPOC() != pocCurr) rpcPic->getSlice(0)->setReferenced(false);
1059	iterPic++;
1060	}
1061	if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
1062	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
1063	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
1064	{
1065	pocCRA = pocCurr;
1066	}
1067	}
1068	else // CRA or No DR
1069	{
1070	if (bRefreshPending==true && pocCurr > pocCRA) // CRA reference marking pending
1071	{
1072	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1073	while (iterPic != rcListPic.end())
1074	{
1075	rpcPic = *(iterPic);
1076	if (rpcPic->getPOC() != pocCurr && rpcPic->getPOC() != pocCRA)
1077	{
1078	rpcPic->getSlice(0)->setReferenced(false);
1079	}
1080	iterPic++;
1081	}
1082	bRefreshPending = false;
1083	}
1084	if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA ) // CRA picture found
1085	{
1086	bRefreshPending = true;
1087	pocCRA = pocCurr;
1088	}
1089	}
1090	}
1091
1092	Void TComSlice::copySliceInfo(TComSlice *pSrc)
1093	{
1094	assert( pSrc != NULL );
1095
1096	Int i, j, k;
1097
1098	m_iPOC = pSrc->m_iPOC;
1099	m_eNalUnitType = pSrc->m_eNalUnitType;
1100	m_eSliceType = pSrc->m_eSliceType;
1101	m_iSliceQp = pSrc->m_iSliceQp;
1102	#if ADAPTIVE_QP_SELECTION
1103	m_iSliceQpBase = pSrc->m_iSliceQpBase;
1104	#endif
1105	m_deblockingFilterDisable = pSrc->m_deblockingFilterDisable;
1106	m_deblockingFilterOverrideFlag = pSrc->m_deblockingFilterOverrideFlag;
1107	m_deblockingFilterBetaOffsetDiv2 = pSrc->m_deblockingFilterBetaOffsetDiv2;
1108	m_deblockingFilterTcOffsetDiv2 = pSrc->m_deblockingFilterTcOffsetDiv2;
1109
1110	for (i = 0; i < 2; i++)
1111	{
1112	m_aiNumRefIdx[i] = pSrc->m_aiNumRefIdx[i];
1113	}
1114
1115	for (i = 0; i < MAX_NUM_REF; i++)
1116	{
1117	m_list1IdxToList0Idx[i] = pSrc->m_list1IdxToList0Idx[i];
1118	}
1119	m_bCheckLDC = pSrc->m_bCheckLDC;
1120	m_iSliceQpDelta = pSrc->m_iSliceQpDelta;
1121	m_iSliceQpDeltaCb = pSrc->m_iSliceQpDeltaCb;
1122	m_iSliceQpDeltaCr = pSrc->m_iSliceQpDeltaCr;
1123	for (i = 0; i < 2; i++)
1124	{
1125	for (j = 0; j < MAX_NUM_REF; j++)
1126	{
1127	m_apcRefPicList[i][j] = pSrc->m_apcRefPicList[i][j];
1128	m_aiRefPOCList[i][j] = pSrc->m_aiRefPOCList[i][j];
1129	}
1130	}
1131	for (i = 0; i < 2; i++)
1132	{
1133	for (j = 0; j < MAX_NUM_REF + 1; j++)
1134	{
1135	m_bIsUsedAsLongTerm[i][j] = pSrc->m_bIsUsedAsLongTerm[i][j];
1136	}
1137	}
1138	m_iDepth = pSrc->m_iDepth;
1139
1140	// referenced slice
1141	m_bRefenced = pSrc->m_bRefenced;
1142
1143	// access channel
1144	#if SVC_EXTENSION
1145	m_pcVPS = pSrc->m_pcVPS;
1146	m_layerId = pSrc->m_layerId;
1147	#if JCTVC_M0458_INTERLAYER_RPS_SIG
1148	m_activeNumILRRefIdx = pSrc->m_activeNumILRRefIdx;
1149	m_interLayerPredEnabledFlag = pSrc->m_interLayerPredEnabledFlag;
1150	memcpy( m_interLayerPredLayerIdc, pSrc->m_interLayerPredLayerIdc, sizeof( m_interLayerPredLayerIdc ) );
1151	#endif
1152	#endif
1153	m_pcSPS = pSrc->m_pcSPS;
1154	m_pcPPS = pSrc->m_pcPPS;
1155	m_pcRPS = pSrc->m_pcRPS;
1156	m_iLastIDR = pSrc->m_iLastIDR;
1157
1158	m_pcPic = pSrc->m_pcPic;
1159
1160	m_colFromL0Flag = pSrc->m_colFromL0Flag;
1161	m_colRefIdx = pSrc->m_colRefIdx;
1162	#if SAO_CHROMA_LAMBDA
1163	m_dLambdaLuma = pSrc->m_dLambdaLuma;
1164	m_dLambdaChroma = pSrc->m_dLambdaChroma;
1165	#else
1166	m_dLambda = pSrc->m_dLambda;
1167	#endif
1168	for (i = 0; i < 2; i++)
1169	{
1170	for (j = 0; j < MAX_NUM_REF; j++)
1171	{
1172	for (k =0; k < MAX_NUM_REF; k++)
1173	{
1174	m_abEqualRef[i][j][k] = pSrc->m_abEqualRef[i][j][k];
1175	}
1176	}
1177	}
1178
1179	m_uiTLayer = pSrc->m_uiTLayer;
1180	m_bTLayerSwitchingFlag = pSrc->m_bTLayerSwitchingFlag;
1181
1182	m_sliceMode = pSrc->m_sliceMode;
1183	m_sliceArgument = pSrc->m_sliceArgument;
1184	m_sliceCurStartCUAddr = pSrc->m_sliceCurStartCUAddr;
1185	m_sliceCurEndCUAddr = pSrc->m_sliceCurEndCUAddr;
1186	m_sliceIdx = pSrc->m_sliceIdx;
1187	m_sliceSegmentMode = pSrc->m_sliceSegmentMode;
1188	m_sliceSegmentArgument = pSrc->m_sliceSegmentArgument;
1189	m_sliceSegmentCurStartCUAddr = pSrc->m_sliceSegmentCurStartCUAddr;
1190	m_sliceSegmentCurEndCUAddr = pSrc->m_sliceSegmentCurEndCUAddr;
1191	m_nextSlice = pSrc->m_nextSlice;
1192	m_nextSliceSegment = pSrc->m_nextSliceSegment;
1193	for ( Int e=0 ; e<2 ; e++ )
1194	{
1195	for ( Int n=0 ; n<MAX_NUM_REF ; n++ )
1196	{
1197	memcpy(m_weightPredTable[e][n], pSrc->m_weightPredTable[e][n], sizeof(wpScalingParam)*3 );
1198	}
1199	}
1200	m_saoEnabledFlag = pSrc->m_saoEnabledFlag;
1201	m_saoEnabledFlagChroma = pSrc->m_saoEnabledFlagChroma;
1202	m_cabacInitFlag = pSrc->m_cabacInitFlag;
1203	m_numEntryPointOffsets = pSrc->m_numEntryPointOffsets;
1204
1205	m_bLMvdL1Zero = pSrc->m_bLMvdL1Zero;
1206	m_LFCrossSliceBoundaryFlag = pSrc->m_LFCrossSliceBoundaryFlag;
1207	m_enableTMVPFlag = pSrc->m_enableTMVPFlag;
1208	m_maxNumMergeCand = pSrc->m_maxNumMergeCand;
1209	}
1210
1211	Int TComSlice::m_prevTid0POC = 0;
1212
1213	/** Function for setting the slice's temporal layer ID and corresponding temporal_layer_switching_point_flag.
1214	* \param uiTLayer Temporal layer ID of the current slice
1215	* The decoder calls this function to set temporal_layer_switching_point_flag for each temporal layer based on
1216	* the SPS's temporal_id_nesting_flag and the parsed PPS. Then, current slice's temporal layer ID and
1217	* temporal_layer_switching_point_flag is set accordingly.
1218	*/
1219	Void TComSlice::setTLayerInfo( UInt uiTLayer )
1220	{
1221	m_uiTLayer = uiTLayer;
1222	}
1223
1224	/** Function for checking if this is a switching-point
1225	*/
1226	Bool TComSlice::isTemporalLayerSwitchingPoint( TComList<TComPic*>& rcListPic )
1227	{
1228	TComPic* rpcPic;
1229	// loop through all pictures in the reference picture buffer
1230	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1231	while ( iterPic != rcListPic.end())
1232	{
1233	rpcPic = *(iterPic++);
1234	if(rpcPic->getSlice(0)->isReferenced() && rpcPic->getPOC() != getPOC())
1235	{
1236	if(rpcPic->getTLayer() >= getTLayer())
1237	{
1238	return false;
1239	}
1240	}
1241	}
1242	return true;
1243	}
1244
1245	/** Function for checking if this is a STSA candidate
1246	*/
1247	Bool TComSlice::isStepwiseTemporalLayerSwitchingPointCandidate( TComList<TComPic*>& rcListPic )
1248	{
1249	TComPic* rpcPic;
1250
1251	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1252	while ( iterPic != rcListPic.end())
1253	{
1254	rpcPic = *(iterPic++);
1255	if(rpcPic->getSlice(0)->isReferenced() && (rpcPic->getUsedByCurr()==true) && rpcPic->getPOC() != getPOC())
1256	{
1257	if(rpcPic->getTLayer() >= getTLayer())
1258	{
1259	return false;
1260	}
1261	}
1262	}
1263	return true;
1264	}
1265
1266
1267	Void TComSlice::checkLeadingPictureRestrictions(TComList<TComPic*>& rcListPic)
1268	{
1269	TComPic* rpcPic;
1270
1271	Int nalUnitType = this->getNalUnitType();
1272
1273	// When a picture is a leading picture, it shall be a RADL or RASL picture.
1274	if(this->getAssociatedIRAPPOC() > this->getPOC())
1275	{
1276	// Do not check IRAP pictures since they may get a POC lower than their associated IRAP
1277	if(nalUnitType < NAL_UNIT_CODED_SLICE_BLA_W_LP \|\|
1278	nalUnitType > NAL_UNIT_RESERVED_IRAP_VCL23)
1279	{
1280	assert(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N \|\|
1281	nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R \|\|
1282	nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N \|\|
1283	nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R);
1284	}
1285	}
1286
1287	// When a picture is a trailing picture, it shall not be a RADL or RASL picture.
1288	if(this->getAssociatedIRAPPOC() < this->getPOC())
1289	{
1290	assert(nalUnitType != NAL_UNIT_CODED_SLICE_RASL_N &&
1291	nalUnitType != NAL_UNIT_CODED_SLICE_RASL_R &&
1292	nalUnitType != NAL_UNIT_CODED_SLICE_RADL_N &&
1293	nalUnitType != NAL_UNIT_CODED_SLICE_RADL_R);
1294	}
1295
1296	// No RASL pictures shall be present in the bitstream that are associated
1297	// with a BLA picture having nal_unit_type equal to BLA_W_RADL or BLA_N_LP.
1298	if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N \|\|
1299	nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1300	{
1301	assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_W_RADL &&
1302	this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_N_LP);
1303	}
1304
1305	// No RASL pictures shall be present in the bitstream that are associated with
1306	// an IDR picture.
1307	if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N \|\|
1308	nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1309	{
1310	assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_N_LP &&
1311	this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_W_RADL);
1312	}
1313
1314	// No RADL pictures shall be present in the bitstream that are associated with
1315	// a BLA picture having nal_unit_type equal to BLA_N_LP or that are associated
1316	// with an IDR picture having nal_unit_type equal to IDR_N_LP.
1317	if(nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N \|\|
1318	nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R)
1319	{
1320	assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_N_LP &&
1321	this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_N_LP);
1322	}
1323
1324	// loop through all pictures in the reference picture buffer
1325	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1326	while ( iterPic != rcListPic.end())
1327	{
1328	rpcPic = *(iterPic++);
1329	if (rpcPic->getPOC() == this->getPOC())
1330	{
1331	continue;
1332	}
1333
1334	// Any picture that has PicOutputFlag equal to 1 that precedes an IRAP picture
1335	// in decoding order shall precede the IRAP picture in output order.
1336	// (Note that any picture following in output order would be present in the DPB)
1337	if(rpcPic->getSlice(0)->getPicOutputFlag() == 1)
1338	{
1339	if(nalUnitType == NAL_UNIT_CODED_SLICE_BLA_N_LP \|\|
1340	nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_LP \|\|
1341	nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_RADL \|\|
1342	nalUnitType == NAL_UNIT_CODED_SLICE_CRA \|\|
1343	nalUnitType == NAL_UNIT_CODED_SLICE_IDR_N_LP \|\|
1344	nalUnitType == NAL_UNIT_CODED_SLICE_IDR_W_RADL)
1345	{
1346	assert(rpcPic->getPOC() < this->getPOC());
1347	}
1348	}
1349
1350	// Any picture that has PicOutputFlag equal to 1 that precedes an IRAP picture
1351	// in decoding order shall precede any RADL picture associated with the IRAP
1352	// picture in output order.
1353	if(rpcPic->getSlice(0)->getPicOutputFlag() == 1)
1354	{
1355	if((nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N \|\|
1356	nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R))
1357	{
1358	// rpcPic precedes the IRAP in decoding order
1359	if(this->getAssociatedIRAPPOC() > rpcPic->getSlice(0)->getAssociatedIRAPPOC())
1360	{
1361	// rpcPic must not be the IRAP picture
1362	if(this->getAssociatedIRAPPOC() != rpcPic->getPOC())
1363	{
1364	assert(rpcPic->getPOC() < this->getPOC());
1365	}
1366	}
1367	}
1368	}
1369
1370	// When a picture is a leading picture, it shall precede, in decoding order,
1371	// all trailing pictures that are associated with the same IRAP picture.
1372	if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N \|\|
1373	nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R \|\|
1374	nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N \|\|
1375	nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R)
1376	{
1377	if(rpcPic->getSlice(0)->getAssociatedIRAPPOC() == this->getAssociatedIRAPPOC())
1378	{
1379	// rpcPic is a picture that preceded the leading in decoding order since it exist in the DPB
1380	// rpcPic would violate the constraint if it was a trailing picture
1381	assert(rpcPic->getPOC() <= this->getAssociatedIRAPPOC());
1382	}
1383	}
1384
1385	// Any RASL picture associated with a CRA or BLA picture shall precede any
1386	// RADL picture associated with the CRA or BLA picture in output order
1387	if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N \|\|
1388	nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1389	{
1390	if((this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_N_LP \|\|
1391	this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_W_LP \|\|
1392	this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL \|\|
1393	this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_CRA) &&
1394	this->getAssociatedIRAPPOC() == rpcPic->getSlice(0)->getAssociatedIRAPPOC())
1395	{
1396	if(rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N \|\|
1397	rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_R)
1398	{
1399	assert(rpcPic->getPOC() > this->getPOC());
1400	}
1401	}
1402	}
1403
1404	// Any RASL picture associated with a CRA picture shall follow, in output
1405	// order, any IRAP picture that precedes the CRA picture in decoding order.
1406	if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N \|\|
1407	nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1408	{
1409	if(this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_CRA)
1410	{
1411	if(rpcPic->getSlice(0)->getPOC() < this->getAssociatedIRAPPOC() &&
1412	(rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP \|\|
1413	rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP \|\|
1414	rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL \|\|
1415	rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP \|\|
1416	rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL \|\|
1417	rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA))
1418	{
1419	assert(this->getPOC() > rpcPic->getSlice(0)->getPOC());
1420	}
1421	}
1422	}
1423	}
1424	}
1425
1426	/** Function for applying picture marking based on the Reference Picture Set in pReferencePictureSet.
1427	*/
1428	Void TComSlice::applyReferencePictureSet( TComList<TComPic>& rcListPic, TComReferencePictureSet pReferencePictureSet)
1429	{
1430	TComPic* rpcPic;
1431	Int i, isReference;
1432
1433	checkLeadingPictureRestrictions(rcListPic);
1434
1435	// loop through all pictures in the reference picture buffer
1436	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1437	while ( iterPic != rcListPic.end())
1438	{
1439	rpcPic = *(iterPic++);
1440
1441	if(!rpcPic->getSlice( 0 )->isReferenced())
1442	{
1443	continue;
1444	}
1445
1446	isReference = 0;
1447	// loop through all pictures in the Reference Picture Set
1448	// to see if the picture should be kept as reference picture
1449	for(i=0;i<pReferencePictureSet->getNumberOfPositivePictures()+pReferencePictureSet->getNumberOfNegativePictures();i++)
1450	{
1451	if(!rpcPic->getIsLongTerm() && rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i))
1452	{
1453	isReference = 1;
1454	rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1455	rpcPic->setIsLongTerm(0);
1456	}
1457	}
1458	for(;i<pReferencePictureSet->getNumberOfPictures();i++)
1459	{
1460	if(pReferencePictureSet->getCheckLTMSBPresent(i)==true)
1461	{
1462	if(rpcPic->getIsLongTerm() && (rpcPic->getPicSym()->getSlice(0)->getPOC()) == pReferencePictureSet->getPOC(i))
1463	{
1464	isReference = 1;
1465	rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1466	}
1467	}
1468	else
1469	{
1470	Int pocCycle = 1<<rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
1471	Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC() & (pocCycle-1);
1472	Int refPoc = pReferencePictureSet->getPOC(i) & (pocCycle-1);
1473	if(rpcPic->getIsLongTerm() && curPoc == refPoc)
1474	{
1475	isReference = 1;
1476	rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1477	}
1478	}
1479
1480	}
1481	// mark the picture as "unused for reference" if it is not in
1482	// the Reference Picture Set
1483	if(rpcPic->getPicSym()->getSlice(0)->getPOC() != this->getPOC() && isReference == 0)
1484	{
1485	rpcPic->getSlice( 0 )->setReferenced( false );
1486	rpcPic->setUsedByCurr(0);
1487	rpcPic->setIsLongTerm(0);
1488	}
1489	//check that pictures of higher temporal layers are not used
1490	assert(rpcPic->getSlice( 0 )->isReferenced()==0\|\|rpcPic->getUsedByCurr()==0\|\|rpcPic->getTLayer()<=this->getTLayer());
1491	//check that pictures of higher or equal temporal layer are not in the RPS if the current picture is a TSA picture
1492	if(this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TLA_R \|\| this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N)
1493	{
1494	assert(rpcPic->getSlice( 0 )->isReferenced()==0\|\|rpcPic->getTLayer()<this->getTLayer());
1495	}
1496	//check that pictures marked as temporal layer non-reference pictures are not used for reference
1497	if(rpcPic->getPicSym()->getSlice(0)->getPOC() != this->getPOC() && rpcPic->getTLayer()==this->getTLayer())
1498	{
1499	assert(rpcPic->getSlice( 0 )->isReferenced()==0\|\|rpcPic->getUsedByCurr()==0\|\|rpcPic->getSlice( 0 )->getTemporalLayerNonReferenceFlag()==false);
1500	}
1501	}
1502	}
1503
1504	/** Function for applying picture marking based on the Reference Picture Set in pReferencePictureSet.
1505	*/
1506	Int TComSlice::checkThatAllRefPicsAreAvailable( TComList<TComPic>& rcListPic, TComReferencePictureSet pReferencePictureSet, Bool printErrors, Int pocRandomAccess)
1507	{
1508	TComPic* rpcPic;
1509	Int i, isAvailable;
1510	Int atLeastOneLost = 0;
1511	Int atLeastOneRemoved = 0;
1512	Int iPocLost = 0;
1513
1514	// loop through all long-term pictures in the Reference Picture Set
1515	// to see if the picture should be kept as reference picture
1516	for(i=pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();i<pReferencePictureSet->getNumberOfPictures();i++)
1517	{
1518	isAvailable = 0;
1519	// loop through all pictures in the reference picture buffer
1520	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1521	while ( iterPic != rcListPic.end())
1522	{
1523	rpcPic = *(iterPic++);
1524	if(pReferencePictureSet->getCheckLTMSBPresent(i)==true)
1525	{
1526	if(rpcPic->getIsLongTerm() && (rpcPic->getPicSym()->getSlice(0)->getPOC()) == pReferencePictureSet->getPOC(i) && rpcPic->getSlice(0)->isReferenced())
1527	{
1528	isAvailable = 1;
1529	}
1530	}
1531	else
1532	{
1533	Int pocCycle = 1<<rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
1534	Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC() & (pocCycle-1);
1535	Int refPoc = pReferencePictureSet->getPOC(i) & (pocCycle-1);
1536	if(rpcPic->getIsLongTerm() && curPoc == refPoc && rpcPic->getSlice(0)->isReferenced())
1537	{
1538	isAvailable = 1;
1539	}
1540	}
1541	}
1542	// if there was no such long-term check the short terms
1543	if(!isAvailable)
1544	{
1545	iterPic = rcListPic.begin();
1546	while ( iterPic != rcListPic.end())
1547	{
1548	rpcPic = *(iterPic++);
1549
1550	Int pocCycle = 1 << rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
1551	Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC();
1552	Int refPoc = pReferencePictureSet->getPOC(i);
1553	if (!pReferencePictureSet->getCheckLTMSBPresent(i))
1554	{
1555	curPoc = curPoc & (pocCycle - 1);
1556	refPoc = refPoc & (pocCycle - 1);
1557	}
1558
1559	if (rpcPic->getSlice(0)->isReferenced() && curPoc == refPoc)
1560	{
1561	isAvailable = 1;
1562	rpcPic->setIsLongTerm(1);
1563	break;
1564	}
1565	}
1566	}
1567	// report that a picture is lost if it is in the Reference Picture Set
1568	// but not available as reference picture
1569	if(isAvailable == 0)
1570	{
1571	if (this->getPOC() + pReferencePictureSet->getDeltaPOC(i) >= pocRandomAccess)
1572	{
1573	if(!pReferencePictureSet->getUsed(i) )
1574	{
1575	if(printErrors)
1576	{
1577	printf("\nLong-term reference picture with POC = %3d seems to have been removed or not correctly decoded.", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1578	}
1579	atLeastOneRemoved = 1;
1580	}
1581	else
1582	{
1583	if(printErrors)
1584	{
1585	printf("\nLong-term reference picture with POC = %3d is lost or not correctly decoded!", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1586	}
1587	atLeastOneLost = 1;
1588	iPocLost=this->getPOC() + pReferencePictureSet->getDeltaPOC(i);
1589	}
1590	}
1591	}
1592	}
1593	// loop through all short-term pictures in the Reference Picture Set
1594	// to see if the picture should be kept as reference picture
1595	for(i=0;i<pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();i++)
1596	{
1597	isAvailable = 0;
1598	// loop through all pictures in the reference picture buffer
1599	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1600	while ( iterPic != rcListPic.end())
1601	{
1602	rpcPic = *(iterPic++);
1603
1604	if(!rpcPic->getIsLongTerm() && rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i) && rpcPic->getSlice(0)->isReferenced())
1605	{
1606	isAvailable = 1;
1607	}
1608	}
1609	// report that a picture is lost if it is in the Reference Picture Set
1610	// but not available as reference picture
1611	if(isAvailable == 0)
1612	{
1613	if (this->getPOC() + pReferencePictureSet->getDeltaPOC(i) >= pocRandomAccess)
1614	{
1615	if(!pReferencePictureSet->getUsed(i) )
1616	{
1617	if(printErrors)
1618	{
1619	printf("\nShort-term reference picture with POC = %3d seems to have been removed or not correctly decoded.", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1620	}
1621	atLeastOneRemoved = 1;
1622	}
1623	else
1624	{
1625	if(printErrors)
1626	{
1627	printf("\nShort-term reference picture with POC = %3d is lost or not correctly decoded!", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1628	}
1629	atLeastOneLost = 1;
1630	iPocLost=this->getPOC() + pReferencePictureSet->getDeltaPOC(i);
1631	}
1632	}
1633	}
1634	}
1635	if(atLeastOneLost)
1636	{
1637	return iPocLost+1;
1638	}
1639	if(atLeastOneRemoved)
1640	{
1641	return -2;
1642	}
1643	else
1644	{
1645	return 0;
1646	}
1647	}
1648
1649	/** Function for constructing an explicit Reference Picture Set out of the available pictures in a referenced Reference Picture Set
1650	*/
1651	#if FIX1071
1652	Void TComSlice::createExplicitReferencePictureSetFromReference( TComList<TComPic>& rcListPic, TComReferencePictureSet pReferencePictureSet, Bool isRAP)
1653	#else
1654	Void TComSlice::createExplicitReferencePictureSetFromReference( TComList<TComPic>& rcListPic, TComReferencePictureSet pReferencePictureSet)
1655	#endif
1656	{
1657	TComPic* rpcPic;
1658	Int i, j;
1659	Int k = 0;
1660	Int nrOfNegativePictures = 0;
1661	Int nrOfPositivePictures = 0;
1662	TComReferencePictureSet* pcRPS = this->getLocalRPS();
1663
1664	// loop through all pictures in the Reference Picture Set
1665	for(i=0;i<pReferencePictureSet->getNumberOfPictures();i++)
1666	{
1667	j = 0;
1668	// loop through all pictures in the reference picture buffer
1669	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1670	while ( iterPic != rcListPic.end())
1671	{
1672	j++;
1673	rpcPic = *(iterPic++);
1674
1675	if(rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i) && rpcPic->getSlice(0)->isReferenced())
1676	{
1677	// This picture exists as a reference picture
1678	// and should be added to the explicit Reference Picture Set
1679	pcRPS->setDeltaPOC(k, pReferencePictureSet->getDeltaPOC(i));
1680	#if FIX1071
1681	pcRPS->setUsed(k, pReferencePictureSet->getUsed(i) && (!isRAP));
1682	#else
1683	pcRPS->setUsed(k, pReferencePictureSet->getUsed(i));
1684	#endif
1685	if(pcRPS->getDeltaPOC(k) < 0)
1686	{
1687	nrOfNegativePictures++;
1688	}
1689	else
1690	{
1691	nrOfPositivePictures++;
1692	}
1693	k++;
1694	}
1695	}
1696	}
1697	pcRPS->setNumberOfNegativePictures(nrOfNegativePictures);
1698	pcRPS->setNumberOfPositivePictures(nrOfPositivePictures);
1699	pcRPS->setNumberOfPictures(nrOfNegativePictures+nrOfPositivePictures);
1700	// This is a simplistic inter rps example. A smarter encoder will look for a better reference RPS to do the
1701	// inter RPS prediction with. Here we just use the reference used by pReferencePictureSet.
1702	// If pReferencePictureSet is not inter_RPS_predicted, then inter_RPS_prediction is for the current RPS also disabled.
1703	if (!pReferencePictureSet->getInterRPSPrediction())
1704	{
1705	pcRPS->setInterRPSPrediction(false);
1706	pcRPS->setNumRefIdc(0);
1707	}
1708	else
1709	{
1710	Int rIdx = this->getRPSidx() - pReferencePictureSet->getDeltaRIdxMinus1() - 1;
1711	Int deltaRPS = pReferencePictureSet->getDeltaRPS();
1712	TComReferencePictureSet* pcRefRPS = this->getSPS()->getRPSList()->getReferencePictureSet(rIdx);
1713	Int iRefPics = pcRefRPS->getNumberOfPictures();
1714	Int iNewIdc=0;
1715	for(i=0; i<= iRefPics; i++)
1716	{
1717	Int deltaPOC = ((i != iRefPics)? pcRefRPS->getDeltaPOC(i) : 0); // check if the reference abs POC is >= 0
1718	Int iRefIdc = 0;
1719	for (j=0; j < pcRPS->getNumberOfPictures(); j++) // loop through the pictures in the new RPS
1720	{
1721	if ( (deltaPOC + deltaRPS) == pcRPS->getDeltaPOC(j))
1722	{
1723	if (pcRPS->getUsed(j))
1724	{
1725	iRefIdc = 1;
1726	}
1727	else
1728	{
1729	iRefIdc = 2;
1730	}
1731	}
1732	}
1733	pcRPS->setRefIdc(i, iRefIdc);
1734	iNewIdc++;
1735	}
1736	pcRPS->setInterRPSPrediction(true);
1737	pcRPS->setNumRefIdc(iNewIdc);
1738	pcRPS->setDeltaRPS(deltaRPS);
1739	pcRPS->setDeltaRIdxMinus1(pReferencePictureSet->getDeltaRIdxMinus1() + this->getSPS()->getRPSList()->getNumberOfReferencePictureSets() - this->getRPSidx());
1740	}
1741
1742	this->setRPS(pcRPS);
1743	this->setRPSidx(-1);
1744	}
1745
1746	/** get AC and DC values for weighted pred
1747	* \param *wp
1748	* \returns Void
1749	*/
1750	Void TComSlice::getWpAcDcParam(wpACDCParam *&wp)
1751	{
1752	wp = m_weightACDCParam;
1753	}
1754
1755	/** init AC and DC values for weighted pred
1756	* \returns Void
1757	*/
1758	Void TComSlice::initWpAcDcParam()
1759	{
1760	for(Int iComp = 0; iComp < 3; iComp++ )
1761	{
1762	m_weightACDCParam[iComp].iAC = 0;
1763	m_weightACDCParam[iComp].iDC = 0;
1764	}
1765	}
1766
1767	/** get WP tables for weighted pred
1768	* \param RefPicList
1769	* \param iRefIdx
1770	* \param *&wpScalingParam
1771	* \returns Void
1772	*/
1773	Void TComSlice::getWpScaling( RefPicList e, Int iRefIdx, wpScalingParam *&wp )
1774	{
1775	wp = m_weightPredTable[e][iRefIdx];
1776	}
1777
1778	/** reset Default WP tables settings : no weight.
1779	* \param wpScalingParam
1780	* \returns Void
1781	*/
1782	Void TComSlice::resetWpScaling()
1783	{
1784	for ( Int e=0 ; e<2 ; e++ )
1785	{
1786	for ( Int i=0 ; i<MAX_NUM_REF ; i++ )
1787	{
1788	for ( Int yuv=0 ; yuv<3 ; yuv++ )
1789	{
1790	wpScalingParam *pwp = &(m_weightPredTable[e][i][yuv]);
1791	pwp->bPresentFlag = false;
1792	pwp->uiLog2WeightDenom = 0;
1793	pwp->uiLog2WeightDenom = 0;
1794	pwp->iWeight = 1;
1795	pwp->iOffset = 0;
1796	}
1797	}
1798	}
1799	}
1800
1801	/** init WP table
1802	* \returns Void
1803	*/
1804	Void TComSlice::initWpScaling()
1805	{
1806	for ( Int e=0 ; e<2 ; e++ )
1807	{
1808	for ( Int i=0 ; i<MAX_NUM_REF ; i++ )
1809	{
1810	for ( Int yuv=0 ; yuv<3 ; yuv++ )
1811	{
1812	wpScalingParam *pwp = &(m_weightPredTable[e][i][yuv]);
1813	if ( !pwp->bPresentFlag )
1814	{
1815	// Inferring values not present :
1816	pwp->iWeight = (1 << pwp->uiLog2WeightDenom);
1817	pwp->iOffset = 0;
1818	}
1819
1820	pwp->w = pwp->iWeight;
1821	Int bitDepth = yuv ? g_bitDepthC : g_bitDepthY;
1822	pwp->o = pwp->iOffset << (bitDepth-8);
1823	pwp->shift = pwp->uiLog2WeightDenom;
1824	pwp->round = (pwp->uiLog2WeightDenom>=1) ? (1 << (pwp->uiLog2WeightDenom-1)) : (0);
1825	}
1826	}
1827	}
1828	}
1829
1830	#if REPN_FORMAT_IN_VPS
1831	UInt TComSlice::getPicWidthInLumaSamples()
1832	{
1833	TComSPS *sps = getSPS();
1834	TComVPS *vps = getVPS();
1835	UInt retVal, layerId = getLayerId();
1836	if( ( layerId == 0 ) \|\| sps->getUpdateRepFormatFlag() )
1837	{
1838	retVal = sps->getPicWidthInLumaSamples();
1839	}
1840	else
1841	{
1842	retVal = vps->getVpsRepFormat( vps->getVpsRepFormatIdx(layerId) )->getPicWidthVpsInLumaSamples();
1843	}
1844	return retVal;
1845	}
1846	UInt TComSlice::getPicHeightInLumaSamples()
1847	{
1848	TComSPS *sps = getSPS();
1849	TComVPS *vps = getVPS();
1850	UInt retVal, layerId = getLayerId();
1851	if( ( layerId == 0 ) \|\| sps->getUpdateRepFormatFlag() )
1852	{
1853	retVal = sps->getPicHeightInLumaSamples();
1854	}
1855	else
1856	{
1857	retVal = vps->getVpsRepFormat( vps->getVpsRepFormatIdx(layerId) )->getPicHeightVpsInLumaSamples();
1858	}
1859	return retVal;
1860	}
1861	#if AUXILIARY_PICTURES
1862	ChromaFormat TComSlice::getChromaFormatIdc()
1863	#else
1864	UInt TComSlice::getChromaFormatIdc()
1865	#endif
1866	{
1867	TComSPS *sps = getSPS();
1868	TComVPS *vps = getVPS();
1869	#if AUXILIARY_PICTURES
1870	ChromaFormat retVal;
1871	UInt layerId = getLayerId();
1872	#else
1873	UInt retVal, layerId = getLayerId();
1874	#endif
1875	if( ( layerId == 0 ) \|\| sps->getUpdateRepFormatFlag() )
1876	{
1877	retVal = sps->getChromaFormatIdc();
1878	}
1879	else
1880	{
1881	retVal = vps->getVpsRepFormat( vps->getVpsRepFormatIdx(layerId) )->getChromaFormatVpsIdc();
1882	}
1883	return retVal;
1884	}
1885	UInt TComSlice::getBitDepthY()
1886	{
1887	TComSPS *sps = getSPS();
1888	TComVPS *vps = getVPS();
1889	UInt retVal, layerId = getLayerId();
1890	if( ( layerId == 0 ) \|\| sps->getUpdateRepFormatFlag() )
1891	{
1892	retVal = sps->getBitDepthY();
1893	}
1894	else
1895	{
1896	retVal = vps->getVpsRepFormat( vps->getVpsRepFormatIdx(layerId) )->getBitDepthVpsLuma();
1897	}
1898	return retVal;
1899	}
1900	UInt TComSlice::getBitDepthC()
1901	{
1902	TComSPS *sps = getSPS();
1903	TComVPS *vps = getVPS();
1904	UInt retVal, layerId = getLayerId();
1905	if( ( layerId == 0 ) \|\| sps->getUpdateRepFormatFlag() )
1906	{
1907	retVal = sps->getBitDepthC();
1908	}
1909	else
1910	{
1911	retVal = vps->getVpsRepFormat( vps->getVpsRepFormatIdx(layerId) )->getBitDepthVpsChroma();
1912	}
1913	return retVal;
1914	}
1915	Int TComSlice::getQpBDOffsetY()
1916	{
1917	return (getBitDepthY() - 8) * 6;
1918	}
1919	Int TComSlice::getQpBDOffsetC()
1920	{
1921	return (getBitDepthC() - 8) * 6;
1922	}
1923
1924	RepFormat::RepFormat()
1925	#if AUXILIARY_PICTURES
1926	: m_chromaFormatVpsIdc (CHROMA_420)
1927	#else
1928	: m_chromaFormatVpsIdc (0)
1929	#endif
1930	, m_separateColourPlaneVpsFlag (false)
1931	, m_picWidthVpsInLumaSamples (0)
1932	, m_picHeightVpsInLumaSamples (0)
1933	, m_bitDepthVpsLuma (0)
1934	, m_bitDepthVpsChroma (0)
1935	{}
1936	#endif
1937
1938	// ------------------------------------------------------------------------------------------------
1939	// Video parameter set (VPS)
1940	// ------------------------------------------------------------------------------------------------
1941	#if SVC_EXTENSION
1942	TComVPS::TComVPS()
1943	: m_VPSId ( 0)
1944	, m_uiMaxTLayers ( 1)
1945	, m_uiMaxLayers ( 1)
1946	, m_bTemporalIdNestingFlag (false)
1947	, m_numHrdParameters ( 0)
1948	#if !VPS_RENAME
1949	, m_maxNuhReservedZeroLayerId ( 0)
1950	#endif
1951	, m_hrdParameters (NULL)
1952	, m_hrdOpSetIdx (NULL)
1953	, m_cprmsPresentFlag (NULL)
1954	#if VPS_RENAME
1955	, m_maxLayerId (0)
1956	, m_numLayerSets (0)
1957	#endif
1958	#if VPS_EXTN_OP_LAYER_SETS
1959	, m_numOutputLayerSets (0)
1960	#endif
1961	, m_numProfileTierLevel (0)
1962	, m_moreOutputLayerSetsThanDefaultFlag (false)
1963	, m_numAddOutputLayerSets (0)
1964	, m_defaultOneTargetOutputLayerFlag (false)
1965	#if VPS_VUI_BITRATE_PICRATE
1966	, m_bitRatePresentVpsFlag (false)
1967	, m_picRatePresentVpsFlag (false)
1968	#endif
1969	#if REPN_FORMAT_IN_VPS
1970	, m_repFormatIdxPresentFlag (true)
1971	, m_vpsNumRepFormats (1)
1972	#endif
1973	#if VIEW_ID_RELATED_SIGNALING
1974	, m_viewIdLenMinus1 (0)
1975	#endif
1976	{
1977	for( Int i = 0; i < MAX_TLAYER; i++)
1978	{
1979	m_numReorderPics[i] = 0;
1980	m_uiMaxDecPicBuffering[i] = 1;
1981	m_uiMaxLatencyIncrease[i] = 0;
1982	}
1983	#if VPS_EXTN_MASK_AND_DIM_INFO
1984	m_avcBaseLayerFlag = false;
1985	m_splittingFlag = false;
1986	::memset(m_scalabilityMask, 0, sizeof(m_scalabilityMask));
1987	::memset(m_dimensionIdLen, 0, sizeof(m_dimensionIdLen));
1988	m_nuhLayerIdPresentFlag = false;
1989	::memset(m_layerIdInNuh, 0, sizeof(m_layerIdInNuh));
1990	::memset(m_dimensionId, 0, sizeof(m_dimensionId));
1991
1992	m_numScalabilityTypes = 0;
1993	::memset(m_layerIdInVps, 0, sizeof(m_layerIdInVps));
1994	#endif
1995	#if VPS_EXTN_PROFILE_INFO
1996	::memset(m_profilePresentFlag, 0, sizeof(m_profilePresentFlag));
1997	::memset(m_profileLayerSetRef, 0, sizeof(m_profileLayerSetRef));
1998	#endif
1999	#if VPS_EXTN_OP_LAYER_SETS
2000	::memset(m_layerIdIncludedFlag, 0, sizeof(m_layerIdIncludedFlag));
2001	// Consider dynamic allocation for outputLayerSetIdx and outputLayerFlag
2002	::memset(m_outputLayerSetIdx, 0, sizeof(m_outputLayerSetIdx));
2003	::memset(m_outputLayerFlag, 0, sizeof(m_outputLayerFlag));
2004	#endif
2005	#if VPS_EXTN_DIRECT_REF_LAYERS
2006	::memset(m_directDependencyFlag, 0, sizeof(m_directDependencyFlag));
2007	::memset(m_numDirectRefLayers, 0, sizeof(m_numDirectRefLayers ));
2008	::memset(m_refLayerId, 0, sizeof(m_refLayerId ));
2009	#if M0457_PREDICTION_INDICATIONS
2010	m_directDepTypeLen = 2;
2011	::memset(m_directDependencyType, 0, sizeof(m_directDependencyType));
2012	#endif
2013	#endif
2014	#if DERIVE_LAYER_ID_LIST_VARIABLES
2015	::memset(m_layerSetLayerIdList, 0, sizeof(m_layerSetLayerIdList));
2016	::memset(m_numLayerInIdList, 0, sizeof(m_numLayerInIdList ));
2017	#endif
2018	::memset(m_profileLevelTierIdx, 0, sizeof(m_profileLevelTierIdx));
2019	#if JCTVC_M0458_INTERLAYER_RPS_SIG
2020	m_maxOneActiveRefLayerFlag = true;
2021	#endif
2022	#if O0062_POC_LSB_NOT_PRESENT_FLAG
2023	::memset(m_pocLsbNotPresentFlag, 0, sizeof(m_pocLsbNotPresentFlag));
2024	#endif
2025	#if N0147_IRAP_ALIGN_FLAG
2026	m_crossLayerIrapAlignFlag = true;
2027	#endif
2028	#if JCTVC_M0203_INTERLAYER_PRED_IDC
2029	#if N0120_MAX_TID_REF_PRESENT_FLAG
2030	m_maxTidRefPresentFlag = true;
2031	#endif
2032	for( Int i = 0; i < MAX_VPS_LAYER_ID_PLUS1 - 1; i++)
2033	{
2034	#if O0225_MAX_TID_FOR_REF_LAYERS
2035	for( Int j = 0; j < MAX_VPS_LAYER_ID_PLUS1; j++)
2036	{
2037	m_maxTidIlRefPicsPlus1[i][j] = m_uiMaxTLayers + 1;
2038	}
2039	#else
2040	m_maxTidIlRefPicsPlus1[i] = m_uiMaxTLayers + 1;
2041	#endif
2042	}
2043	#endif
2044	#if TILE_BOUNDARY_ALIGNED_FLAG
2045	::memset(m_tileBoundariesAlignedFlag, 0, sizeof(m_tileBoundariesAlignedFlag));
2046	#endif
2047	#if N0160_VUI_EXT_ILP_REF
2048	m_numIlpRestrictedRefLayers = false;
2049	::memset(m_minSpatialSegmentOffsetPlus1, 0, sizeof(m_minSpatialSegmentOffsetPlus1));
2050	::memset(m_ctuBasedOffsetEnabledFlag, 0, sizeof(m_ctuBasedOffsetEnabledFlag));
2051	::memset(m_minHorizontalCtuOffsetPlus1, 0, sizeof(m_minHorizontalCtuOffsetPlus1));
2052	#endif
2053	#if VPS_VUI_BITRATE_PICRATE
2054	::memset(m_bitRatePresentFlag, 0, sizeof(m_bitRatePresentFlag));
2055	::memset(m_picRatePresentFlag, 0, sizeof(m_picRatePresentFlag));
2056	::memset(m_avgBitRate , 0, sizeof(m_avgBitRate) );
2057	::memset(m_maxBitRate , 0, sizeof(m_maxBitRate) );
2058	::memset(m_constPicRateIdc , 0, sizeof(m_constPicRateIdc) );
2059	::memset(m_avgPicRate , 0, sizeof(m_avgPicRate) );
2060	#endif
2061	#if REPN_FORMAT_IN_VPS
2062	::memset( m_vpsRepFormatIdx, 0, sizeof(m_vpsRepFormatIdx) );
2063	#endif
2064	#if VIEW_ID_RELATED_SIGNALING
2065	::memset(m_viewIdVal, 0, sizeof(m_viewIdVal));
2066	#endif
2067	}
2068	#else
2069	TComVPS::TComVPS()
2070	: m_VPSId ( 0)
2071	, m_uiMaxTLayers ( 1)
2072	, m_uiMaxLayers ( 1)
2073	, m_bTemporalIdNestingFlag (false)
2074	, m_numHrdParameters ( 0)
2075	, m_maxNuhReservedZeroLayerId ( 0)
2076	, m_hrdParameters (NULL)
2077	, m_hrdOpSetIdx (NULL)
2078	, m_cprmsPresentFlag (NULL)
2079	{
2080	for( Int i = 0; i < MAX_TLAYER; i++)
2081	{
2082	m_numReorderPics[i] = 0;
2083	m_uiMaxDecPicBuffering[i] = 1;
2084	m_uiMaxLatencyIncrease[i] = 0;
2085	}
2086	}
2087	#endif //SVC_EXTENSION
2088
2089	TComVPS::~TComVPS()
2090	{
2091	if( m_hrdParameters != NULL ) delete[] m_hrdParameters;
2092	if( m_hrdOpSetIdx != NULL ) delete[] m_hrdOpSetIdx;
2093	if( m_cprmsPresentFlag != NULL ) delete[] m_cprmsPresentFlag;
2094	}
2095	#if DERIVE_LAYER_ID_LIST_VARIABLES
2096	Void TComVPS::deriveLayerIdListVariables()
2097	{
2098	// For layer 0
2099	setNumLayersInIdList(0, 1);
2100	setLayerSetLayerIdList(0, 0, 0);
2101
2102	// For other layers
2103	Int i, m, n;
2104	for( i = 1; i <= getNumLayerSets() - 1; i++ )
2105	{
2106	n = 0;
2107	for( m = 0; m <= this->getMaxLayerId(); m++)
2108	{
2109	if(this->getLayerIdIncludedFlag(i, m))
2110	{
2111	setLayerSetLayerIdList(i, n, m);
2112	n++;
2113	}
2114	}
2115	setNumLayersInIdList(i, n);
2116	}
2117	}
2118	#endif
2119
2120	#if IL_SL_SIGNALLING_N0371
2121	Bool TComVPS::checkLayerDependency(UInt i, UInt j)
2122	{
2123	if( this->getDirectDependencyFlag(i, j) == true )
2124	{
2125	return true;
2126	}
2127	else
2128	{
2129	for(UInt k=i-1; k>j; k--)
2130	{
2131	if( this->getDirectDependencyFlag(i, k) == true )
2132	{
2133	checkLayerDependency( k,j );
2134	}
2135	}
2136	}
2137	return false;
2138	}
2139	#endif
2140
2141	#if VIEW_ID_RELATED_SIGNALING
2142	Int TComVPS::getNumViews()
2143	{
2144	Int numViews = 1;
2145	for( Int i = 0; i <= getMaxLayers() - 1; i++ )
2146	{
2147	Int lId = getLayerIdInNuh( i );
2148	if ( i > 0 && ( getViewIndex( lId ) != getScalabilityId( i - 1, VIEW_ORDER_INDEX ) ) )
2149	{
2150	numViews++;
2151	}
2152	}
2153
2154	return numViews;
2155	}
2156	Int TComVPS::getScalabilityId( Int layerIdInVps, ScalabilityType scalType )
2157	{
2158	return getScalabilityMask( scalType ) ? getDimensionId( layerIdInVps, scalTypeToScalIdx( scalType ) ) : 0;
2159	}
2160	Int TComVPS::scalTypeToScalIdx( ScalabilityType scalType )
2161	{
2162	assert( scalType >= 0 && scalType <= MAX_VPS_NUM_SCALABILITY_TYPES );
2163	assert( scalType == MAX_VPS_NUM_SCALABILITY_TYPES \|\| getScalabilityMask( scalType ) );
2164	Int scalIdx = 0;
2165	for( Int curScalType = 0; curScalType < scalType; curScalType++ )
2166	{
2167	scalIdx += ( getScalabilityMask( curScalType ) ? 1 : 0 );
2168
2169	}
2170
2171	return scalIdx;
2172	}
2173	#endif
2174	// ------------------------------------------------------------------------------------------------
2175	// Sequence parameter set (SPS)
2176	// ------------------------------------------------------------------------------------------------
2177
2178	TComSPS::TComSPS()
2179	: m_SPSId ( 0)
2180	, m_VPSId ( 0)
2181	, m_chromaFormatIdc (CHROMA_420)
2182	, m_uiMaxTLayers ( 1)
2183	// Structure
2184	, m_picWidthInLumaSamples (352)
2185	, m_picHeightInLumaSamples (288)
2186	, m_log2MinCodingBlockSize ( 0)
2187	, m_log2DiffMaxMinCodingBlockSize (0)
2188	, m_uiMaxCUWidth ( 32)
2189	, m_uiMaxCUHeight ( 32)
2190	, m_uiMaxCUDepth ( 3)
2191	, m_bLongTermRefsPresent (false)
2192	, m_uiQuadtreeTULog2MaxSize ( 0)
2193	, m_uiQuadtreeTULog2MinSize ( 0)
2194	, m_uiQuadtreeTUMaxDepthInter ( 0)
2195	, m_uiQuadtreeTUMaxDepthIntra ( 0)
2196	// Tool list
2197	, m_usePCM (false)
2198	, m_pcmLog2MaxSize ( 5)
2199	, m_uiPCMLog2MinSize ( 7)
2200	, m_bitDepthY ( 8)
2201	, m_bitDepthC ( 8)
2202	, m_qpBDOffsetY ( 0)
2203	, m_qpBDOffsetC ( 0)
2204	, m_useLossless (false)
2205	, m_uiPCMBitDepthLuma ( 8)
2206	, m_uiPCMBitDepthChroma ( 8)
2207	, m_bPCMFilterDisableFlag (false)
2208	, m_uiBitsForPOC ( 8)
2209	, m_numLongTermRefPicSPS ( 0)
2210	, m_uiMaxTrSize ( 32)
2211	, m_bUseSAO (false)
2212	, m_bTemporalIdNestingFlag (false)
2213	, m_scalingListEnabledFlag (false)
2214	, m_useStrongIntraSmoothing (false)
2215	, m_vuiParametersPresentFlag (false)
2216	, m_vuiParameters ()
2217	#if SVC_EXTENSION
2218	#if M0463_VUI_EXT_ILP_REF
2219	, m_interViewMvVertConstraintFlag (false)
2220	, m_numIlpRestrictedRefLayers ( 0 )
2221	#endif
2222	, m_layerId ( 0 )
2223	, m_numScaledRefLayerOffsets ( 0 )
2224	#if REPN_FORMAT_IN_VPS
2225	, m_updateRepFormatFlag (false)
2226	#endif
2227	#endif //SVC_EXTENSION
2228	{
2229	for ( Int i = 0; i < MAX_TLAYER; i++ )
2230	{
2231	m_uiMaxLatencyIncrease[i] = 0;
2232	m_uiMaxDecPicBuffering[i] = 1;
2233	m_numReorderPics[i] = 0;
2234	}
2235	m_scalingList = new TComScalingList;
2236	::memset(m_ltRefPicPocLsbSps, 0, sizeof(m_ltRefPicPocLsbSps));
2237	::memset(m_usedByCurrPicLtSPSFlag, 0, sizeof(m_usedByCurrPicLtSPSFlag));
2238	#if M0463_VUI_EXT_ILP_REF
2239	for (Int i = 0; i < MAX_LAYERS; i++ )
2240	{
2241	m_minSpatialSegmentOffsetPlus1[ i ] = 0;
2242	m_ctuBasedOffsetEnabledFlag [ i ] = false;
2243	m_minHorizontalCtuOffsetPlus1 [ i ] = 0;
2244	}
2245	#endif
2246	}
2247
2248	TComSPS::~TComSPS()
2249	{
2250	delete m_scalingList;
2251	m_RPSList.destroy();
2252	}
2253
2254	Void TComSPS::createRPSList( Int numRPS )
2255	{
2256	m_RPSList.destroy();
2257	m_RPSList.create(numRPS);
2258	}
2259
2260	Void TComSPS::setHrdParameters( UInt frameRate, UInt numDU, UInt bitRate, Bool randomAccess )
2261	{
2262	if( !getVuiParametersPresentFlag() )
2263	{
2264	return;
2265	}
2266
2267	TComVUI *vui = getVuiParameters();
2268	TComHRD *hrd = vui->getHrdParameters();
2269
2270	TimingInfo *timingInfo = vui->getTimingInfo();
2271	#if TIMING_INFO_NONZERO_LAYERID_SPS
2272	if( getLayerId() > 0 )
2273	{
2274	timingInfo->setTimingInfoPresentFlag( false );
2275	}
2276	else
2277	{
2278	#endif
2279	timingInfo->setTimingInfoPresentFlag( true );
2280	switch( frameRate )
2281	{
2282	case 24:
2283	timingInfo->setNumUnitsInTick( 1125000 ); timingInfo->setTimeScale ( 27000000 );
2284	break;
2285	case 25:
2286	timingInfo->setNumUnitsInTick( 1080000 ); timingInfo->setTimeScale ( 27000000 );
2287	break;
2288	case 30:
2289	timingInfo->setNumUnitsInTick( 900900 ); timingInfo->setTimeScale ( 27000000 );
2290	break;
2291	case 50:
2292	timingInfo->setNumUnitsInTick( 540000 ); timingInfo->setTimeScale ( 27000000 );
2293	break;
2294	case 60:
2295	timingInfo->setNumUnitsInTick( 450450 ); timingInfo->setTimeScale ( 27000000 );
2296	break;
2297	default:
2298	timingInfo->setNumUnitsInTick( 1001 ); timingInfo->setTimeScale ( 60000 );
2299	break;
2300	}
2301
2302	Bool rateCnt = ( bitRate > 0 );
2303	hrd->setNalHrdParametersPresentFlag( rateCnt );
2304	hrd->setVclHrdParametersPresentFlag( rateCnt );
2305
2306	hrd->setSubPicCpbParamsPresentFlag( ( numDU > 1 ) );
2307
2308	if( hrd->getSubPicCpbParamsPresentFlag() )
2309	{
2310	hrd->setTickDivisorMinus2( 100 - 2 ); //
2311	hrd->setDuCpbRemovalDelayLengthMinus1( 7 ); // 8-bit precision ( plus 1 for last DU in AU )
2312	hrd->setSubPicCpbParamsInPicTimingSEIFlag( true );
2313	hrd->setDpbOutputDelayDuLengthMinus1( 5 + 7 ); // With sub-clock tick factor of 100, at least 7 bits to have the same value as AU dpb delay
2314	}
2315	else
2316	{
2317	hrd->setSubPicCpbParamsInPicTimingSEIFlag( false );
2318	}
2319
2320	hrd->setBitRateScale( 4 ); // in units of 2~( 6 + 4 ) = 1,024 bps
2321	hrd->setCpbSizeScale( 6 ); // in units of 2~( 4 + 4 ) = 1,024 bit
2322	hrd->setDuCpbSizeScale( 6 ); // in units of 2~( 4 + 4 ) = 1,024 bit
2323
2324	hrd->setInitialCpbRemovalDelayLengthMinus1(15); // assuming 0.5 sec, log2( 90,000 * 0.5 ) = 16-bit
2325	if( randomAccess )
2326	{
2327	hrd->setCpbRemovalDelayLengthMinus1(5); // 32 = 2^5 (plus 1)
2328	hrd->setDpbOutputDelayLengthMinus1 (5); // 32 + 3 = 2^6
2329	}
2330	else
2331	{
2332	hrd->setCpbRemovalDelayLengthMinus1(9); // max. 2^10
2333	hrd->setDpbOutputDelayLengthMinus1 (9); // max. 2^10
2334	}
2335
2336	/*
2337	Note: only the case of "vps_max_temporal_layers_minus1 = 0" is supported.
2338	*/
2339	Int i, j;
2340	UInt birateValue, cpbSizeValue;
2341	UInt ducpbSizeValue;
2342	UInt duBitRateValue = 0;
2343
2344	for( i = 0; i < MAX_TLAYER; i ++ )
2345	{
2346	hrd->setFixedPicRateFlag( i, 1 );
2347	hrd->setPicDurationInTcMinus1( i, 0 );
2348	hrd->setLowDelayHrdFlag( i, 0 );
2349	hrd->setCpbCntMinus1( i, 0 );
2350
2351	birateValue = bitRate;
2352	cpbSizeValue = bitRate; // 1 second
2353	ducpbSizeValue = bitRate/numDU;
2354	duBitRateValue = bitRate;
2355	for( j = 0; j < ( hrd->getCpbCntMinus1( i ) + 1 ); j ++ )
2356	{
2357	hrd->setBitRateValueMinus1( i, j, 0, ( birateValue - 1 ) );
2358	hrd->setCpbSizeValueMinus1( i, j, 0, ( cpbSizeValue - 1 ) );
2359	hrd->setDuCpbSizeValueMinus1( i, j, 0, ( ducpbSizeValue - 1 ) );
2360	hrd->setCbrFlag( i, j, 0, ( j == 0 ) );
2361
2362	hrd->setBitRateValueMinus1( i, j, 1, ( birateValue - 1) );
2363	hrd->setCpbSizeValueMinus1( i, j, 1, ( cpbSizeValue - 1 ) );
2364	hrd->setDuCpbSizeValueMinus1( i, j, 1, ( ducpbSizeValue - 1 ) );
2365	hrd->setDuBitRateValueMinus1( i, j, 1, ( duBitRateValue - 1 ) );
2366	hrd->setCbrFlag( i, j, 1, ( j == 0 ) );
2367	}
2368	}
2369	#if TIMING_INFO_NONZERO_LAYERID_SPS
2370	}
2371	#endif
2372	}
2373	const Int TComSPS::m_winUnitX[]={1,2,2,1};
2374	const Int TComSPS::m_winUnitY[]={1,2,1,1};
2375
2376	TComPPS::TComPPS()
2377	: m_PPSId (0)
2378	, m_SPSId (0)
2379	, m_picInitQPMinus26 (0)
2380	, m_useDQP (false)
2381	, m_bConstrainedIntraPred (false)
2382	, m_bSliceChromaQpFlag (false)
2383	, m_pcSPS (NULL)
2384	, m_uiMaxCuDQPDepth (0)
2385	, m_uiMinCuDQPSize (0)
2386	, m_chromaCbQpOffset (0)
2387	, m_chromaCrQpOffset (0)
2388	, m_numRefIdxL0DefaultActive (1)
2389	, m_numRefIdxL1DefaultActive (1)
2390	, m_TransquantBypassEnableFlag (false)
2391	, m_useTransformSkip (false)
2392	, m_dependentSliceSegmentsEnabledFlag (false)
2393	, m_tilesEnabledFlag (false)
2394	, m_entropyCodingSyncEnabledFlag (false)
2395	, m_loopFilterAcrossTilesEnabledFlag (true)
2396	, m_uniformSpacingFlag (0)
2397	, m_iNumColumnsMinus1 (0)
2398	, m_puiColumnWidth (NULL)
2399	, m_iNumRowsMinus1 (0)
2400	, m_puiRowHeight (NULL)
2401	, m_iNumSubstreams (1)
2402	, m_signHideFlag(0)
2403	, m_cabacInitPresentFlag (false)
2404	, m_encCABACTableIdx (I_SLICE)
2405	, m_sliceHeaderExtensionPresentFlag (false)
2406	, m_loopFilterAcrossSlicesEnabledFlag (false)
2407	, m_listsModificationPresentFlag( 0)
2408	, m_numExtraSliceHeaderBits(0)
2409	{
2410	m_scalingList = new TComScalingList;
2411	}
2412
2413	TComPPS::~TComPPS()
2414	{
2415	if( m_iNumColumnsMinus1 > 0 && m_uniformSpacingFlag == 0 )
2416	{
2417	if (m_puiColumnWidth) delete [] m_puiColumnWidth;
2418	m_puiColumnWidth = NULL;
2419	}
2420	if( m_iNumRowsMinus1 > 0 && m_uniformSpacingFlag == 0 )
2421	{
2422	if (m_puiRowHeight) delete [] m_puiRowHeight;
2423	m_puiRowHeight = NULL;
2424	}
2425	delete m_scalingList;
2426	}
2427
2428	TComReferencePictureSet::TComReferencePictureSet()
2429	: m_numberOfPictures (0)
2430	, m_numberOfNegativePictures (0)
2431	, m_numberOfPositivePictures (0)
2432	, m_numberOfLongtermPictures (0)
2433	, m_interRPSPrediction (0)
2434	, m_deltaRIdxMinus1 (0)
2435	, m_deltaRPS (0)
2436	, m_numRefIdc (0)
2437	{
2438	::memset( m_deltaPOC, 0, sizeof(m_deltaPOC) );
2439	::memset( m_POC, 0, sizeof(m_POC) );
2440	::memset( m_used, 0, sizeof(m_used) );
2441	::memset( m_refIdc, 0, sizeof(m_refIdc) );
2442	}
2443
2444	TComReferencePictureSet::~TComReferencePictureSet()
2445	{
2446	}
2447
2448	Void TComReferencePictureSet::setUsed(Int bufferNum, Bool used)
2449	{
2450	m_used[bufferNum] = used;
2451	}
2452
2453	Void TComReferencePictureSet::setDeltaPOC(Int bufferNum, Int deltaPOC)
2454	{
2455	m_deltaPOC[bufferNum] = deltaPOC;
2456	}
2457
2458	Void TComReferencePictureSet::setNumberOfPictures(Int numberOfPictures)
2459	{
2460	m_numberOfPictures = numberOfPictures;
2461	}
2462
2463	Int TComReferencePictureSet::getUsed(Int bufferNum)
2464	{
2465	return m_used[bufferNum];
2466	}
2467
2468	Int TComReferencePictureSet::getDeltaPOC(Int bufferNum)
2469	{
2470	return m_deltaPOC[bufferNum];
2471	}
2472
2473	Int TComReferencePictureSet::getNumberOfPictures()
2474	{
2475	return m_numberOfPictures;
2476	}
2477
2478	Int TComReferencePictureSet::getPOC(Int bufferNum)
2479	{
2480	return m_POC[bufferNum];
2481	}
2482
2483	Void TComReferencePictureSet::setPOC(Int bufferNum, Int POC)
2484	{
2485	m_POC[bufferNum] = POC;
2486	}
2487
2488	Bool TComReferencePictureSet::getCheckLTMSBPresent(Int bufferNum)
2489	{
2490	return m_bCheckLTMSB[bufferNum];
2491	}
2492
2493	Void TComReferencePictureSet::setCheckLTMSBPresent(Int bufferNum, Bool b)
2494	{
2495	m_bCheckLTMSB[bufferNum] = b;
2496	}
2497
2498	/** set the reference idc value at uiBufferNum entry to the value of iRefIdc
2499	* \param uiBufferNum
2500	* \param iRefIdc
2501	* \returns Void
2502	*/
2503	Void TComReferencePictureSet::setRefIdc(Int bufferNum, Int refIdc)
2504	{
2505	m_refIdc[bufferNum] = refIdc;
2506	}
2507
2508	/** get the reference idc value at uiBufferNum
2509	* \param uiBufferNum
2510	* \returns Int
2511	*/
2512	Int TComReferencePictureSet::getRefIdc(Int bufferNum)
2513	{
2514	return m_refIdc[bufferNum];
2515	}
2516
2517	/** Sorts the deltaPOC and Used by current values in the RPS based on the deltaPOC values.
2518	* deltaPOC values are sorted with -ve values before the +ve values. -ve values are in decreasing order.
2519	* +ve values are in increasing order.
2520	* \returns Void
2521	*/
2522	Void TComReferencePictureSet::sortDeltaPOC()
2523	{
2524	// sort in increasing order (smallest first)
2525	for(Int j=1; j < getNumberOfPictures(); j++)
2526	{
2527	Int deltaPOC = getDeltaPOC(j);
2528	Bool used = getUsed(j);
2529	for (Int k=j-1; k >= 0; k--)
2530	{
2531	Int temp = getDeltaPOC(k);
2532	if (deltaPOC < temp)
2533	{
2534	setDeltaPOC(k+1, temp);
2535	setUsed(k+1, getUsed(k));
2536	setDeltaPOC(k, deltaPOC);
2537	setUsed(k, used);
2538	}
2539	}
2540	}
2541	// flip the negative values to largest first
2542	Int numNegPics = getNumberOfNegativePictures();
2543	for(Int j=0, k=numNegPics-1; j < numNegPics>>1; j++, k--)
2544	{
2545	Int deltaPOC = getDeltaPOC(j);
2546	Bool used = getUsed(j);
2547	setDeltaPOC(j, getDeltaPOC(k));
2548	setUsed(j, getUsed(k));
2549	setDeltaPOC(k, deltaPOC);
2550	setUsed(k, used);
2551	}
2552	}
2553
2554	/** Prints the deltaPOC and RefIdc (if available) values in the RPS.
2555	* A "*" is added to the deltaPOC value if it is Used bu current.
2556	* \returns Void
2557	*/
2558	Void TComReferencePictureSet::printDeltaPOC()
2559	{
2560	printf("DeltaPOC = { ");
2561	for(Int j=0; j < getNumberOfPictures(); j++)
2562	{
2563	printf("%d%s ", getDeltaPOC(j), (getUsed(j)==1)?"*":"");
2564	}
2565	if (getInterRPSPrediction())
2566	{
2567	printf("}, RefIdc = { ");
2568	for(Int j=0; j < getNumRefIdc(); j++)
2569	{
2570	printf("%d ", getRefIdc(j));
2571	}
2572	}
2573	printf("}\n");
2574	}
2575
2576	TComRPSList::TComRPSList()
2577	:m_referencePictureSets (NULL)
2578	{
2579	}
2580
2581	TComRPSList::~TComRPSList()
2582	{
2583	}
2584
2585	Void TComRPSList::create( Int numberOfReferencePictureSets)
2586	{
2587	m_numberOfReferencePictureSets = numberOfReferencePictureSets;
2588	m_referencePictureSets = new TComReferencePictureSet[numberOfReferencePictureSets];
2589	}
2590
2591	Void TComRPSList::destroy()
2592	{
2593	if (m_referencePictureSets)
2594	{
2595	delete [] m_referencePictureSets;
2596	}
2597	m_numberOfReferencePictureSets = 0;
2598	m_referencePictureSets = NULL;
2599	}
2600
2601
2602
2603	TComReferencePictureSet* TComRPSList::getReferencePictureSet(Int referencePictureSetNum)
2604	{
2605	return &m_referencePictureSets[referencePictureSetNum];
2606	}
2607
2608	Int TComRPSList::getNumberOfReferencePictureSets()
2609	{
2610	return m_numberOfReferencePictureSets;
2611	}
2612
2613	Void TComRPSList::setNumberOfReferencePictureSets(Int numberOfReferencePictureSets)
2614	{
2615	m_numberOfReferencePictureSets = numberOfReferencePictureSets;
2616	}
2617
2618	TComRefPicListModification::TComRefPicListModification()
2619	: m_bRefPicListModificationFlagL0 (false)
2620	, m_bRefPicListModificationFlagL1 (false)
2621	{
2622	::memset( m_RefPicSetIdxL0, 0, sizeof(m_RefPicSetIdxL0) );
2623	::memset( m_RefPicSetIdxL1, 0, sizeof(m_RefPicSetIdxL1) );
2624	}
2625
2626	TComRefPicListModification::~TComRefPicListModification()
2627	{
2628	}
2629
2630	TComScalingList::TComScalingList()
2631	{
2632	init();
2633	}
2634
2635	TComScalingList::~TComScalingList()
2636	{
2637	destroy();
2638	}
2639
2640	/** set default quantization matrix to array
2641	*/
2642	#if IL_SL_SIGNALLING_N0371
2643	Void TComSlice::setDefaultScalingList( UInt layerId )
2644	#else
2645	Void TComSlice::setDefaultScalingList()
2646	#endif
2647	{
2648	for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2649	{
2650	for(UInt listId=0;listId<g_scalingListNum[sizeId];listId++)
2651	{
2652	#if IL_SL_SIGNALLING_N0371
2653	getScalingList()->processDefaultMarix(sizeId, listId, layerId);
2654	#else
2655	getScalingList()->processDefaultMarix(sizeId, listId);
2656	#endif
2657	}
2658	}
2659	}
2660	/** check if use default quantization matrix
2661	* \returns true if use default quantization matrix in all size
2662	*/
2663	Bool TComSlice::checkDefaultScalingList()
2664	{
2665	UInt defaultCounter=0;
2666
2667	for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2668	{
2669	for(UInt listId=0;listId<g_scalingListNum[sizeId];listId++)
2670	{
2671	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
2672	&& ((sizeId < SCALING_LIST_16x16) \|\| (getScalingList()->getScalingListDC(sizeId,listId) == 16))) // check DC value
2673	{
2674	defaultCounter++;
2675	}
2676	}
2677	}
2678	return (defaultCounter == (SCALING_LIST_NUM * SCALING_LIST_SIZE_NUM - 4)) ? false : true; // -4 for 32x32
2679	}
2680
2681	/** get scaling matrix from RefMatrixID
2682	* \param sizeId size index
2683	* \param Index of input matrix
2684	* \param Index of reference matrix
2685	*/
2686	Void TComScalingList::processRefMatrix( UInt sizeId, UInt listId , UInt refListId )
2687	{
2688	::memcpy(getScalingListAddress(sizeId, listId),((listId == refListId)? getScalingListDefaultAddress(sizeId, refListId): getScalingListAddress(sizeId, refListId)),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
2689	}
2690
2691	/** parse syntax infomation
2692	* \param pchFile syntax infomation
2693	* \returns false if successful
2694	*/
2695	Bool TComScalingList::xParseScalingList(Char* pchFile)
2696	{
2697	FILE *fp;
2698	Char line[1024];
2699	UInt sizeIdc,listIdc;
2700	UInt i,size = 0;
2701	Int *src=0,data;
2702	Char *ret;
2703	UInt retval;
2704
2705	if((fp = fopen(pchFile,"r")) == (FILE*)NULL)
2706	{
2707	printf("can't open file %s :: set Default Matrix\n",pchFile);
2708	return true;
2709	}
2710
2711	for(sizeIdc = 0; sizeIdc < SCALING_LIST_SIZE_NUM; sizeIdc++)
2712	{
2713	size = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeIdc]);
2714	for(listIdc = 0; listIdc < g_scalingListNum[sizeIdc]; listIdc++)
2715	{
2716	src = getScalingListAddress(sizeIdc, listIdc);
2717
2718	fseek(fp,0,0);
2719	do
2720	{
2721	ret = fgets(line, 1024, fp);
2722	if ((ret==NULL)\|\|(strstr(line, MatrixType[sizeIdc][listIdc])==NULL && feof(fp)))
2723	{
2724	printf("Error: can't read Matrix :: set Default Matrix\n");
2725	return true;
2726	}
2727	}
2728	while (strstr(line, MatrixType[sizeIdc][listIdc]) == NULL);
2729	for (i=0; i<size; i++)
2730	{
2731	retval = fscanf(fp, "%d,", &data);
2732	if (retval!=1)
2733	{
2734	printf("Error: can't read Matrix :: set Default Matrix\n");
2735	return true;
2736	}
2737	src[i] = data;
2738	}
2739	//set DC value for default matrix check
2740	setScalingListDC(sizeIdc,listIdc,src[0]);
2741
2742	if(sizeIdc > SCALING_LIST_8x8)
2743	{
2744	fseek(fp,0,0);
2745	do
2746	{
2747	ret = fgets(line, 1024, fp);
2748	if ((ret==NULL)\|\|(strstr(line, MatrixType_DC[sizeIdc][listIdc])==NULL && feof(fp)))
2749	{
2750	printf("Error: can't read DC :: set Default Matrix\n");
2751	return true;
2752	}
2753	}
2754	while (strstr(line, MatrixType_DC[sizeIdc][listIdc]) == NULL);
2755	retval = fscanf(fp, "%d,", &data);
2756	if (retval!=1)
2757	{
2758	printf("Error: can't read Matrix :: set Default Matrix\n");
2759	return true;
2760	}
2761	//overwrite DC value when size of matrix is larger than 16x16
2762	setScalingListDC(sizeIdc,listIdc,data);
2763	}
2764	}
2765	}
2766	fclose(fp);
2767	return false;
2768	}
2769
2770	/** initialization process of quantization matrix array
2771	*/
2772	Void TComScalingList::init()
2773	{
2774	for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2775	{
2776	for(UInt listId = 0; listId < g_scalingListNum[sizeId]; listId++)
2777	{
2778	m_scalingListCoef[sizeId][listId] = new Int [min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])];
2779	}
2780	}
2781	m_scalingListCoef[SCALING_LIST_32x32][3] = m_scalingListCoef[SCALING_LIST_32x32][1]; // copy address for 32x32
2782	}
2783
2784	/** destroy quantization matrix array
2785	*/
2786	Void TComScalingList::destroy()
2787	{
2788	for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2789	{
2790	for(UInt listId = 0; listId < g_scalingListNum[sizeId]; listId++)
2791	{
2792	if(m_scalingListCoef[sizeId][listId]) delete [] m_scalingListCoef[sizeId][listId];
2793	}
2794	}
2795	}
2796
2797	/** get default address of quantization matrix
2798	* \param sizeId size index
2799	* \param listId list index
2800	* \returns pointer of quantization matrix
2801	*/
2802	Int* TComScalingList::getScalingListDefaultAddress(UInt sizeId, UInt listId)
2803	{
2804	Int *src = 0;
2805	switch(sizeId)
2806	{
2807	case SCALING_LIST_4x4:
2808	src = g_quantTSDefault4x4;
2809	break;
2810	case SCALING_LIST_8x8:
2811	src = (listId<3) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
2812	break;
2813	case SCALING_LIST_16x16:
2814	src = (listId<3) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
2815	break;
2816	case SCALING_LIST_32x32:
2817	src = (listId<1) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
2818	break;
2819	default:
2820	assert(0);
2821	src = NULL;
2822	break;
2823	}
2824	return src;
2825	}
2826
2827	/** process of default matrix
2828	* \param sizeId size index
2829	* \param Index of input matrix
2830	*/
2831	#if IL_SL_SIGNALLING_N0371
2832	Void TComScalingList::processDefaultMarix(UInt sizeId, UInt listId, UInt layerId)
2833	#else
2834	Void TComScalingList::processDefaultMarix(UInt sizeId, UInt listId)
2835	#endif
2836	{
2837	#if IL_SL_SIGNALLING_N0371
2838	Int i,coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
2839	UInt* scan = (sizeId == 0) ? g_auiSigLastScan [ SCAN_DIAG ] [ 1 ] : g_sigLastScanCG32x32;
2840	Int *src = getScalingListDefaultAddress(sizeId, listId);
2841	#endif
2842
2843	::memcpy(getScalingListAddress(sizeId, listId),getScalingListDefaultAddress(sizeId,listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
2844
2845	#if IL_SL_SIGNALLING_N0371
2846	for(i = 0; i < coefNum; i++)
2847	{
2848	ref_scalingListCoef[layerId][sizeId][listId][i] = src[scan[i]];
2849	}
2850	#endif
2851
2852	setScalingListDC(sizeId,listId,SCALING_LIST_DC);
2853	#if IL_SL_SIGNALLING_N0371
2854	ref_scalingListDC[layerId][sizeId][listId] = SCALING_LIST_DC;
2855	#endif
2856	}
2857
2858	/** check DC value of matrix for default matrix signaling
2859	*/
2860	#if IL_SL_SIGNALLING_N0371
2861	Void TComScalingList::checkDcOfMatrix( UInt layerId )
2862	#else
2863	Void TComScalingList::checkDcOfMatrix()
2864	#endif
2865	{
2866	for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2867	{
2868	for(UInt listId = 0; listId < g_scalingListNum[sizeId]; listId++)
2869	{
2870	//check default matrix?
2871	if(getScalingListDC(sizeId,listId) == 0)
2872	{
2873	#if IL_SL_SIGNALLING_N0371
2874	processDefaultMarix(sizeId, listId, layerId);
2875	#else
2876	processDefaultMarix(sizeId, listId);
2877	#endif
2878	}
2879	}
2880	}
2881	}
2882
2883	ParameterSetManager::ParameterSetManager()
2884	#if SVC_EXTENSION
2885	: m_spsMap(MAX_NUM_SPS)
2886	, m_ppsMap(MAX_NUM_PPS)
2887	, m_activeSPSId(-1)
2888	, m_activePPSId(-1)
2889	#else
2890	: m_vpsMap(MAX_NUM_VPS)
2891	, m_spsMap(MAX_NUM_SPS)
2892	, m_ppsMap(MAX_NUM_PPS)
2893	, m_activeVPSId(-1)
2894	, m_activeSPSId(-1)
2895	, m_activePPSId(-1)
2896	#endif
2897	{
2898	}
2899
2900
2901	ParameterSetManager::~ParameterSetManager()
2902	{
2903	}
2904
2905	//! activate a SPS from a active parameter sets SEI message
2906	//! \returns true, if activation is successful
2907	Bool ParameterSetManager::activateSPSWithSEI(Int spsId)
2908	{
2909	TComSPS *sps = m_spsMap.getPS(spsId);
2910	if (sps)
2911	{
2912	Int vpsId = sps->getVPSId();
2913	if (m_vpsMap.getPS(vpsId))
2914	{
2915	m_activeVPSId = vpsId;
2916	m_activeSPSId = spsId;
2917	return true;
2918	}
2919	else
2920	{
2921	printf("Warning: tried to activate SPS using an Active parameter sets SEI message. Referenced VPS does not exist.");
2922	}
2923	}
2924	else
2925	{
2926	printf("Warning: tried to activate non-existing SPS using an Active parameter sets SEI message.");
2927	}
2928	return false;
2929	}
2930
2931	//! activate a PPS and depending on isIDR parameter also SPS and VPS
2932	//! \returns true, if activation is successful
2933	Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP)
2934	{
2935	TComPPS *pps = m_ppsMap.getPS(ppsId);
2936	if (pps)
2937	{
2938	Int spsId = pps->getSPSId();
2939	if (!isIRAP && (spsId != m_activeSPSId))
2940	{
2941	printf("Warning: tried to activate PPS referring to a inactive SPS at non-IRAP.");
2942	return false;
2943	}
2944	TComSPS *sps = m_spsMap.getPS(spsId);
2945	if (sps)
2946	{
2947	Int vpsId = sps->getVPSId();
2948	if (!isIRAP && (vpsId != m_activeVPSId))
2949	{
2950	printf("Warning: tried to activate PPS referring to a inactive VPS at non-IRAP.");
2951	return false;
2952	}
2953	if (m_vpsMap.getPS(vpsId))
2954	{
2955	m_activePPSId = ppsId;
2956	m_activeVPSId = vpsId;
2957	m_activeSPSId = spsId;
2958
2959	#if IL_SL_SIGNALLING_N0371
2960	activeRefPPSId[ sps->getLayerId() ] = ppsId;
2961	activeRefSPSId[ sps->getLayerId() ] = spsId;
2962	#endif
2963
2964	return true;
2965	}
2966	else
2967	{
2968	printf("Warning: tried to activate PPS that refers to a non-existing VPS.");
2969	}
2970	}
2971	else
2972	{
2973	printf("Warning: tried to activate a PPS that refers to a non-existing SPS.");
2974	}
2975	}
2976	else
2977	{
2978	printf("Warning: tried to activate non-existing PPS.");
2979	}
2980	return false;
2981	}
2982
2983	ProfileTierLevel::ProfileTierLevel()
2984	: m_profileSpace (0)
2985	, m_tierFlag (false)
2986	, m_profileIdc (0)
2987	, m_levelIdc (0)
2988	, m_progressiveSourceFlag (false)
2989	, m_interlacedSourceFlag (false)
2990	, m_nonPackedConstraintFlag(false)
2991	, m_frameOnlyConstraintFlag(false)
2992	{
2993	::memset(m_profileCompatibilityFlag, 0, sizeof(m_profileCompatibilityFlag));
2994	}
2995	#if VPS_EXTN_PROFILE_INFO
2996	Void ProfileTierLevel::copyProfileInfo(ProfileTierLevel *ptl)
2997	{
2998	this->setProfileSpace ( ptl->getProfileSpace() );
2999	this->setTierFlag ( ptl->getTierFlag() );
3000	this->setProfileIdc ( ptl->getProfileIdc() );
3001	for(Int j = 0; j < 32; j++)
3002	{
3003	this->setProfileCompatibilityFlag(j, ptl->getProfileCompatibilityFlag(j));
3004	}
3005	this->setProgressiveSourceFlag ( ptl->getProgressiveSourceFlag() );
3006	this->setInterlacedSourceFlag ( ptl->getInterlacedSourceFlag() );
3007	this->setNonPackedConstraintFlag( ptl->getNonPackedConstraintFlag());
3008	this->setFrameOnlyConstraintFlag( ptl->getFrameOnlyConstraintFlag());
3009	}
3010	#endif
3011
3012	TComPTL::TComPTL()
3013	{
3014	::memset(m_subLayerProfilePresentFlag, 0, sizeof(m_subLayerProfilePresentFlag));
3015	::memset(m_subLayerLevelPresentFlag, 0, sizeof(m_subLayerLevelPresentFlag ));
3016	}
3017	#if VPS_EXTN_PROFILE_INFO
3018	Void TComPTL::copyProfileInfo(TComPTL *ptl)
3019	{
3020	// Copy all information related to general profile
3021	this->getGeneralPTL()->copyProfileInfo(ptl->getGeneralPTL());
3022	}
3023	#endif
3024
3025	#if SVC_EXTENSION
3026	#if AVC_SYNTAX
3027	Void TComSlice::initBaseLayerRPL( TComSlice *pcSlice )
3028	{
3029	// Assumed that RPL of the base layer is same to the EL, otherwise this information should be also dumped and read from the metadata file
3030	setPOC( pcSlice->getPOC() );
3031	if( pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA )
3032	{
3033	setSliceType( I_SLICE );
3034	}
3035	else
3036	{
3037	setSliceType( pcSlice->getSliceType() );
3038	}
3039
3040	if( this->isIntra() )
3041	{
3042	return;
3043	}
3044
3045	//initialize reference POC of BL
3046	for( Int iRefPicList = 0; iRefPicList < 2; iRefPicList++ )
3047	{
3048	RefPicList eRefPicList = RefPicList( iRefPicList );
3049
3050	assert( pcSlice->getNumRefIdx( eRefPicList) >= 0 );
3051	setNumRefIdx( eRefPicList, pcSlice->getNumRefIdx( eRefPicList ) - 1 );
3052	assert( getNumRefIdx( eRefPicList) <= MAX_NUM_REF);
3053
3054	for(Int refIdx = 0; refIdx < getNumRefIdx( eRefPicList ); refIdx++)
3055	{
3056	setRefPOC( pcSlice->getRefPic( eRefPicList, refIdx )->getPOC(), eRefPicList, refIdx );
3057	setRefPic( pcSlice->getRefPic( eRefPicList, refIdx ), eRefPicList, refIdx );
3058	/*
3059	// should be set if the base layer has its own instance of the reference picture lists, currently EL RPL is reused.
3060	getRefPic( eRefPicList, refIdx )->setLayerId( 0 );
3061	getRefPic( eRefPicList, refIdx )->setIsLongTerm( pcSlice->getRefPic( eRefPicList, refIdx )->getIsLongTerm() );
3062	*/
3063
3064	}
3065	}
3066	return;
3067	}
3068	#endif
3069
3070	Void TComSlice::setBaseColPic( TComList<TComPic*>& rcListPic, UInt refLayerIdc )
3071	{
3072	if(m_layerId == 0)
3073	{
3074	memset( m_pcBaseColPic, 0, sizeof( m_pcBaseColPic ) );
3075	return;
3076	}
3077	#if POC_RESET_FLAG
3078	if( this->getPocResetFlag() )
3079	{
3080	setBaseColPic(refLayerIdc, xGetRefPic(rcListPic, 0));
3081	}
3082	else
3083	{
3084	setBaseColPic(refLayerIdc, xGetRefPic(rcListPic, getPOC()));
3085	}
3086	#else
3087	setBaseColPic(refLayerIdc, xGetRefPic(rcListPic, getPOC()));
3088	#endif
3089	}
3090
3091	#if MFM_ENCCONSTRAINT
3092	TComPic* TComSlice::getBaseColPic( TComList<TComPic*>& rcListPic )
3093	{
3094	#if POC_RESET_FLAG
3095	return xGetRefPic( rcListPic, m_bPocResetFlag ? 0 : m_iPOC );
3096	#else
3097	return xGetRefPic( rcListPic, m_iPOC );
3098	#endif
3099	}
3100	#endif
3101
3102	#if REF_IDX_MFM
3103	Void TComSlice::setRefPOCListILP( TComPic ilpPic, TComPic pcRefPicRL )
3104	{
3105	for( UInt i = 0; i < m_activeNumILRRefIdx; i++ )
3106	{
3107	UInt refLayerIdc = m_interLayerPredLayerIdc[i];
3108
3109	TComPic* pcRefPicBL = pcRefPicRL[refLayerIdc];
3110	//set reference picture POC of each ILP reference
3111	Int thePoc = ilpPic[refLayerIdc]->getPOC();
3112	assert(thePoc >= 0);
3113	assert(thePoc == pcRefPicBL->getPOC());
3114
3115	ilpPic[refLayerIdc]->getSlice(0)->setBaseColPic( refLayerIdc, pcRefPicBL );
3116
3117	//copy reference pictures marking from the reference layer
3118	ilpPic[refLayerIdc]->getSlice(0)->copySliceInfo(pcRefPicBL->getSlice(0));
3119
3120	for( Int refList = 0; refList < 2; refList++ )
3121	{
3122	RefPicList refPicList = RefPicList( refList );
3123
3124	//set reference POC of ILP
3125	ilpPic[refLayerIdc]->getSlice(0)->setNumRefIdx(refPicList, pcRefPicBL->getSlice(0)->getNumRefIdx(refPicList));
3126	assert(ilpPic[refLayerIdc]->getSlice(0)->getNumRefIdx(refPicList) >= 0);
3127	assert(ilpPic[refLayerIdc]->getSlice(0)->getNumRefIdx(refPicList) <= MAX_NUM_REF);
3128
3129	//initialize reference POC of ILP
3130	for(Int refIdx = 0; refIdx < pcRefPicBL->getSlice(0)->getNumRefIdx(refPicList); refIdx++)
3131	{
3132	ilpPic[refLayerIdc]->getSlice(0)->setRefPOC(pcRefPicBL->getSlice(0)->getRefPOC(refPicList, refIdx), refPicList, refIdx);
3133	ilpPic[refLayerIdc]->getSlice(0)->setRefPic(pcRefPicBL->getSlice(0)->getRefPic(refPicList, refIdx), refPicList, refIdx);
3134	}
3135
3136	for(Int refIdx = pcRefPicBL->getSlice(0)->getNumRefIdx(refPicList); refIdx < MAX_NUM_REF; refIdx++)
3137	{
3138	ilpPic[refLayerIdc]->getSlice(0)->setRefPOC(0, refPicList, refIdx);
3139	ilpPic[refLayerIdc]->getSlice(0)->setRefPic(NULL, refPicList, refIdx);
3140	}
3141	}
3142	}
3143	return;
3144	}
3145	#endif
3146
3147	Void TComSlice::setILRPic(TComPic **pcIlpPic)
3148	{
3149	for( Int i = 0; i < m_activeNumILRRefIdx; i++ )
3150	{
3151	Int refLayerIdc = m_interLayerPredLayerIdc[i];
3152
3153	if( pcIlpPic[refLayerIdc] )
3154	{
3155	pcIlpPic[refLayerIdc]->copyUpsampledPictureYuv( m_pcPic->getFullPelBaseRec( refLayerIdc ), pcIlpPic[refLayerIdc]->getPicYuvRec() );
3156	pcIlpPic[refLayerIdc]->getSlice(0)->setPOC( m_iPOC );
3157	pcIlpPic[refLayerIdc]->setLayerId( m_pcBaseColPic[refLayerIdc]->getLayerId() ); //set reference layerId
3158	pcIlpPic[refLayerIdc]->getPicYuvRec()->setBorderExtension( false );
3159	pcIlpPic[refLayerIdc]->getPicYuvRec()->extendPicBorder();
3160	for (Int j=0; j<pcIlpPic[refLayerIdc]->getPicSym()->getNumberOfCUsInFrame(); j++) // set reference CU layerId
3161	{
3162	pcIlpPic[refLayerIdc]->getPicSym()->getCU(j)->setLayerId( pcIlpPic[refLayerIdc]->getLayerId() );
3163	}
3164	}
3165	}
3166	}
3167
3168	#endif //SVC_EXTENSION
3169
3170	//! \}

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

Download in other formats: