Context navigation

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

Visit:

Last change on this file since 678 was 676, checked in by seregin, 11 years ago
fix for decodingRefreshMarking, reported by Danny Hong <danny@…>
Property svn:eol-style set to `native`
File size: 119.8 KB

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

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

Download in other formats: