Context navigation

source: 3DVCSoftware/trunk/source/Lib/TLibCommon/TComSlice.cpp @ 875

Visit:

Last change on this file since 875 was 872, checked in by tech, 11 years ago
Merged HTM-10.0-dev0@871. (MV-HEVC 7 HLS)
Property svn:eol-style set to `native`
File size: 118.5 KB

Line
1	/* The copyright in this software is being made available under the BSD
2	* License, included below. This software may be subject to other third party
3	* and contributor rights, including patent rights, and no such rights are
4	* granted under this license.
5	*
6	* Copyright (c) 2010-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	TComSlice::TComSlice()
48	: m_iPPSId ( -1 )
49	, m_iPOC ( 0 )
50	, m_iLastIDR ( 0 )
51	, m_eNalUnitType ( NAL_UNIT_CODED_SLICE_IDR_W_RADL )
52	, m_eSliceType ( I_SLICE )
53	, m_iSliceQp ( 0 )
54	, m_dependentSliceSegmentFlag ( false )
55	#if ADAPTIVE_QP_SELECTION
56	, m_iSliceQpBase ( 0 )
57	#endif
58	, m_deblockingFilterDisable ( false )
59	, m_deblockingFilterOverrideFlag ( false )
60	, m_deblockingFilterBetaOffsetDiv2 ( 0 )
61	, m_deblockingFilterTcOffsetDiv2 ( 0 )
62	, m_bCheckLDC ( false )
63	, m_iSliceQpDelta ( 0 )
64	, m_iSliceQpDeltaCb ( 0 )
65	, m_iSliceQpDeltaCr ( 0 )
66	, m_iDepth ( 0 )
67	, m_bRefenced ( false )
68	, m_pcSPS ( NULL )
69	, m_pcPPS ( NULL )
70	, m_pcPic ( NULL )
71	, m_colFromL0Flag ( 1 )
72	, m_colRefIdx ( 0 )
73	, m_uiTLayer ( 0 )
74	, m_bTLayerSwitchingFlag ( false )
75	, m_sliceMode ( 0 )
76	, m_sliceArgument ( 0 )
77	, m_sliceCurStartCUAddr ( 0 )
78	, m_sliceCurEndCUAddr ( 0 )
79	, m_sliceIdx ( 0 )
80	, m_sliceSegmentMode ( 0 )
81	, m_sliceSegmentArgument ( 0 )
82	, m_sliceSegmentCurStartCUAddr ( 0 )
83	, m_sliceSegmentCurEndCUAddr ( 0 )
84	, m_nextSlice ( false )
85	, m_nextSliceSegment ( false )
86	, m_sliceBits ( 0 )
87	, m_sliceSegmentBits ( 0 )
88	, m_bFinalized ( false )
89	, m_uiTileOffstForMultES ( 0 )
90	, m_puiSubstreamSizes ( NULL )
91	, m_cabacInitFlag ( false )
92	, m_bLMvdL1Zero ( false )
93	, m_numEntryPointOffsets ( 0 )
94	, m_temporalLayerNonReferenceFlag ( false )
95	, m_enableTMVPFlag ( true )
96	#if H_MV
97	, m_refPicSetInterLayer0 ( NULL )
98	, m_refPicSetInterLayer1 ( NULL )
99	, m_layerId (0)
100	, m_viewId (0)
101	, m_viewIndex (0)
102	#if H_3D
103	, m_isDepth (false)
104	#endif
105	#if !H_MV_HLS7_GEN
106	, m_pocResetFlag (false)
107	#endif
108	#if H_MV
109	, m_crossLayerBlaFlag (false)
110	#endif
111	, m_discardableFlag (false)
112	, m_interLayerPredEnabledFlag (false)
113	, m_numInterLayerRefPicsMinus1 (0)
114	#if H_MV_HLS_7_POC_P0041
115	, m_sliceSegmentHeaderExtensionLength (0)
116	, m_pocResetIdc (0)
117	, m_pocResetPeriodId (0)
118	, m_fullPocResetFlag (false)
119	, m_pocLsbVal (0)
120	, m_pocMsbValPresentFlag (false)
121	, m_pocMsbVal (0)
122	, m_pocMsbValRequiredFlag ( false )
123	#endif
124	#if H_3D_IC
125	, m_bApplyIC ( false )
126	, m_icSkipParseFlag ( false )
127	#endif
128	#if H_3D
129	, m_depthToDisparityB ( NULL )
130	, m_depthToDisparityF ( NULL )
131	#endif
132	#endif
133	{
134	m_aiNumRefIdx[0] = m_aiNumRefIdx[1] = 0;
135
136	initEqualRef();
137
138	for (Int component = 0; component < 3; component++)
139	{
140	m_lambdas[component] = 0.0;
141	}
142
143	for ( Int idx = 0; idx < MAX_NUM_REF; idx++ )
144	{
145	m_list1IdxToList0Idx[idx] = -1;
146	}
147	for(Int iNumCount = 0; iNumCount < MAX_NUM_REF; iNumCount++)
148	{
149	m_apcRefPicList [0][iNumCount] = NULL;
150	m_apcRefPicList [1][iNumCount] = NULL;
151	m_aiRefPOCList [0][iNumCount] = 0;
152	m_aiRefPOCList [1][iNumCount] = 0;
153	#if H_MV
154	m_aiRefLayerIdList[0][iNumCount] = 0;
155	m_aiRefLayerIdList[1][iNumCount] = 0;
156	#endif
157	}
158	resetWpScaling();
159	initWpAcDcParam();
160	m_saoEnabledFlag = false;
161	m_saoEnabledFlagChroma = false;
162	#if H_MV
163	for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
164	{
165	m_interLayerPredLayerIdc[ i ] = -1;
166	}
167	#endif
168	}
169
170	TComSlice::~TComSlice()
171	{
172	delete[] m_puiSubstreamSizes;
173	m_puiSubstreamSizes = NULL;
174	#if H_3D
175	for( UInt i = 0; i < getViewIndex(); i++ )
176	{
177	if ( m_depthToDisparityB && m_depthToDisparityB[ i ] )
178	{
179	delete[] m_depthToDisparityB [ i ];
180	}
181
182	if ( m_depthToDisparityF && m_depthToDisparityF[ i ] )
183	{
184	delete[] m_depthToDisparityF [ i ];
185	}
186	}
187
188	if ( m_depthToDisparityF )
189	{
190	delete[] m_depthToDisparityF;
191	}
192
193	m_depthToDisparityF = NULL;
194
195	if ( m_depthToDisparityB )
196	delete[] m_depthToDisparityB;
197
198	m_depthToDisparityB = NULL;
199	#endif
200	}
201
202
203	Void TComSlice::initSlice()
204	{
205	m_aiNumRefIdx[0] = 0;
206	m_aiNumRefIdx[1] = 0;
207
208	m_colFromL0Flag = 1;
209
210	m_colRefIdx = 0;
211	initEqualRef();
212	m_bCheckLDC = false;
213	m_iSliceQpDeltaCb = 0;
214	m_iSliceQpDeltaCr = 0;
215
216	#if H_3D_IV_MERGE
217	m_maxNumMergeCand = MRG_MAX_NUM_CANDS_MEM;
218	#else
219	m_maxNumMergeCand = MRG_MAX_NUM_CANDS;
220	#endif
221
222	m_bFinalized=false;
223
224	m_tileByteLocation.clear();
225	m_cabacInitFlag = false;
226	m_numEntryPointOffsets = 0;
227	m_enableTMVPFlag = true;
228	#if H_3D_TMVP
229	m_aiAlterRefIdx[0] = -1;
230	m_aiAlterRefIdx[1] = -1;
231	#endif
232	}
233
234	Bool TComSlice::getRapPicFlag()
235	{
236	return getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
237	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP
238	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
239	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
240	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
241	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA;
242	}
243
244	/**
245	- allocate table to contain substream sizes to be written to the slice header.
246	.
247	\param uiNumSubstreams Number of substreams -- the allocation will be this value - 1.
248	*/
249	Void TComSlice::allocSubstreamSizes(UInt uiNumSubstreams)
250	{
251	delete[] m_puiSubstreamSizes;
252	m_puiSubstreamSizes = new UInt[uiNumSubstreams > 0 ? uiNumSubstreams-1 : 0];
253	}
254
255	Void TComSlice::sortPicList (TComList<TComPic*>& rcListPic)
256	{
257	TComPic* pcPicExtract;
258	TComPic* pcPicInsert;
259
260	TComList<TComPic*>::iterator iterPicExtract;
261	TComList<TComPic*>::iterator iterPicExtract_1;
262	TComList<TComPic*>::iterator iterPicInsert;
263
264	for (Int i = 1; i < (Int)(rcListPic.size()); i++)
265	{
266	iterPicExtract = rcListPic.begin();
267	for (Int j = 0; j < i; j++) iterPicExtract++;
268	pcPicExtract = *(iterPicExtract);
269	pcPicExtract->setCurrSliceIdx(0);
270
271	iterPicInsert = rcListPic.begin();
272	while (iterPicInsert != iterPicExtract)
273	{
274	pcPicInsert = *(iterPicInsert);
275	pcPicInsert->setCurrSliceIdx(0);
276	if (pcPicInsert->getPOC() >= pcPicExtract->getPOC())
277	{
278	break;
279	}
280
281	iterPicInsert++;
282	}
283
284	iterPicExtract_1 = iterPicExtract; iterPicExtract_1++;
285
286	// swap iterPicExtract and iterPicInsert, iterPicExtract = curr. / iterPicInsert = insertion position
287	rcListPic.insert (iterPicInsert, iterPicExtract, iterPicExtract_1);
288	rcListPic.erase (iterPicExtract);
289	}
290	}
291
292	TComPic* TComSlice::xGetRefPic (TComList<TComPic*>& rcListPic,
293	Int poc)
294	{
295	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
296	TComPic* pcPic = *(iterPic);
297	while ( iterPic != rcListPic.end() )
298	{
299	if(pcPic->getPOC() == poc)
300	{
301	break;
302	}
303	iterPic++;
304	pcPic = *(iterPic);
305	}
306	return pcPic;
307	}
308
309
310	TComPic* TComSlice::xGetLongTermRefPic(TComList<TComPic*>& rcListPic, Int poc, Bool pocHasMsb)
311	{
312	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
313	TComPic* pcPic = *(iterPic);
314	TComPic* pcStPic = pcPic;
315
316	Int pocCycle = 1 << getSPS()->getBitsForPOC();
317	if (!pocHasMsb)
318	{
319	poc = poc & (pocCycle - 1);
320	}
321
322	while ( iterPic != rcListPic.end() )
323	{
324	pcPic = *(iterPic);
325	if (pcPic && pcPic->getPOC()!=this->getPOC() && pcPic->getSlice( 0 )->isReferenced())
326	{
327	Int picPoc = pcPic->getPOC();
328	if (!pocHasMsb)
329	{
330	picPoc = picPoc & (pocCycle - 1);
331	}
332
333	if (poc == picPoc)
334	{
335	if(pcPic->getIsLongTerm())
336	{
337	return pcPic;
338	}
339	else
340	{
341	pcStPic = pcPic;
342	}
343	break;
344	}
345	}
346
347	iterPic++;
348	}
349
350	return pcStPic;
351	}
352
353	Void TComSlice::setRefPOCList ()
354	{
355	for (Int iDir = 0; iDir < 2; iDir++)
356	{
357	for (Int iNumRefIdx = 0; iNumRefIdx < m_aiNumRefIdx[iDir]; iNumRefIdx++)
358	{
359	m_aiRefPOCList[iDir][iNumRefIdx] = m_apcRefPicList[iDir][iNumRefIdx]->getPOC();
360	#if H_MV
361	m_aiRefLayerIdList[iDir][iNumRefIdx] = m_apcRefPicList[iDir][iNumRefIdx]->getLayerId();
362	#endif
363	}
364	}
365
366	}
367
368	Void TComSlice::setList1IdxToList0Idx()
369	{
370	Int idxL0, idxL1;
371	for ( idxL1 = 0; idxL1 < getNumRefIdx( REF_PIC_LIST_1 ); idxL1++ )
372	{
373	m_list1IdxToList0Idx[idxL1] = -1;
374	for ( idxL0 = 0; idxL0 < getNumRefIdx( REF_PIC_LIST_0 ); idxL0++ )
375	{
376	if ( m_apcRefPicList[REF_PIC_LIST_0][idxL0]->getPOC() == m_apcRefPicList[REF_PIC_LIST_1][idxL1]->getPOC() )
377	{
378	m_list1IdxToList0Idx[idxL1] = idxL0;
379	break;
380	}
381	}
382	}
383	}
384
385	#if !H_MV
386	Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr )
387	{
388	if (!checkNumPocTotalCurr)
389	{
390	if (m_eSliceType == I_SLICE)
391	{
392	::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
393	::memset( m_aiNumRefIdx, 0, sizeof ( m_aiNumRefIdx ));
394
395	return;
396	}
397
398	m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
399	m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
400	}
401
402	TComPic* pcRefPic= NULL;
403	TComPic* RefPicSetStCurr0[16];
404	TComPic* RefPicSetStCurr1[16];
405	TComPic* RefPicSetLtCurr[16];
406	UInt NumPocStCurr0 = 0;
407	UInt NumPocStCurr1 = 0;
408	UInt NumPocLtCurr = 0;
409	Int i;
410
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
454	// ref_pic_list_init
455	TComPic* rpsCurrList0[MAX_NUM_REF+1];
456	TComPic* rpsCurrList1[MAX_NUM_REF+1];
457	Int numPocTotalCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr;
458	if (checkNumPocTotalCurr)
459	{
460	// 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:
461	// ?If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
462	// ?Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
463	if (getRapPicFlag())
464	{
465	assert(numPocTotalCurr == 0);
466	}
467
468	if (m_eSliceType == I_SLICE)
469	{
470	::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
471	::memset( m_aiNumRefIdx, 0, sizeof ( m_aiNumRefIdx ));
472
473	return;
474	}
475
476	assert(numPocTotalCurr > 0);
477
478	m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
479	m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
480	}
481
482	Int cIdx = 0;
483	for ( i=0; i<NumPocStCurr0; i++, cIdx++)
484	{
485	rpsCurrList0[cIdx] = RefPicSetStCurr0[i];
486	}
487	for ( i=0; i<NumPocStCurr1; i++, cIdx++)
488	{
489	rpsCurrList0[cIdx] = RefPicSetStCurr1[i];
490	}
491	for ( i=0; i<NumPocLtCurr; i++, cIdx++)
492	{
493	rpsCurrList0[cIdx] = RefPicSetLtCurr[i];
494	}
495	assert(cIdx == numPocTotalCurr);
496
497	if (m_eSliceType==B_SLICE)
498	{
499	cIdx = 0;
500	for ( i=0; i<NumPocStCurr1; i++, cIdx++)
501	{
502	rpsCurrList1[cIdx] = RefPicSetStCurr1[i];
503	}
504	for ( i=0; i<NumPocStCurr0; i++, cIdx++)
505	{
506	rpsCurrList1[cIdx] = RefPicSetStCurr0[i];
507	}
508	for ( i=0; i<NumPocLtCurr; i++, cIdx++)
509	{
510	rpsCurrList1[cIdx] = RefPicSetLtCurr[i];
511	}
512	assert(cIdx == numPocTotalCurr);
513	}
514
515	::memset(m_bIsUsedAsLongTerm, 0, sizeof(m_bIsUsedAsLongTerm));
516
517	for (Int rIdx = 0; rIdx < m_aiNumRefIdx[0]; rIdx ++)
518	{
519	cIdx = m_RefPicListModification.getRefPicListModificationFlagL0() ? m_RefPicListModification.getRefPicSetIdxL0(rIdx) : rIdx % numPocTotalCurr;
520	assert(cIdx >= 0 && cIdx < numPocTotalCurr);
521	m_apcRefPicList[0][rIdx] = rpsCurrList0[ cIdx ];
522	m_bIsUsedAsLongTerm[0][rIdx] = ( cIdx >= NumPocStCurr0 + NumPocStCurr1 );
523	}
524	if ( m_eSliceType != B_SLICE )
525	{
526	m_aiNumRefIdx[1] = 0;
527	::memset( m_apcRefPicList[1], 0, sizeof(m_apcRefPicList[1]));
528	}
529	else
530	{
531	for (Int rIdx = 0; rIdx < m_aiNumRefIdx[1]; rIdx ++)
532	{
533	cIdx = m_RefPicListModification.getRefPicListModificationFlagL1() ? m_RefPicListModification.getRefPicSetIdxL1(rIdx) : rIdx % numPocTotalCurr;
534	assert(cIdx >= 0 && cIdx < numPocTotalCurr);
535	m_apcRefPicList[1][rIdx] = rpsCurrList1[ cIdx ];
536	m_bIsUsedAsLongTerm[1][rIdx] = ( cIdx >= NumPocStCurr0 + NumPocStCurr1 );
537	}
538	}
539	}
540
541	#else
542	Void TComSlice::getTempRefPicLists( TComList<TComPic>& rcListPic, std::vector<TComPic>& refPicSetInterLayer0, std::vector<TComPic*>& refPicSetInterLayer1,
543	std::vector<TComPic*> rpsCurrList[2], std::vector<Bool> usedAsLongTerm[2], Int& numPocTotalCurr, Bool checkNumPocTotalCurr )
544	{
545	if (!checkNumPocTotalCurr)
546	{
547	if (m_eSliceType == I_SLICE)
548	{
549	return;
550	}
551	}
552
553	TComPic* pcRefPic= NULL;
554	TComPic* RefPicSetStCurr0[16];
555	TComPic* RefPicSetStCurr1[16];
556	TComPic* RefPicSetLtCurr[16];
557	UInt NumPocStCurr0 = 0;
558	UInt NumPocStCurr1 = 0;
559	UInt NumPocLtCurr = 0;
560	Int i;
561
562	for(i=0; i < m_pcRPS->getNumberOfNegativePictures(); i++)
563	{
564	if(m_pcRPS->getUsed(i))
565	{
566	pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
567	pcRefPic->setIsLongTerm(0);
568	pcRefPic->getPicYuvRec()->extendPicBorder();
569	RefPicSetStCurr0[NumPocStCurr0] = pcRefPic;
570	NumPocStCurr0++;
571	pcRefPic->setCheckLTMSBPresent(false);
572	}
573	}
574
575	for(; i < m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures(); i++)
576	{
577	if(m_pcRPS->getUsed(i))
578	{
579	pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
580	pcRefPic->setIsLongTerm(0);
581	pcRefPic->getPicYuvRec()->extendPicBorder();
582	RefPicSetStCurr1[NumPocStCurr1] = pcRefPic;
583	NumPocStCurr1++;
584	pcRefPic->setCheckLTMSBPresent(false);
585	}
586	}
587
588	for(i = m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()+m_pcRPS->getNumberOfLongtermPictures()-1; i > m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()-1 ; i--)
589	{
590	if(m_pcRPS->getUsed(i))
591	{
592	pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
593	pcRefPic->setIsLongTerm(1);
594	pcRefPic->getPicYuvRec()->extendPicBorder();
595	RefPicSetLtCurr[NumPocLtCurr] = pcRefPic;
596	NumPocLtCurr++;
597	}
598	if(pcRefPic==NULL)
599	{
600	pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
601	}
602	pcRefPic->setCheckLTMSBPresent(m_pcRPS->getCheckLTMSBPresent(i));
603	}
604
605	Int numPocInterCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr;
606	numPocTotalCurr = numPocInterCurr + getNumActiveRefLayerPics( );
607	assert( numPocTotalCurr == getNumRpsCurrTempList() );
608
609	if (checkNumPocTotalCurr)
610	{
611	// 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:
612	// - If nuh_layer_id is equal to 0 and the current picture is a BLA picture or a CRA picture, the value of NumPocTotalCurr shall be equal to 0.
613	// - Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
614	if ( getRapPicFlag() && m_layerId == 0 )
615	{
616	assert(numPocTotalCurr == 0);
617	}
618
619	if (m_eSliceType == I_SLICE)
620	{
621	::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
622	::memset( m_aiNumRefIdx, 0, sizeof ( m_aiNumRefIdx ));
623
624	return;
625	}
626
627	assert(numPocTotalCurr > 0);
628
629	m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
630	m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
631	}
632
633	std::vector<TComPic> refPicSetInterLayer[2] = { &refPicSetInterLayer0, &refPicSetInterLayer1};
634	Int numPocInterLayer[2] = { getNumActiveRefLayerPics0( ), getNumActiveRefLayerPics1( ) };
635
636	TComPic** refPicSetStCurr [2] = { RefPicSetStCurr0, RefPicSetStCurr1 };
637	Int numPocStCurr[2] = { NumPocStCurr0, NumPocStCurr1 };
638
639	for (Int li = 0; li < ((m_eSliceType==B_SLICE) ? 2 : 1); li++)
640	{
641	rpsCurrList [li].resize(MAX_NUM_REF+1,NULL );
642	usedAsLongTerm[li].resize(MAX_NUM_REF+1,false);
643
644	Int cIdx = 0;
645	for ( i=0; i < numPocStCurr[li]; i++, cIdx++)
646	{
647	rpsCurrList[li][cIdx] = refPicSetStCurr[li][i];
648	usedAsLongTerm [li][cIdx] = false;
649	}
650
651	for ( i=0; i < numPocInterLayer[li]; i++, cIdx++)
652	{
653	rpsCurrList[li][cIdx] = (*refPicSetInterLayer[li])[i];
654	usedAsLongTerm [li][cIdx] = true;
655	}
656
657	for ( i=0; i < numPocStCurr[1-li]; i++, cIdx++)
658	{
659	rpsCurrList[li][cIdx] = refPicSetStCurr[1-li][i];
660	usedAsLongTerm [li][cIdx] = false;
661	}
662
663	for ( i=0; i<NumPocLtCurr; i++, cIdx++)
664	{
665	rpsCurrList[li][cIdx] = RefPicSetLtCurr[i];
666	usedAsLongTerm [li][cIdx] = true;
667	}
668
669	for ( i=0; i < numPocInterLayer[1-li]; i++, cIdx++)
670	{
671	assert( cIdx < MAX_NUM_REF );
672	rpsCurrList[li][cIdx] = (*refPicSetInterLayer[1-li])[i];
673	usedAsLongTerm [li][cIdx] = true;
674	}
675
676	assert(cIdx == numPocTotalCurr);
677	}
678	}
679
680	Void TComSlice::setRefPicList( std::vector<TComPic*> rpsCurrList[2], std::vector<Bool> usedAsLongTerm[2], Int numPocTotalCurr, Bool checkNumPocTotalCurr )
681
682	{
683	if (!checkNumPocTotalCurr)
684	{
685	if (m_eSliceType == I_SLICE)
686	{
687	::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
688	::memset( m_aiNumRefIdx, 0, sizeof ( m_aiNumRefIdx ));
689
690	return;
691	}
692	}
693
694	::memset(m_bIsUsedAsLongTerm, 0, sizeof(m_bIsUsedAsLongTerm));
695
696	for (Int li = 0; li < 2; li++)
697	{
698	if ( m_eSliceType == P_SLICE && li == 1 )
699	{
700	m_aiNumRefIdx[1] = 0;
701	::memset( m_apcRefPicList[1], 0, sizeof(m_apcRefPicList[1]));
702	}
703	else
704	{
705	for (Int rIdx = 0; rIdx <= (m_aiNumRefIdx[ li ] - 1 ); rIdx ++)
706	{
707	Bool listModified = m_RefPicListModification.getRefPicListModificationFlagL( li );
708	Int orgIdx = listModified ? m_RefPicListModification.getRefPicSetIdxL(li, rIdx) : (rIdx % numPocTotalCurr);
709
710	assert( rpsCurrList[li][ orgIdx ] != NULL );
711	m_apcRefPicList [li][rIdx] = rpsCurrList [li][ orgIdx ];
712	m_bIsUsedAsLongTerm[li][rIdx] = usedAsLongTerm [li][ orgIdx ] ;
713	}
714	}
715	}
716	}
717	#endif
718	Int TComSlice::getNumRpsCurrTempList()
719	{
720	Int numRpsCurrTempList = 0;
721
722	if (m_eSliceType == I_SLICE)
723	{
724	return 0;
725	}
726	for(UInt i=0; i < m_pcRPS->getNumberOfNegativePictures()+ m_pcRPS->getNumberOfPositivePictures() + m_pcRPS->getNumberOfLongtermPictures(); i++)
727	{
728	if(m_pcRPS->getUsed(i))
729	{
730	numRpsCurrTempList++;
731	}
732	}
733	#if H_MV
734	numRpsCurrTempList = numRpsCurrTempList + getNumActiveRefLayerPics();
735	#endif
736	return numRpsCurrTempList;
737	}
738
739	Void TComSlice::initEqualRef()
740	{
741	for (Int iDir = 0; iDir < 2; iDir++)
742	{
743	for (Int iRefIdx1 = 0; iRefIdx1 < MAX_NUM_REF; iRefIdx1++)
744	{
745	for (Int iRefIdx2 = iRefIdx1; iRefIdx2 < MAX_NUM_REF; iRefIdx2++)
746	{
747	m_abEqualRef[iDir][iRefIdx1][iRefIdx2] = m_abEqualRef[iDir][iRefIdx2][iRefIdx1] = (iRefIdx1 == iRefIdx2? true : false);
748	}
749	}
750	}
751	}
752	#if H_3D
753	#if H_3D_TMVP
754	Void TComSlice::generateAlterRefforTMVP()
755	{
756	for ( UInt uiRefListIdx = 0; uiRefListIdx < 2; uiRefListIdx++ )
757	{
758	if ( this->getNumRefIdx( RefPicList( uiRefListIdx ) ) == 0)
759	{
760	continue;
761	}
762	Bool bZeroIdxLtFlag = this->getRefPic(RefPicList(uiRefListIdx), 0)->getIsLongTerm();
763	for(Int i = 1; i < this->getNumRefIdx(RefPicList(uiRefListIdx)); i++ )
764	{
765	if ( ( bZeroIdxLtFlag && !this->getRefPic(RefPicList(uiRefListIdx), i)->getIsLongTerm() ) \|\|
766	(!bZeroIdxLtFlag && this->getRefPic(RefPicList(uiRefListIdx), i)->getIsLongTerm() ) )
767	{
768	this->setAlterRefIdx(RefPicList(uiRefListIdx),i);
769	break;
770	}
771	}
772	}
773	}
774	#endif
775	Void TComSlice::setCamparaSlice( Int aaiScale, Int aaiOffset )
776	{
777	if( m_pcVPS->hasCamParInSliceHeader( m_viewIndex ) )
778	{
779	for( UInt uiBaseViewIndex = 0; uiBaseViewIndex < m_viewIndex; uiBaseViewIndex++ )
780	{
781	m_aaiCodedScale [ 0 ][ uiBaseViewIndex ] = aaiScale [ uiBaseViewIndex ][ m_viewIndex ];
782	m_aaiCodedScale [ 1 ][ uiBaseViewIndex ] = aaiScale [ m_viewIndex ][ uiBaseViewIndex ];
783	m_aaiCodedOffset[ 0 ][ uiBaseViewIndex ] = aaiOffset[ uiBaseViewIndex ][ m_viewIndex ];
784	m_aaiCodedOffset[ 1 ][ uiBaseViewIndex ] = aaiOffset[ m_viewIndex ][ uiBaseViewIndex ];
785	}
786	}
787	}
788	#endif
789
790	Void TComSlice::checkColRefIdx(UInt curSliceIdx, TComPic* pic)
791	{
792	Int i;
793	TComSlice* curSlice = pic->getSlice(curSliceIdx);
794	Int currColRefPOC = curSlice->getRefPOC( RefPicList(1-curSlice->getColFromL0Flag()), curSlice->getColRefIdx());
795	TComSlice* preSlice;
796	Int preColRefPOC;
797	for(i=curSliceIdx-1; i>=0; i--)
798	{
799	preSlice = pic->getSlice(i);
800	if(preSlice->getSliceType() != I_SLICE)
801	{
802	preColRefPOC = preSlice->getRefPOC( RefPicList(1-preSlice->getColFromL0Flag()), preSlice->getColRefIdx());
803	if(currColRefPOC != preColRefPOC)
804	{
805	printf("Collocated_ref_idx shall always be the same for all slices of a coded picture!\n");
806	exit(EXIT_FAILURE);
807	}
808	else
809	{
810	break;
811	}
812	}
813	}
814	}
815
816	Void TComSlice::checkCRA(TComReferencePictureSet pReferencePictureSet, Int& pocCRA, NalUnitType& associatedIRAPType, TComList<TComPic >& rcListPic)
817	{
818	for(Int i = 0; i < pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures(); i++)
819	{
820	if(pocCRA < MAX_UINT && getPOC() > pocCRA)
821	{
822	assert(getPOC()+pReferencePictureSet->getDeltaPOC(i) >= pocCRA);
823	}
824	}
825	for(Int i = pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures(); i < pReferencePictureSet->getNumberOfPictures(); i++)
826	{
827	if(pocCRA < MAX_UINT && getPOC() > pocCRA)
828	{
829	if (!pReferencePictureSet->getCheckLTMSBPresent(i))
830	{
831	assert(xGetLongTermRefPic(rcListPic, pReferencePictureSet->getPOC(i), false)->getPOC() >= pocCRA);
832	}
833	else
834	{
835	assert(pReferencePictureSet->getPOC(i) >= pocCRA);
836	}
837	}
838	}
839	if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL \|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ) // IDR picture found
840	{
841	pocCRA = getPOC();
842	associatedIRAPType = getNalUnitType();
843	}
844	else if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA ) // CRA picture found
845	{
846	pocCRA = getPOC();
847	associatedIRAPType = getNalUnitType();
848	}
849	else if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
850	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
851	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP ) // BLA picture found
852	{
853	pocCRA = getPOC();
854	associatedIRAPType = getNalUnitType();
855	}
856	}
857
858	/** Function for marking the reference pictures when an IDR/CRA/CRANT/BLA/BLANT is encountered.
859	* \param pocCRA POC of the CRA/CRANT/BLA/BLANT picture
860	* \param bRefreshPending flag indicating if a deferred decoding refresh is pending
861	* \param rcListPic reference to the reference picture list
862	* This function marks the reference pictures as "unused for reference" in the following conditions.
863	* If the nal_unit_type is IDR/BLA/BLANT, all pictures in the reference picture list
864	* are marked as "unused for reference"
865	* If the nal_unit_type is BLA/BLANT, set the pocCRA to the temporal reference of the current picture.
866	* Otherwise
867	* If the bRefreshPending flag is true (a deferred decoding refresh is pending) and the current
868	* temporal reference is greater than the temporal reference of the latest CRA/CRANT/BLA/BLANT picture (pocCRA),
869	* mark all reference pictures except the latest CRA/CRANT/BLA/BLANT picture as "unused for reference" and set
870	* the bRefreshPending flag to false.
871	* If the nal_unit_type is CRA/CRANT, set the bRefreshPending flag to true and pocCRA to the temporal
872	* reference of the current picture.
873	* Note that the current picture is already placed in the reference list and its marking is not changed.
874	* If the current picture has a nal_ref_idc that is not 0, it will remain marked as "used for reference".
875	*/
876	Void TComSlice::decodingRefreshMarking(Int& pocCRA, Bool& bRefreshPending, TComList<TComPic*>& rcListPic)
877	{
878	TComPic* rpcPic;
879	#if !FIX1172
880	setAssociatedIRAPPOC(pocCRA);
881	#endif
882	Int pocCurr = getPOC();
883
884	if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
885	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
886	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
887	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
888	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ) // IDR or BLA picture
889	{
890	// mark all pictures as not used for reference
891	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
892	while (iterPic != rcListPic.end())
893	{
894	rpcPic = *(iterPic);
895	rpcPic->setCurrSliceIdx(0);
896	if (rpcPic->getPOC() != pocCurr) rpcPic->getSlice(0)->setReferenced(false);
897	iterPic++;
898	}
899	if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
900	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
901	\|\| getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
902	{
903	pocCRA = pocCurr;
904	}
905	}
906	else // CRA or No DR
907	{
908	if (bRefreshPending==true && pocCurr > pocCRA) // CRA reference marking pending
909	{
910	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
911	while (iterPic != rcListPic.end())
912	{
913	rpcPic = *(iterPic);
914	if (rpcPic->getPOC() != pocCurr && rpcPic->getPOC() != pocCRA)
915	{
916	rpcPic->getSlice(0)->setReferenced(false);
917	}
918	iterPic++;
919	}
920	bRefreshPending = false;
921	}
922	if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA ) // CRA picture found
923	{
924	bRefreshPending = true;
925	pocCRA = pocCurr;
926	}
927	}
928	}
929
930	Void TComSlice::copySliceInfo(TComSlice *pSrc)
931	{
932	assert( pSrc != NULL );
933
934	Int i, j, k;
935
936	m_iPOC = pSrc->m_iPOC;
937	m_eNalUnitType = pSrc->m_eNalUnitType;
938	#if H_MV
939	m_layerId = pSrc->m_layerId;
940	// GT: Copying of several other values might be be missing here, or is above not necessary?
941	#endif
942	m_eSliceType = pSrc->m_eSliceType;
943	m_iSliceQp = pSrc->m_iSliceQp;
944	#if ADAPTIVE_QP_SELECTION
945	m_iSliceQpBase = pSrc->m_iSliceQpBase;
946	#endif
947	m_deblockingFilterDisable = pSrc->m_deblockingFilterDisable;
948	m_deblockingFilterOverrideFlag = pSrc->m_deblockingFilterOverrideFlag;
949	m_deblockingFilterBetaOffsetDiv2 = pSrc->m_deblockingFilterBetaOffsetDiv2;
950	m_deblockingFilterTcOffsetDiv2 = pSrc->m_deblockingFilterTcOffsetDiv2;
951
952	for (i = 0; i < 2; i++)
953	{
954	m_aiNumRefIdx[i] = pSrc->m_aiNumRefIdx[i];
955	}
956
957	for (i = 0; i < MAX_NUM_REF; i++)
958	{
959	m_list1IdxToList0Idx[i] = pSrc->m_list1IdxToList0Idx[i];
960	}
961	m_bCheckLDC = pSrc->m_bCheckLDC;
962	m_iSliceQpDelta = pSrc->m_iSliceQpDelta;
963	m_iSliceQpDeltaCb = pSrc->m_iSliceQpDeltaCb;
964	m_iSliceQpDeltaCr = pSrc->m_iSliceQpDeltaCr;
965	for (i = 0; i < 2; i++)
966	{
967	for (j = 0; j < MAX_NUM_REF; j++)
968	{
969	m_apcRefPicList[i][j] = pSrc->m_apcRefPicList[i][j];
970	m_aiRefPOCList[i][j] = pSrc->m_aiRefPOCList[i][j];
971	#if H_MV
972	m_aiRefLayerIdList[i][j] = pSrc->m_aiRefLayerIdList[i][j];
973	#endif
974	}
975	}
976	for (i = 0; i < 2; i++)
977	{
978	for (j = 0; j < MAX_NUM_REF + 1; j++)
979	{
980	m_bIsUsedAsLongTerm[i][j] = pSrc->m_bIsUsedAsLongTerm[i][j];
981	}
982	}
983	m_iDepth = pSrc->m_iDepth;
984
985	// referenced slice
986	m_bRefenced = pSrc->m_bRefenced;
987
988	// access channel
989	#if H_MV
990	m_pcVPS = pSrc->m_pcVPS;
991	#endif
992	m_pcSPS = pSrc->m_pcSPS;
993	m_pcPPS = pSrc->m_pcPPS;
994	m_pcRPS = pSrc->m_pcRPS;
995	m_iLastIDR = pSrc->m_iLastIDR;
996
997	m_pcPic = pSrc->m_pcPic;
998
999	m_colFromL0Flag = pSrc->m_colFromL0Flag;
1000	m_colRefIdx = pSrc->m_colRefIdx;
1001	setLambdas(pSrc->getLambdas());
1002	for (i = 0; i < 2; i++)
1003	{
1004	for (j = 0; j < MAX_NUM_REF; j++)
1005	{
1006	for (k =0; k < MAX_NUM_REF; k++)
1007	{
1008	m_abEqualRef[i][j][k] = pSrc->m_abEqualRef[i][j][k];
1009	}
1010	}
1011	}
1012
1013	m_uiTLayer = pSrc->m_uiTLayer;
1014	m_bTLayerSwitchingFlag = pSrc->m_bTLayerSwitchingFlag;
1015
1016	m_sliceMode = pSrc->m_sliceMode;
1017	m_sliceArgument = pSrc->m_sliceArgument;
1018	m_sliceCurStartCUAddr = pSrc->m_sliceCurStartCUAddr;
1019	m_sliceCurEndCUAddr = pSrc->m_sliceCurEndCUAddr;
1020	m_sliceIdx = pSrc->m_sliceIdx;
1021	m_sliceSegmentMode = pSrc->m_sliceSegmentMode;
1022	m_sliceSegmentArgument = pSrc->m_sliceSegmentArgument;
1023	m_sliceSegmentCurStartCUAddr = pSrc->m_sliceSegmentCurStartCUAddr;
1024	m_sliceSegmentCurEndCUAddr = pSrc->m_sliceSegmentCurEndCUAddr;
1025	m_nextSlice = pSrc->m_nextSlice;
1026	m_nextSliceSegment = pSrc->m_nextSliceSegment;
1027	for ( Int e=0 ; e<2 ; e++ )
1028	{
1029	for ( Int n=0 ; n<MAX_NUM_REF ; n++ )
1030	{
1031	memcpy(m_weightPredTable[e][n], pSrc->m_weightPredTable[e][n], sizeof(wpScalingParam)*3 );
1032	}
1033	}
1034	m_saoEnabledFlag = pSrc->m_saoEnabledFlag;
1035	m_saoEnabledFlagChroma = pSrc->m_saoEnabledFlagChroma;
1036	m_cabacInitFlag = pSrc->m_cabacInitFlag;
1037	m_numEntryPointOffsets = pSrc->m_numEntryPointOffsets;
1038
1039	m_bLMvdL1Zero = pSrc->m_bLMvdL1Zero;
1040	m_LFCrossSliceBoundaryFlag = pSrc->m_LFCrossSliceBoundaryFlag;
1041	m_enableTMVPFlag = pSrc->m_enableTMVPFlag;
1042	m_maxNumMergeCand = pSrc->m_maxNumMergeCand;
1043
1044	#if H_MV
1045	// Additional slice header syntax elements
1046	#if !H_MV_HLS7_GEN
1047	m_pocResetFlag = pSrc->m_pocResetFlag;
1048	#endif
1049	m_discardableFlag = pSrc->m_discardableFlag;
1050	m_interLayerPredEnabledFlag = pSrc->m_interLayerPredEnabledFlag;
1051	m_numInterLayerRefPicsMinus1 = pSrc->m_numInterLayerRefPicsMinus1;
1052
1053	for (Int layer = 0; layer < MAX_NUM_LAYERS; layer++ )
1054	{
1055	m_interLayerPredLayerIdc[ layer ] = pSrc->m_interLayerPredLayerIdc[ layer ];
1056	}
1057	#endif
1058	#if H_3D_IC
1059	m_bApplyIC = pSrc->m_bApplyIC;
1060	m_icSkipParseFlag = pSrc->m_icSkipParseFlag;
1061	#endif
1062	}
1063
1064	Int TComSlice::m_prevTid0POC = 0;
1065
1066	/** Function for setting the slice's temporal layer ID and corresponding temporal_layer_switching_point_flag.
1067	* \param uiTLayer Temporal layer ID of the current slice
1068	* The decoder calls this function to set temporal_layer_switching_point_flag for each temporal layer based on
1069	* the SPS's temporal_id_nesting_flag and the parsed PPS. Then, current slice's temporal layer ID and
1070	* temporal_layer_switching_point_flag is set accordingly.
1071	*/
1072	Void TComSlice::setTLayerInfo( UInt uiTLayer )
1073	{
1074	m_uiTLayer = uiTLayer;
1075	}
1076
1077	/** Function for checking if this is a switching-point
1078	*/
1079	Bool TComSlice::isTemporalLayerSwitchingPoint( TComList<TComPic*>& rcListPic )
1080	{
1081	TComPic* rpcPic;
1082	// loop through all pictures in the reference picture buffer
1083	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1084	while ( iterPic != rcListPic.end())
1085	{
1086	rpcPic = *(iterPic++);
1087	if(rpcPic->getSlice(0)->isReferenced() && rpcPic->getPOC() != getPOC())
1088	{
1089	if(rpcPic->getTLayer() >= getTLayer())
1090	{
1091	return false;
1092	}
1093	}
1094	}
1095	return true;
1096	}
1097
1098	/** Function for checking if this is a STSA candidate
1099	*/
1100	Bool TComSlice::isStepwiseTemporalLayerSwitchingPointCandidate( TComList<TComPic*>& rcListPic )
1101	{
1102	TComPic* rpcPic;
1103
1104	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1105	while ( iterPic != rcListPic.end())
1106	{
1107	rpcPic = *(iterPic++);
1108	if(rpcPic->getSlice(0)->isReferenced() && (rpcPic->getUsedByCurr()==true) && rpcPic->getPOC() != getPOC())
1109	{
1110	if(rpcPic->getTLayer() >= getTLayer())
1111	{
1112	return false;
1113	}
1114	}
1115	}
1116	return true;
1117	}
1118
1119
1120	Void TComSlice::checkLeadingPictureRestrictions(TComList<TComPic*>& rcListPic)
1121	{
1122	TComPic* rpcPic;
1123
1124	Int nalUnitType = this->getNalUnitType();
1125
1126	// When a picture is a leading picture, it shall be a RADL or RASL picture.
1127	if(this->getAssociatedIRAPPOC() > this->getPOC())
1128	{
1129	// Do not check IRAP pictures since they may get a POC lower than their associated IRAP
1130	if(nalUnitType < NAL_UNIT_CODED_SLICE_BLA_W_LP \|\|
1131	nalUnitType > NAL_UNIT_RESERVED_IRAP_VCL23)
1132	{
1133	assert(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N \|\|
1134	nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R \|\|
1135	nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N \|\|
1136	nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R);
1137	}
1138	}
1139
1140	// When a picture is a trailing picture, it shall not be a RADL or RASL picture.
1141	if(this->getAssociatedIRAPPOC() < this->getPOC())
1142	{
1143	assert(nalUnitType != NAL_UNIT_CODED_SLICE_RASL_N &&
1144	nalUnitType != NAL_UNIT_CODED_SLICE_RASL_R &&
1145	nalUnitType != NAL_UNIT_CODED_SLICE_RADL_N &&
1146	nalUnitType != NAL_UNIT_CODED_SLICE_RADL_R);
1147	}
1148
1149	// No RASL pictures shall be present in the bitstream that are associated
1150	// with a BLA picture having nal_unit_type equal to BLA_W_RADL or BLA_N_LP.
1151	if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N \|\|
1152	nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1153	{
1154	assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_W_RADL &&
1155	this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_N_LP);
1156	}
1157
1158	// No RASL pictures shall be present in the bitstream that are associated with
1159	// an IDR picture.
1160	if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N \|\|
1161	nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1162	{
1163	assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_N_LP &&
1164	this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_W_RADL);
1165	}
1166
1167	// No RADL pictures shall be present in the bitstream that are associated with
1168	// a BLA picture having nal_unit_type equal to BLA_N_LP or that are associated
1169	// with an IDR picture having nal_unit_type equal to IDR_N_LP.
1170	if(nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N \|\|
1171	nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R)
1172	{
1173	assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_N_LP &&
1174	this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_N_LP);
1175	}
1176
1177	// loop through all pictures in the reference picture buffer
1178	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1179	while ( iterPic != rcListPic.end())
1180	{
1181	rpcPic = *(iterPic++);
1182	#if BUGFIX_INTRAPERIOD
1183	if(!rpcPic->getReconMark())
1184	{
1185	continue;
1186	}
1187	#endif
1188	if (rpcPic->getPOC() == this->getPOC())
1189	{
1190	continue;
1191	}
1192
1193	// Any picture that has PicOutputFlag equal to 1 that precedes an IRAP picture
1194	// in decoding order shall precede the IRAP picture in output order.
1195	// (Note that any picture following in output order would be present in the DPB)
1196	if(rpcPic->getSlice(0)->getPicOutputFlag() == 1)
1197	{
1198	if(nalUnitType == NAL_UNIT_CODED_SLICE_BLA_N_LP \|\|
1199	nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_LP \|\|
1200	nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_RADL \|\|
1201	nalUnitType == NAL_UNIT_CODED_SLICE_CRA \|\|
1202	nalUnitType == NAL_UNIT_CODED_SLICE_IDR_N_LP \|\|
1203	nalUnitType == NAL_UNIT_CODED_SLICE_IDR_W_RADL)
1204	{
1205	assert(rpcPic->getPOC() < this->getPOC());
1206	}
1207	}
1208
1209	// Any picture that has PicOutputFlag equal to 1 that precedes an IRAP picture
1210	// in decoding order shall precede any RADL picture associated with the IRAP
1211	// picture in output order.
1212	if(rpcPic->getSlice(0)->getPicOutputFlag() == 1)
1213	{
1214	if((nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N \|\|
1215	nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R))
1216	{
1217	// rpcPic precedes the IRAP in decoding order
1218	if(this->getAssociatedIRAPPOC() > rpcPic->getSlice(0)->getAssociatedIRAPPOC())
1219	{
1220	// rpcPic must not be the IRAP picture
1221	if(this->getAssociatedIRAPPOC() != rpcPic->getPOC())
1222	{
1223	assert(rpcPic->getPOC() < this->getPOC());
1224	}
1225	}
1226	}
1227	}
1228
1229	// When a picture is a leading picture, it shall precede, in decoding order,
1230	// all trailing pictures that are associated with the same IRAP picture.
1231	if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N \|\|
1232	nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R \|\|
1233	nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N \|\|
1234	nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R)
1235	{
1236	if(rpcPic->getSlice(0)->getAssociatedIRAPPOC() == this->getAssociatedIRAPPOC())
1237	{
1238	// rpcPic is a picture that preceded the leading in decoding order since it exist in the DPB
1239	// rpcPic would violate the constraint if it was a trailing picture
1240	assert(rpcPic->getPOC() <= this->getAssociatedIRAPPOC());
1241	}
1242	}
1243
1244	// Any RASL picture associated with a CRA or BLA picture shall precede any
1245	// RADL picture associated with the CRA or BLA picture in output order
1246	if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N \|\|
1247	nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1248	{
1249	if((this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_N_LP \|\|
1250	this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_W_LP \|\|
1251	this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL \|\|
1252	this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_CRA) &&
1253	this->getAssociatedIRAPPOC() == rpcPic->getSlice(0)->getAssociatedIRAPPOC())
1254	{
1255	if(rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N \|\|
1256	rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_R)
1257	{
1258	assert(rpcPic->getPOC() > this->getPOC());
1259	}
1260	}
1261	}
1262
1263	// Any RASL picture associated with a CRA picture shall follow, in output
1264	// order, any IRAP picture that precedes the CRA picture in decoding order.
1265	if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N \|\|
1266	nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
1267	{
1268	if(this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_CRA)
1269	{
1270	if(rpcPic->getSlice(0)->getPOC() < this->getAssociatedIRAPPOC() &&
1271	(rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP \|\|
1272	rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP \|\|
1273	rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL \|\|
1274	rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP \|\|
1275	rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL \|\|
1276	rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA))
1277	{
1278	assert(this->getPOC() > rpcPic->getSlice(0)->getPOC());
1279	}
1280	}
1281	}
1282	}
1283	}
1284
1285
1286
1287	/** Function for applying picture marking based on the Reference Picture Set in pReferencePictureSet.
1288	*/
1289	Void TComSlice::applyReferencePictureSet( TComList<TComPic>& rcListPic, TComReferencePictureSet pReferencePictureSet)
1290	{
1291	TComPic* rpcPic;
1292	Int i, isReference;
1293
1294	checkLeadingPictureRestrictions(rcListPic);
1295
1296	// loop through all pictures in the reference picture buffer
1297	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1298	while ( iterPic != rcListPic.end())
1299	{
1300	rpcPic = *(iterPic++);
1301
1302	if(!rpcPic->getSlice( 0 )->isReferenced())
1303	{
1304	continue;
1305	}
1306
1307	isReference = 0;
1308	// loop through all pictures in the Reference Picture Set
1309	// to see if the picture should be kept as reference picture
1310	for(i=0;i<pReferencePictureSet->getNumberOfPositivePictures()+pReferencePictureSet->getNumberOfNegativePictures();i++)
1311	{
1312	if(!rpcPic->getIsLongTerm() && rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i))
1313	{
1314	isReference = 1;
1315	rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1316	rpcPic->setIsLongTerm(0);
1317	}
1318	}
1319	for(;i<pReferencePictureSet->getNumberOfPictures();i++)
1320	{
1321	if(pReferencePictureSet->getCheckLTMSBPresent(i)==true)
1322	{
1323	if(rpcPic->getIsLongTerm() && (rpcPic->getPicSym()->getSlice(0)->getPOC()) == pReferencePictureSet->getPOC(i))
1324	{
1325	isReference = 1;
1326	rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1327	}
1328	}
1329	else
1330	{
1331	Int pocCycle = 1<<rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
1332	Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC() & (pocCycle-1);
1333	Int refPoc = pReferencePictureSet->getPOC(i) & (pocCycle-1);
1334	if(rpcPic->getIsLongTerm() && curPoc == refPoc)
1335	{
1336	isReference = 1;
1337	rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
1338	}
1339	}
1340
1341	}
1342	#if H_MV_HLS_7_MISC_P0130_20
1343	if( isReference ) // Current picture is in the temporal RPS
1344	{
1345	assert( rpcPic->getSlice(0)->getDiscardableFlag() == 0 ); // Temporal RPS shall not contain picture with discardable_flag equal to 1
1346	}
1347	#endif
1348	// mark the picture as "unused for reference" if it is not in
1349	// the Reference Picture Set
1350	if(rpcPic->getPicSym()->getSlice(0)->getPOC() != this->getPOC() && isReference == 0)
1351	{
1352	rpcPic->getSlice( 0 )->setReferenced( false );
1353	rpcPic->setUsedByCurr(0);
1354	rpcPic->setIsLongTerm(0);
1355	}
1356	//check that pictures of higher temporal layers are not used
1357	assert(rpcPic->getSlice( 0 )->isReferenced()==0\|\|rpcPic->getUsedByCurr()==0\|\|rpcPic->getTLayer()<=this->getTLayer());
1358	//check that pictures of higher or equal temporal layer are not in the RPS if the current picture is a TSA picture
1359	if(this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_R \|\| this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N)
1360	{
1361	assert(rpcPic->getSlice( 0 )->isReferenced()==0\|\|rpcPic->getTLayer()<this->getTLayer());
1362	}
1363	//check that pictures marked as temporal layer non-reference pictures are not used for reference
1364	if(rpcPic->getPicSym()->getSlice(0)->getPOC() != this->getPOC() && rpcPic->getTLayer()==this->getTLayer())
1365	{
1366	assert(rpcPic->getSlice( 0 )->isReferenced()==0\|\|rpcPic->getUsedByCurr()==0\|\|rpcPic->getSlice( 0 )->getTemporalLayerNonReferenceFlag()==false);
1367	}
1368	}
1369	}
1370
1371	/** Function for applying picture marking based on the Reference Picture Set in pReferencePictureSet.
1372	*/
1373	Int TComSlice::checkThatAllRefPicsAreAvailable( TComList<TComPic>& rcListPic, TComReferencePictureSet pReferencePictureSet, Bool printErrors, Int pocRandomAccess)
1374	{
1375	TComPic* rpcPic;
1376	Int i, isAvailable;
1377	Int atLeastOneLost = 0;
1378	Int atLeastOneRemoved = 0;
1379	Int iPocLost = 0;
1380
1381	// loop through all long-term pictures in the Reference Picture Set
1382	// to see if the picture should be kept as reference picture
1383	for(i=pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();i<pReferencePictureSet->getNumberOfPictures();i++)
1384	{
1385	isAvailable = 0;
1386	// loop through all pictures in the reference picture buffer
1387	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1388	while ( iterPic != rcListPic.end())
1389	{
1390	rpcPic = *(iterPic++);
1391	if(pReferencePictureSet->getCheckLTMSBPresent(i)==true)
1392	{
1393	if(rpcPic->getIsLongTerm() && (rpcPic->getPicSym()->getSlice(0)->getPOC()) == pReferencePictureSet->getPOC(i) && rpcPic->getSlice(0)->isReferenced())
1394	{
1395	isAvailable = 1;
1396	}
1397	}
1398	else
1399	{
1400	Int pocCycle = 1<<rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
1401	Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC() & (pocCycle-1);
1402	Int refPoc = pReferencePictureSet->getPOC(i) & (pocCycle-1);
1403	if(rpcPic->getIsLongTerm() && curPoc == refPoc && rpcPic->getSlice(0)->isReferenced())
1404	{
1405	isAvailable = 1;
1406	}
1407	}
1408	}
1409	// if there was no such long-term check the short terms
1410	if(!isAvailable)
1411	{
1412	iterPic = rcListPic.begin();
1413	while ( iterPic != rcListPic.end())
1414	{
1415	rpcPic = *(iterPic++);
1416
1417	Int pocCycle = 1 << rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
1418	Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC();
1419	Int refPoc = pReferencePictureSet->getPOC(i);
1420	if (!pReferencePictureSet->getCheckLTMSBPresent(i))
1421	{
1422	curPoc = curPoc & (pocCycle - 1);
1423	refPoc = refPoc & (pocCycle - 1);
1424	}
1425
1426	if (rpcPic->getSlice(0)->isReferenced() && curPoc == refPoc)
1427	{
1428	isAvailable = 1;
1429	rpcPic->setIsLongTerm(1);
1430	break;
1431	}
1432	}
1433	}
1434	// report that a picture is lost if it is in the Reference Picture Set
1435	// but not available as reference picture
1436	if(isAvailable == 0)
1437	{
1438	if (this->getPOC() + pReferencePictureSet->getDeltaPOC(i) >= pocRandomAccess)
1439	{
1440	if(!pReferencePictureSet->getUsed(i) )
1441	{
1442	if(printErrors)
1443	{
1444	printf("\nLong-term reference picture with POC = %3d seems to have been removed or not correctly decoded.", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1445	}
1446	atLeastOneRemoved = 1;
1447	}
1448	else
1449	{
1450	if(printErrors)
1451	{
1452	printf("\nLong-term reference picture with POC = %3d is lost or not correctly decoded!", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1453	}
1454	atLeastOneLost = 1;
1455	iPocLost=this->getPOC() + pReferencePictureSet->getDeltaPOC(i);
1456	}
1457	}
1458	}
1459	}
1460	// loop through all short-term pictures in the Reference Picture Set
1461	// to see if the picture should be kept as reference picture
1462	for(i=0;i<pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();i++)
1463	{
1464	isAvailable = 0;
1465	// loop through all pictures in the reference picture buffer
1466	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1467	while ( iterPic != rcListPic.end())
1468	{
1469	rpcPic = *(iterPic++);
1470
1471	if(!rpcPic->getIsLongTerm() && rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i) && rpcPic->getSlice(0)->isReferenced())
1472	{
1473	isAvailable = 1;
1474	}
1475	}
1476	// report that a picture is lost if it is in the Reference Picture Set
1477	// but not available as reference picture
1478	if(isAvailable == 0)
1479	{
1480	if (this->getPOC() + pReferencePictureSet->getDeltaPOC(i) >= pocRandomAccess)
1481	{
1482	if(!pReferencePictureSet->getUsed(i) )
1483	{
1484	if(printErrors)
1485	{
1486	printf("\nShort-term reference picture with POC = %3d seems to have been removed or not correctly decoded.", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1487	}
1488	atLeastOneRemoved = 1;
1489	}
1490	else
1491	{
1492	if(printErrors)
1493	{
1494	printf("\nShort-term reference picture with POC = %3d is lost or not correctly decoded!", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
1495	}
1496	atLeastOneLost = 1;
1497	iPocLost=this->getPOC() + pReferencePictureSet->getDeltaPOC(i);
1498	}
1499	}
1500	}
1501	}
1502	if(atLeastOneLost)
1503	{
1504	return iPocLost+1;
1505	}
1506	if(atLeastOneRemoved)
1507	{
1508	return -2;
1509	}
1510	else
1511	{
1512	return 0;
1513	}
1514	}
1515
1516	/** Function for constructing an explicit Reference Picture Set out of the available pictures in a referenced Reference Picture Set
1517	*/
1518	Void TComSlice::createExplicitReferencePictureSetFromReference( TComList<TComPic>& rcListPic, TComReferencePictureSet pReferencePictureSet, Bool isRAP)
1519	{
1520	TComPic* rpcPic;
1521	Int i, j;
1522	Int k = 0;
1523	Int nrOfNegativePictures = 0;
1524	Int nrOfPositivePictures = 0;
1525	TComReferencePictureSet* pcRPS = this->getLocalRPS();
1526
1527	// loop through all pictures in the Reference Picture Set
1528	for(i=0;i<pReferencePictureSet->getNumberOfPictures();i++)
1529	{
1530	j = 0;
1531	// loop through all pictures in the reference picture buffer
1532	TComList<TComPic*>::iterator iterPic = rcListPic.begin();
1533	while ( iterPic != rcListPic.end())
1534	{
1535	j++;
1536	rpcPic = *(iterPic++);
1537
1538	if(rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i) && rpcPic->getSlice(0)->isReferenced())
1539	{
1540	// This picture exists as a reference picture
1541	// and should be added to the explicit Reference Picture Set
1542	pcRPS->setDeltaPOC(k, pReferencePictureSet->getDeltaPOC(i));
1543	pcRPS->setUsed(k, pReferencePictureSet->getUsed(i) && (!isRAP));
1544	if(pcRPS->getDeltaPOC(k) < 0)
1545	{
1546	nrOfNegativePictures++;
1547	}
1548	else
1549	{
1550	nrOfPositivePictures++;
1551	}
1552	k++;
1553	}
1554	}
1555	}
1556	pcRPS->setNumberOfNegativePictures(nrOfNegativePictures);
1557	pcRPS->setNumberOfPositivePictures(nrOfPositivePictures);
1558	pcRPS->setNumberOfPictures(nrOfNegativePictures+nrOfPositivePictures);
1559	// This is a simplistic inter rps example. A smarter encoder will look for a better reference RPS to do the
1560	// inter RPS prediction with. Here we just use the reference used by pReferencePictureSet.
1561	// If pReferencePictureSet is not inter_RPS_predicted, then inter_RPS_prediction is for the current RPS also disabled.
1562	if (!pReferencePictureSet->getInterRPSPrediction())
1563	{
1564	pcRPS->setInterRPSPrediction(false);
1565	pcRPS->setNumRefIdc(0);
1566	}
1567	else
1568	{
1569	Int rIdx = this->getRPSidx() - pReferencePictureSet->getDeltaRIdxMinus1() - 1;
1570	Int deltaRPS = pReferencePictureSet->getDeltaRPS();
1571	TComReferencePictureSet* pcRefRPS = this->getSPS()->getRPSList()->getReferencePictureSet(rIdx);
1572	Int iRefPics = pcRefRPS->getNumberOfPictures();
1573	Int iNewIdc=0;
1574	for(i=0; i<= iRefPics; i++)
1575	{
1576	Int deltaPOC = ((i != iRefPics)? pcRefRPS->getDeltaPOC(i) : 0); // check if the reference abs POC is >= 0
1577	Int iRefIdc = 0;
1578	for (j=0; j < pcRPS->getNumberOfPictures(); j++) // loop through the pictures in the new RPS
1579	{
1580	if ( (deltaPOC + deltaRPS) == pcRPS->getDeltaPOC(j))
1581	{
1582	if (pcRPS->getUsed(j))
1583	{
1584	iRefIdc = 1;
1585	}
1586	else
1587	{
1588	iRefIdc = 2;
1589	}
1590	}
1591	}
1592	pcRPS->setRefIdc(i, iRefIdc);
1593	iNewIdc++;
1594	}
1595	pcRPS->setInterRPSPrediction(true);
1596	pcRPS->setNumRefIdc(iNewIdc);
1597	pcRPS->setDeltaRPS(deltaRPS);
1598	pcRPS->setDeltaRIdxMinus1(pReferencePictureSet->getDeltaRIdxMinus1() + this->getSPS()->getRPSList()->getNumberOfReferencePictureSets() - this->getRPSidx());
1599	}
1600
1601	this->setRPS(pcRPS);
1602	this->setRPSidx(-1);
1603	}
1604
1605	/** get AC and DC values for weighted pred
1606	* \param *wp
1607	* \returns Void
1608	*/
1609	Void TComSlice::getWpAcDcParam(wpACDCParam *&wp)
1610	{
1611	wp = m_weightACDCParam;
1612	}
1613
1614	/** init AC and DC values for weighted pred
1615	* \returns Void
1616	*/
1617	Void TComSlice::initWpAcDcParam()
1618	{
1619	for(Int iComp = 0; iComp < 3; iComp++ )
1620	{
1621	m_weightACDCParam[iComp].iAC = 0;
1622	m_weightACDCParam[iComp].iDC = 0;
1623	}
1624	}
1625
1626	/** get WP tables for weighted pred
1627	* \param RefPicList
1628	* \param iRefIdx
1629	* \param *&wpScalingParam
1630	* \returns Void
1631	*/
1632	Void TComSlice::getWpScaling( RefPicList e, Int iRefIdx, wpScalingParam *&wp )
1633	{
1634	wp = m_weightPredTable[e][iRefIdx];
1635	}
1636
1637	/** reset Default WP tables settings : no weight.
1638	* \param wpScalingParam
1639	* \returns Void
1640	*/
1641	Void TComSlice::resetWpScaling()
1642	{
1643	for ( Int e=0 ; e<2 ; e++ )
1644	{
1645	for ( Int i=0 ; i<MAX_NUM_REF ; i++ )
1646	{
1647	for ( Int yuv=0 ; yuv<3 ; yuv++ )
1648	{
1649	wpScalingParam *pwp = &(m_weightPredTable[e][i][yuv]);
1650	pwp->bPresentFlag = false;
1651	pwp->uiLog2WeightDenom = 0;
1652	pwp->uiLog2WeightDenom = 0;
1653	pwp->iWeight = 1;
1654	pwp->iOffset = 0;
1655	}
1656	}
1657	}
1658	}
1659
1660	/** init WP table
1661	* \returns Void
1662	*/
1663	Void TComSlice::initWpScaling()
1664	{
1665	for ( Int e=0 ; e<2 ; e++ )
1666	{
1667	for ( Int i=0 ; i<MAX_NUM_REF ; i++ )
1668	{
1669	for ( Int yuv=0 ; yuv<3 ; yuv++ )
1670	{
1671	wpScalingParam *pwp = &(m_weightPredTable[e][i][yuv]);
1672	if ( !pwp->bPresentFlag )
1673	{
1674	// Inferring values not present :
1675	pwp->iWeight = (1 << pwp->uiLog2WeightDenom);
1676	pwp->iOffset = 0;
1677	}
1678
1679	pwp->w = pwp->iWeight;
1680	Int bitDepth = yuv ? g_bitDepthC : g_bitDepthY;
1681	pwp->o = pwp->iOffset << (bitDepth-8);
1682	pwp->shift = pwp->uiLog2WeightDenom;
1683	pwp->round = (pwp->uiLog2WeightDenom>=1) ? (1 << (pwp->uiLog2WeightDenom-1)) : (0);
1684	}
1685	}
1686	}
1687	}
1688
1689	// ------------------------------------------------------------------------------------------------
1690	// Video parameter set (VPS)
1691	// ------------------------------------------------------------------------------------------------
1692	TComVPS::TComVPS()
1693	: m_VPSId ( 0)
1694	, m_uiMaxTLayers ( 1)
1695	#if H_MV
1696	, m_uiMaxLayersMinus1 ( 0)
1697	#else
1698	, m_uiMaxLayers ( 1)
1699	#endif
1700	, m_bTemporalIdNestingFlag (false)
1701	, m_numHrdParameters ( 0)
1702	#if H_MV
1703	, m_maxLayerId ( 0)
1704	#else
1705	, m_maxNuhReservedZeroLayerId ( 0)
1706	#endif
1707	, m_hrdParameters (NULL)
1708	, m_hrdOpSetIdx (NULL)
1709	, m_cprmsPresentFlag (NULL)
1710	#if H_MV
1711	, m_dpbSize (NULL)
1712	, m_vpsVUI ( NULL )
1713	#endif
1714	{
1715	for( Int i = 0; i < MAX_TLAYER; i++)
1716	{
1717	m_numReorderPics[i] = 0;
1718	m_uiMaxDecPicBuffering[i] = 1;
1719	m_uiMaxLatencyIncrease[i] = 0;
1720	}
1721	#if H_MV
1722	for (Int lsIdx = 0; lsIdx < MAX_VPS_OP_SETS_PLUS1; lsIdx++ )
1723	{
1724	for( Int layerId = 0; layerId < MAX_VPS_NUH_LAYER_ID_PLUS1; layerId++ )
1725	{
1726	m_layerIdIncludedFlag[lsIdx][layerId] = (( lsIdx == 0 ) && ( layerId == 0 )) ;
1727	}
1728	}
1729	#if !H_MV_HLS_7_OUTPUT_LAYERS_5_10_22_27
1730	m_vpsNumberLayerSetsMinus1 = -1;
1731	#endif
1732	m_vpsNumProfileTierLevelMinus1 = -1;
1733
1734	#if !H_MV_HLS_7_OUTPUT_LAYERS_5_10_22_27
1735	for ( Int i = 0; i < MAX_VPS_PROFILE_TIER_LEVEL; i++)
1736	{
1737	#if !H_MV_HLS_7_VPS_P0048_14
1738	m_profileRefMinus1[ i ] = -1;
1739	#endif
1740	}
1741
1742	m_moreOutputLayerSetsThanDefaultFlag = false;
1743	m_numAddOutputLayerSetsMinus1 = -1;
1744	m_defaultOneTargetOutputLayerIdc = 0;
1745	#else
1746	m_numAddOutputLayerSets = -1;
1747	m_defaultTargetOutputLayerIdc = 0;
1748	#endif
1749
1750	for ( Int i = 0; i < MAX_VPS_OUTPUTLAYER_SETS; i++)
1751	{
1752	m_outputLayerSetIdxMinus1[i] = -1;
1753	m_profileLevelTierIdx[i] = 0;
1754	for ( Int j = 0; j < MAX_VPS_NUH_LAYER_ID_PLUS1; j++)
1755	{
1756	m_outputLayerFlag[i][j] = false;
1757	}
1758	#if H_MV_HLS_7_OUTPUT_LAYERS_5_10_22_27
1759	m_altOutputLayerFlag[ i ] = false;
1760	#endif
1761	}
1762	#if !H_MV_HLS_7_OUTPUT_LAYERS_5_10_22_27
1763	m_altOutputLayerFlag = false;
1764	#endif
1765	m_maxOneActiveRefLayerFlag = false;
1766	m_directDepTypeLenMinus2 = 0;
1767
1768
1769	m_avcBaseLayerFlag = false;
1770	#if H_MV_HLS_7_VPS_P0307_23
1771	m_vpsNonVuiExtensionLength = 0;
1772	#else
1773	m_vpsVuiOffset = 0;
1774	#endif
1775	m_splittingFlag = false;
1776
1777	for( Int i = 0; i < MAX_NUM_SCALABILITY_TYPES; i++ )
1778	{
1779	m_scalabilityMaskFlag[i] = false;
1780	m_dimensionIdLen [i] = -1;
1781	}
1782
1783	m_vpsNuhLayerIdPresentFlag = false;
1784
1785	for( Int i = 0; i < MAX_VPS_OP_SETS_PLUS1; i++ )
1786	{
1787	m_vpsProfilePresentFlag [i] = false;
1788	#if !H_MV_HLS_7_VPS_P0048_14
1789	m_profileRefMinus1[i] = 0;
1790	#endif
1791	m_outputLayerSetIdxMinus1 [i] = 0;
1792	for( Int j = 0; j < MAX_VPS_NUH_LAYER_ID_PLUS1; j++ )
1793	{
1794	m_outputLayerFlag[i][j] = false;
1795	}
1796	}
1797
1798	for( Int i = 0; i < MAX_NUM_LAYER_IDS; i++ )
1799	{
1800	m_layerIdInVps[i] = (i == 0 ) ? 0 : -1;
1801	}
1802
1803	for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
1804	{
1805	m_layerIdInNuh [i] = ( i == 0 ) ? 0 : -1;
1806	m_numDirectRefLayers[i] = 0;
1807	m_vpsRepFormatIdx [i] = 0;
1808	m_pocLsbNotPresentFlag[i] = 0;
1809	m_repFormat [i] = NULL;
1810	m_viewIdVal [i] = 0;
1811
1812	#if H_3D
1813	m_viewIndex [i] = -1;
1814	m_vpsDepthModesFlag [i] = false;
1815	m_ivMvScalingFlag = true;
1816	#endif
1817
1818	for( Int j = 0; j < MAX_NUM_LAYERS; j++ )
1819	{
1820	m_directDependencyFlag[i][j] = false;
1821	m_directDependencyType[i][j] = -1;
1822	m_refLayerId[i][j] = -1;
1823	m_maxTidIlRefPicsPlus1[i][j] = 7;
1824	}
1825
1826	for( Int j = 0; j < MAX_NUM_SCALABILITY_TYPES; j++ )
1827	{
1828	m_dimensionId[i][j] = 0;
1829	}
1830	#if H_3D_ARP
1831	m_uiUseAdvResPred[i] = 0;
1832	m_uiARPStepNum[i] = 1;
1833	#endif
1834	}
1835	m_vpsVUI = new TComVPSVUI;
1836	m_dpbSize = new TComDpbSize;
1837
1838	#if H_3D
1839	for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
1840	{
1841	#if H_3D_IV_MERGE
1842	m_ivMvPredFlag [ i ] = false;
1843	#if H_3D_SPIVMP
1844	m_iSubPULog2Size [ i ] = 0;
1845	#endif
1846	#endif
1847	#if H_3D_VSP
1848	m_viewSynthesisPredFlag[ i ] = false;
1849	#endif
1850	#if H_3D_NBDV_REF
1851	m_depthRefinementFlag [ i ] = false;
1852	#endif
1853	#if H_3D_INTER_SDC
1854	m_bInterSDCFlag [ i ] = false;
1855	#endif
1856	#if H_3D_DBBP
1857	m_dbbpFlag [ i ] = false;
1858	#endif
1859	#if H_3D_IV_MERGE
1860	m_bMPIFlag [ i ] = false;
1861	#endif
1862	}
1863	#endif
1864	#endif
1865	}
1866
1867	TComVPS::~TComVPS()
1868	{
1869	if( m_hrdParameters != NULL ) delete[] m_hrdParameters;
1870	if( m_hrdOpSetIdx != NULL ) delete[] m_hrdOpSetIdx;
1871	if( m_cprmsPresentFlag != NULL ) delete[] m_cprmsPresentFlag;
1872	#if H_MV
1873	if ( m_vpsVUI != NULL ) delete m_vpsVUI;
1874	if ( m_dpbSize != NULL ) delete m_dpbSize;
1875
1876	for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
1877	{
1878	if (m_repFormat[ i ] != NULL ) delete m_repFormat[ i ];
1879	}
1880	#endif
1881	#if H_3D
1882	deleteCamPars();
1883	#endif
1884	}
1885
1886	#if H_MV
1887
1888	Bool TComVPS::checkVPSExtensionSyntax()
1889	{
1890	for( Int layer = 1; layer <= getMaxLayersMinus1(); layer++ )
1891	{
1892	// check layer_id_in_nuh constraint
1893	assert( getLayerIdInNuh( layer ) > getLayerIdInNuh( layer -1 ) );
1894	}
1895	return true;
1896	}
1897
1898	Int TComVPS::getNumScalabilityTypes()
1899	{
1900	return scalTypeToScalIdx( ScalabilityType(MAX_NUM_SCALABILITY_TYPES) );
1901	}
1902
1903	Int TComVPS::scalTypeToScalIdx( ScalabilityType scalType )
1904	{
1905	assert( scalType >= 0 && scalType <= MAX_NUM_SCALABILITY_TYPES );
1906	assert( scalType == MAX_NUM_SCALABILITY_TYPES \|\| getScalabilityMaskFlag( scalType ) );
1907	Int scalIdx = 0;
1908	for( Int curScalType = 0; curScalType < scalType; curScalType++ )
1909	{
1910	scalIdx += ( getScalabilityMaskFlag( curScalType ) ? 1 : 0 );
1911
1912	}
1913
1914	return scalIdx;
1915	}
1916	Void TComVPS::setScalabilityMaskFlag( UInt val )
1917	{
1918	for ( Int scalType = 0; scalType < MAX_NUM_SCALABILITY_TYPES; scalType++ )
1919	{
1920	setScalabilityMaskFlag( scalType, ( val & (1 << scalType ) ) != 0 );
1921	}
1922	}
1923
1924	Void TComVPS::setRefLayers()
1925	{
1926	for( Int i = 0; i <= getMaxLayersMinus1(); i++ )
1927	{
1928	Int iNuhLId = getLayerIdInNuh( i );
1929	m_numDirectRefLayers[ iNuhLId ] = 0;
1930	for( Int j = 0; j < i; j++ )
1931	{
1932	if( getDirectDependencyFlag(i , j) )
1933	{
1934	m_refLayerId[ iNuhLId ][m_numDirectRefLayers[ iNuhLId ]++ ] = getLayerIdInNuh( j );
1935	}
1936	}
1937	}
1938	}
1939
1940	Int TComVPS::getRefLayerId( Int layerIdInNuh, Int idx )
1941	{
1942	assert( idx >= 0 && idx < m_numDirectRefLayers[layerIdInNuh] );
1943	Int refLayerIdInNuh = m_refLayerId[ layerIdInNuh ][ idx ];
1944	assert ( refLayerIdInNuh >= 0 );
1945	return refLayerIdInNuh;
1946	}
1947
1948	Int TComVPS::getScalabilityId( Int layerIdInVps, ScalabilityType scalType )
1949	{
1950	return getScalabilityMaskFlag( scalType ) ? getDimensionId( layerIdInVps, scalTypeToScalIdx( scalType ) ) : 0;
1951	}
1952
1953	#if H_3D
1954	Int TComVPS::getLayerIdInNuh( Int viewIndex, Bool depthFlag )
1955	{
1956	Int foundLayerIdinNuh = -1;
1957
1958	for (Int layerIdInVps = 0 ; layerIdInVps <= getMaxLayersMinus1(); layerIdInVps++ )
1959	{
1960	Int layerIdInNuh = getLayerIdInNuh( layerIdInVps );
1961	if( ( getViewIndex( layerIdInNuh ) == viewIndex ) && ( getDepthId( layerIdInNuh ) == ( depthFlag ? 1 : 0 ) ) )
1962	{
1963	foundLayerIdinNuh = layerIdInNuh;
1964	break;
1965	}
1966	}
1967	assert( foundLayerIdinNuh != -1 );
1968
1969	return foundLayerIdinNuh;
1970	}
1971
1972	Void TComVPS::createCamPars(Int iNumViews)
1973	{
1974	Int i = 0, j = 0;
1975
1976	m_bCamParPresent = new Bool[ iNumViews ];
1977	m_bCamParInSliceHeader = new Bool[ iNumViews ];
1978
1979	m_aaaiCodedScale = new Int**[ iNumViews ];
1980	m_aaaiCodedOffset = new Int**[ iNumViews ];
1981	for ( i = 0; i < iNumViews ; i++ )
1982	{
1983	m_bCamParInSliceHeader[i] = false;
1984	m_aaaiCodedScale[i] = new Int*[ 2 ];
1985	m_aaaiCodedOffset[i] = new Int*[ 2 ];
1986	for ( j = 0; j < 2; j++ )
1987	{
1988	m_aaaiCodedScale[i][j] = new Int[ MAX_NUM_LAYERS ];
1989	m_aaaiCodedOffset[i][j] = new Int[ MAX_NUM_LAYERS ];
1990	for ( Int k = 0; k < MAX_NUM_LAYERS; k++ )
1991	{
1992	m_aaaiCodedScale[i][j][k] = 0;
1993	m_aaaiCodedOffset[i][j][k] = 0;
1994	}
1995	}
1996	}
1997	}
1998
1999	Void TComVPS::deleteCamPars()
2000	{
2001	Int iNumViews = getNumViews();
2002	Int i = 0, j = 0;
2003
2004	if ( m_bCamParPresent != NULL )
2005	{
2006	delete [] m_bCamParPresent;
2007	}
2008	if ( m_bCamParInSliceHeader != NULL )
2009	{
2010	delete [] m_bCamParInSliceHeader;
2011	}
2012
2013	if ( m_aaaiCodedScale != NULL )
2014	{
2015	for ( i = 0; i < iNumViews ; i++ )
2016	{
2017	for ( j = 0; j < 2; j++ )
2018	{
2019	delete [] m_aaaiCodedScale[i][j];
2020	}
2021	delete [] m_aaaiCodedScale[i];
2022	}
2023	delete [] m_aaaiCodedScale;
2024	}
2025
2026	if ( m_aaaiCodedOffset != NULL )
2027	{
2028	for ( i = 0; i < iNumViews ; i++ )
2029	{
2030	for ( j = 0; j < 2; j++ )
2031	{
2032	delete [] m_aaaiCodedOffset[i][j];
2033	}
2034	delete [] m_aaaiCodedOffset[i];
2035	}
2036	delete [] m_aaaiCodedOffset;
2037	}
2038	}
2039
2040
2041	Void
2042	TComVPS::initCamParaVPS( UInt uiViewIndex, Bool bCamParPresent, UInt uiCamParPrecision, Bool bCamParSlice, Int aaiScale, Int aaiOffset )
2043	{
2044	AOT( uiViewIndex != 0 && !bCamParSlice && ( aaiScale == 0 \|\| aaiOffset == 0 ) );
2045
2046	m_uiCamParPrecision = ( ( uiViewIndex != 0 )? uiCamParPrecision : 0 );
2047	m_bCamParPresent[ uiViewIndex ] = (( uiViewIndex != 0 )? bCamParPresent : false );
2048	m_bCamParInSliceHeader[ uiViewIndex ] = ( (uiViewIndex != 0)? bCamParSlice : false );
2049
2050	if( !m_bCamParInSliceHeader[ uiViewIndex ] )
2051	{
2052	for( UInt uiBaseViewIndex = 0; uiBaseViewIndex < uiViewIndex; uiBaseViewIndex++ )
2053	{
2054	m_aaaiCodedScale [ uiViewIndex ][ 0 ][ uiBaseViewIndex ] = aaiScale [ uiBaseViewIndex ][ uiViewIndex ];
2055	m_aaaiCodedScale [ uiViewIndex ][ 1 ][ uiBaseViewIndex ] = aaiScale [ uiViewIndex ][ uiBaseViewIndex ];
2056	m_aaaiCodedOffset[ uiViewIndex ][ 0 ][ uiBaseViewIndex ] = aaiOffset[ uiBaseViewIndex ][ uiViewIndex ];
2057	m_aaaiCodedOffset[ uiViewIndex ][ 1 ][ uiBaseViewIndex ] = aaiOffset[ uiViewIndex ][ uiBaseViewIndex ];
2058	}
2059	}
2060	}
2061
2062	#endif // H_3D
2063
2064
2065	Int TComVPS::xGetDimBitOffset( Int j )
2066	{
2067	Int dimBitOffset = 0;
2068	if ( getSplittingFlag() && j == getNumScalabilityTypes() )
2069	{
2070	dimBitOffset = 6;
2071	}
2072	else
2073	{
2074	for (Int dimIdx = 0; dimIdx <= j-1; dimIdx++)
2075	{
2076	dimBitOffset += getDimensionIdLen( dimIdx );
2077	}
2078	}
2079	return dimBitOffset;
2080	}
2081
2082	Int TComVPS::inferDimensionId( Int i, Int j )
2083	{
2084	return ( ( getLayerIdInNuh( i ) & ( (1 << xGetDimBitOffset( j + 1 ) ) - 1) ) >> xGetDimBitOffset( j ) );
2085	}
2086
2087	Int TComVPS::inferLastDimsionIdLenMinus1()
2088	{
2089	return ( 5 - xGetDimBitOffset( getNumScalabilityTypes() - 1 ) );
2090	}
2091
2092	Int TComVPS::getNumLayersInIdList( Int lsIdx )
2093	{
2094	assert( lsIdx >= 0 );
2095	assert( lsIdx <= getVpsNumLayerSetsMinus1() );
2096	return (Int) m_layerSetLayerIdList[ lsIdx ].size();
2097	}
2098
2099	Int TComVPS::getNumOutputLayerSets()
2100	{
2101	#if H_MV_HLS_7_OUTPUT_LAYERS_5_10_22_27
2102	return getNumAddOutputLayerSets() + getVpsNumLayerSetsMinus1() + 1;
2103	#else
2104	Int numOutputLayerSets = getVpsNumberLayerSetsMinus1( ) + 1;
2105	if ( getMoreOutputLayerSetsThanDefaultFlag( ) )
2106	{
2107	numOutputLayerSets += (getNumAddOutputLayerSetsMinus1( ) + 1);
2108	}
2109	return numOutputLayerSets;
2110	#endif
2111	}
2112
2113	Int TComVPS::getNumViews()
2114	{
2115	Int numViews = 1;
2116	for( Int i = 0; i <= getMaxLayersMinus1(); i++ )
2117	{
2118	Int lId = getLayerIdInNuh( i );
2119	if ( i > 0 && ( getViewIndex( lId ) != getScalabilityId( i - 1, VIEW_ORDER_INDEX ) ) )
2120	{
2121	numViews++;
2122	}
2123	}
2124
2125	return numViews;
2126	}
2127
2128	Bool TComVPS::getInDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps, Int depth /= 0 / )
2129	{
2130	assert( depth < 65 );
2131	Bool dependentFlag = getDirectDependencyFlag( depLayeridInVps, refLayeridInVps );
2132
2133	for( Int i = 0; i < depLayeridInVps && !dependentFlag; i++ )
2134	{
2135	if ( getDirectDependencyFlag( depLayeridInVps, i ) )
2136	{
2137	dependentFlag = getInDirectDependencyFlag( i, refLayeridInVps, depth++ );
2138	}
2139	}
2140	return dependentFlag;
2141	}
2142
2143	Void TComVPS::deriveLayerSetLayerIdList()
2144	{
2145	m_layerSetLayerIdList.resize( getVpsNumLayerSetsMinus1() + 1 );
2146	for (Int i = 0; i <= getVpsNumLayerSetsMinus1(); i++ )
2147	{
2148	for( Int m = 0; m <= getVpsMaxLayerId(); m++ )
2149	{
2150	if( getLayerIdIncludedFlag( i, m) )
2151	{
2152	m_layerSetLayerIdList[ i ].push_back( m );
2153	}
2154	}
2155	}
2156	}
2157
2158	#if H_MV_HLS_7_OUTPUT_LAYERS_5_10_22_27
2159	Void TComVPS::initTargetLayerIdLists()
2160	{
2161	m_targetDecLayerIdLists.resize( getNumOutputLayerSets() );
2162	m_targetOptLayerIdLists.resize( getNumOutputLayerSets() );
2163	}
2164
2165	Void TComVPS::deriveTargetLayerIdList( Int i )
2166	{
2167	Int lsIdx = getLayerSetIdxForOutputLayerSet( i );
2168
2169	for( Int j = 0; j < getNumLayersInIdList( lsIdx ); j++ )
2170	{
2171	m_targetDecLayerIdLists[i].push_back( m_layerSetLayerIdList[ lsIdx ][ j ] );
2172	if( getOutputLayerFlag( i, j ))
2173	{
2174	m_targetOptLayerIdLists[i].push_back( m_layerSetLayerIdList[ lsIdx ][ j ] );
2175	}
2176	}
2177	}
2178	#else
2179	Void TComVPS::deriveTargetLayerIdLists()
2180	{
2181	m_targetDecLayerIdLists.resize( getNumOutputLayerSets() );
2182	m_targetOptLayerIdLists.resize( getNumOutputLayerSets() );
2183
2184	for (Int targetOptLayerSetIdx = 0; targetOptLayerSetIdx < getNumOutputLayerSets(); targetOptLayerSetIdx++ )
2185	{
2186	Int targetDecLayerSetIdx = getOutputLayerSetIdxMinus1( targetOptLayerSetIdx ) + 1;
2187	Int lsIdx = targetDecLayerSetIdx;
2188
2189	for( Int j = 0; j < getNumLayersInIdList( lsIdx ); j++ )
2190	{
2191	m_targetDecLayerIdLists[targetOptLayerSetIdx].push_back( m_layerSetLayerIdList[ lsIdx ][ j ] );
2192	if( getOutputLayerFlag( targetOptLayerSetIdx, j )) // This seems to be wrong in draft text
2193	{
2194	m_targetOptLayerIdLists[targetOptLayerSetIdx].push_back( m_layerSetLayerIdList[ lsIdx ][ j ] );
2195	}
2196	}
2197	}
2198	}
2199	#endif
2200
2201	#endif // H_MV
2202
2203	// ------------------------------------------------------------------------------------------------
2204	// Sequence parameter set (SPS)
2205	// ------------------------------------------------------------------------------------------------
2206
2207	TComSPS::TComSPS()
2208	: m_SPSId ( 0)
2209	, m_VPSId ( 0)
2210	, m_chromaFormatIdc (CHROMA_420)
2211	, m_uiMaxTLayers ( 1)
2212	// Structure
2213	, m_picWidthInLumaSamples (352)
2214	, m_picHeightInLumaSamples (288)
2215	, m_log2MinCodingBlockSize ( 0)
2216	, m_log2DiffMaxMinCodingBlockSize (0)
2217	, m_uiMaxCUWidth ( 32)
2218	, m_uiMaxCUHeight ( 32)
2219	, m_uiMaxCUDepth ( 3)
2220	, m_bLongTermRefsPresent (false)
2221	, m_uiQuadtreeTULog2MaxSize ( 0)
2222	, m_uiQuadtreeTULog2MinSize ( 0)
2223	, m_uiQuadtreeTUMaxDepthInter ( 0)
2224	, m_uiQuadtreeTUMaxDepthIntra ( 0)
2225	// Tool list
2226	, m_usePCM (false)
2227	, m_pcmLog2MaxSize ( 5)
2228	, m_uiPCMLog2MinSize ( 7)
2229	#if H_3D_QTLPC
2230	, m_bUseQTL (false)
2231	, m_bUsePC (false)
2232	#endif
2233	, m_bitDepthY ( 8)
2234	, m_bitDepthC ( 8)
2235	, m_qpBDOffsetY ( 0)
2236	, m_qpBDOffsetC ( 0)
2237	, m_uiPCMBitDepthLuma ( 8)
2238	, m_uiPCMBitDepthChroma ( 8)
2239	, m_bPCMFilterDisableFlag (false)
2240	, m_uiBitsForPOC ( 8)
2241	, m_numLongTermRefPicSPS ( 0)
2242	, m_uiMaxTrSize ( 32)
2243	, m_bUseSAO (false)
2244	, m_bTemporalIdNestingFlag (false)
2245	, m_scalingListEnabledFlag (false)
2246	, m_useStrongIntraSmoothing (false)
2247	, m_vuiParametersPresentFlag (false)
2248	, m_vuiParameters ()
2249	#if H_MV
2250	, m_pcVPS ( NULL )
2251	, m_spsInferScalingListFlag ( false )
2252	, m_spsScalingListRefLayerId ( 0 )
2253
2254	, m_updateRepFormatFlag ( false )
2255	, m_spsRepFormatIdx ( 0 )
2256	, m_interViewMvVertConstraintFlag (false)
2257	#endif
2258	#if H_3D
2259	, m_bCamParInSliceHeader (false)
2260	#endif
2261	{
2262	for ( Int i = 0; i < MAX_TLAYER; i++ )
2263	{
2264	m_uiMaxLatencyIncrease[i] = 0;
2265	m_uiMaxDecPicBuffering[i] = 1;
2266	m_numReorderPics[i] = 0;
2267	}
2268	m_scalingList = new TComScalingList;
2269	::memset(m_ltRefPicPocLsbSps, 0, sizeof(m_ltRefPicPocLsbSps));
2270	::memset(m_usedByCurrPicLtSPSFlag, 0, sizeof(m_usedByCurrPicLtSPSFlag));
2271	#if H_MV
2272	m_spsExtensionFlag = false;
2273	for( Int i = 0; i < PS_EX_T_MAX_NUM; i++ )
2274	{
2275	m_spsExtensionTypeFlag[ i ] = false;
2276	}
2277	m_numScaledRefLayerOffsets = 0;
2278
2279	for (Int i = 0; i < MAX_NUM_SCALED_REF_LAYERS; i++ )
2280	{
2281	m_scaledRefLayerId [i] = -1;
2282	}
2283
2284	for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
2285	{
2286	m_scaledRefLayerLeftOffset [i] = 0;
2287	m_scaledRefLayerTopOffset [i] = 0;
2288	m_scaledRefLayerRightOffset [i] = 0;
2289	m_scaledRefLayerBottomOffset [i] = 0;
2290	}
2291	#endif
2292	}
2293
2294	TComSPS::~TComSPS()
2295	{
2296	delete m_scalingList;
2297	m_RPSList.destroy();
2298	}
2299
2300	Void TComSPS::createRPSList( Int numRPS )
2301	{
2302	m_RPSList.destroy();
2303	m_RPSList.create(numRPS);
2304	}
2305
2306	Void TComSPS::setHrdParameters( UInt frameRate, UInt numDU, UInt bitRate, Bool randomAccess )
2307	{
2308	if( !getVuiParametersPresentFlag() )
2309	{
2310	return;
2311	}
2312
2313	TComVUI *vui = getVuiParameters();
2314	TComHRD *hrd = vui->getHrdParameters();
2315
2316	TimingInfo *timingInfo = vui->getTimingInfo();
2317	timingInfo->setTimingInfoPresentFlag( true );
2318	switch( frameRate )
2319	{
2320	case 24:
2321	timingInfo->setNumUnitsInTick( 1125000 ); timingInfo->setTimeScale ( 27000000 );
2322	break;
2323	case 25:
2324	timingInfo->setNumUnitsInTick( 1080000 ); timingInfo->setTimeScale ( 27000000 );
2325	break;
2326	case 30:
2327	timingInfo->setNumUnitsInTick( 900900 ); timingInfo->setTimeScale ( 27000000 );
2328	break;
2329	case 50:
2330	timingInfo->setNumUnitsInTick( 540000 ); timingInfo->setTimeScale ( 27000000 );
2331	break;
2332	case 60:
2333	timingInfo->setNumUnitsInTick( 450450 ); timingInfo->setTimeScale ( 27000000 );
2334	break;
2335	default:
2336	timingInfo->setNumUnitsInTick( 1001 ); timingInfo->setTimeScale ( 60000 );
2337	break;
2338	}
2339
2340	Bool rateCnt = ( bitRate > 0 );
2341	hrd->setNalHrdParametersPresentFlag( rateCnt );
2342	hrd->setVclHrdParametersPresentFlag( rateCnt );
2343
2344	hrd->setSubPicCpbParamsPresentFlag( ( numDU > 1 ) );
2345
2346	if( hrd->getSubPicCpbParamsPresentFlag() )
2347	{
2348	hrd->setTickDivisorMinus2( 100 - 2 ); //
2349	hrd->setDuCpbRemovalDelayLengthMinus1( 7 ); // 8-bit precision ( plus 1 for last DU in AU )
2350	hrd->setSubPicCpbParamsInPicTimingSEIFlag( true );
2351	hrd->setDpbOutputDelayDuLengthMinus1( 5 + 7 ); // With sub-clock tick factor of 100, at least 7 bits to have the same value as AU dpb delay
2352	}
2353	else
2354	{
2355	hrd->setSubPicCpbParamsInPicTimingSEIFlag( false );
2356	}
2357
2358	hrd->setBitRateScale( 4 ); // in units of 2~( 6 + 4 ) = 1,024 bps
2359	hrd->setCpbSizeScale( 6 ); // in units of 2~( 4 + 4 ) = 1,024 bit
2360	hrd->setDuCpbSizeScale( 6 ); // in units of 2~( 4 + 4 ) = 1,024 bit
2361
2362	hrd->setInitialCpbRemovalDelayLengthMinus1(15); // assuming 0.5 sec, log2( 90,000 * 0.5 ) = 16-bit
2363	if( randomAccess )
2364	{
2365	hrd->setCpbRemovalDelayLengthMinus1(5); // 32 = 2^5 (plus 1)
2366	hrd->setDpbOutputDelayLengthMinus1 (5); // 32 + 3 = 2^6
2367	}
2368	else
2369	{
2370	hrd->setCpbRemovalDelayLengthMinus1(9); // max. 2^10
2371	hrd->setDpbOutputDelayLengthMinus1 (9); // max. 2^10
2372	}
2373
2374	/*
2375	Note: only the case of "vps_max_temporal_layers_minus1 = 0" is supported.
2376	*/
2377	Int i, j;
2378	UInt birateValue, cpbSizeValue;
2379	UInt ducpbSizeValue;
2380	UInt duBitRateValue = 0;
2381
2382	for( i = 0; i < MAX_TLAYER; i ++ )
2383	{
2384	hrd->setFixedPicRateFlag( i, 1 );
2385	hrd->setPicDurationInTcMinus1( i, 0 );
2386	hrd->setLowDelayHrdFlag( i, 0 );
2387	hrd->setCpbCntMinus1( i, 0 );
2388
2389	birateValue = bitRate;
2390	cpbSizeValue = bitRate; // 1 second
2391	ducpbSizeValue = bitRate/numDU;
2392	duBitRateValue = bitRate;
2393	for( j = 0; j < ( hrd->getCpbCntMinus1( i ) + 1 ); j ++ )
2394	{
2395	hrd->setBitRateValueMinus1( i, j, 0, ( birateValue - 1 ) );
2396	hrd->setCpbSizeValueMinus1( i, j, 0, ( cpbSizeValue - 1 ) );
2397	hrd->setDuCpbSizeValueMinus1( i, j, 0, ( ducpbSizeValue - 1 ) );
2398	hrd->setCbrFlag( i, j, 0, ( j == 0 ) );
2399
2400	hrd->setBitRateValueMinus1( i, j, 1, ( birateValue - 1) );
2401	hrd->setCpbSizeValueMinus1( i, j, 1, ( cpbSizeValue - 1 ) );
2402	hrd->setDuCpbSizeValueMinus1( i, j, 1, ( ducpbSizeValue - 1 ) );
2403	hrd->setDuBitRateValueMinus1( i, j, 1, ( duBitRateValue - 1 ) );
2404	hrd->setCbrFlag( i, j, 1, ( j == 0 ) );
2405	}
2406	}
2407	}
2408	const Int TComSPS::m_winUnitX[]={1,2,2,1};
2409	const Int TComSPS::m_winUnitY[]={1,2,1,1};
2410
2411	TComPPS::TComPPS()
2412	: m_PPSId (0)
2413	, m_SPSId (0)
2414	, m_picInitQPMinus26 (0)
2415	, m_useDQP (false)
2416	, m_bConstrainedIntraPred (false)
2417	, m_bSliceChromaQpFlag (false)
2418	, m_pcSPS (NULL)
2419	, m_uiMaxCuDQPDepth (0)
2420	, m_uiMinCuDQPSize (0)
2421	, m_chromaCbQpOffset (0)
2422	, m_chromaCrQpOffset (0)
2423	, m_numRefIdxL0DefaultActive (1)
2424	, m_numRefIdxL1DefaultActive (1)
2425	, m_TransquantBypassEnableFlag (false)
2426	, m_useTransformSkip (false)
2427	, m_dependentSliceSegmentsEnabledFlag (false)
2428	, m_tilesEnabledFlag (false)
2429	, m_entropyCodingSyncEnabledFlag (false)
2430	, m_loopFilterAcrossTilesEnabledFlag (true)
2431	, m_uniformSpacingFlag (0)
2432	, m_iNumColumnsMinus1 (0)
2433	, m_puiColumnWidth (NULL)
2434	, m_iNumRowsMinus1 (0)
2435	, m_puiRowHeight (NULL)
2436	, m_iNumSubstreams (1)
2437	, m_signHideFlag(0)
2438	, m_cabacInitPresentFlag (false)
2439	, m_encCABACTableIdx (I_SLICE)
2440	, m_sliceHeaderExtensionPresentFlag (false)
2441	, m_loopFilterAcrossSlicesEnabledFlag (false)
2442	, m_listsModificationPresentFlag( 0)
2443	, m_numExtraSliceHeaderBits(0)
2444	#if H_MV
2445	, m_ppsInferScalingListFlag(false)
2446	, m_ppsScalingListRefLayerId(0)
2447	#if H_MV_HLS_7_POC_P0041
2448	, m_pocResetInfoPresentFlag(false)
2449	#endif
2450	#if H_3D
2451	, m_pcDLT(NULL)
2452	#endif
2453	#endif
2454	{
2455	m_scalingList = new TComScalingList;
2456
2457	#if H_MV_HLS_7_GEN_P0166_PPS_EXTENSION
2458	for( Int i = 0; i < PS_EX_T_MAX_NUM; i++ )
2459	{
2460	m_ppsExtensionTypeFlag[ i ] = false;
2461	}
2462	#endif
2463
2464	}
2465
2466	TComPPS::~TComPPS()
2467	{
2468	if( m_iNumColumnsMinus1 > 0 && m_uniformSpacingFlag == 0 )
2469	{
2470	if (m_puiColumnWidth) delete [] m_puiColumnWidth;
2471	m_puiColumnWidth = NULL;
2472	}
2473	if( m_iNumRowsMinus1 > 0 && m_uniformSpacingFlag == 0 )
2474	{
2475	if (m_puiRowHeight) delete [] m_puiRowHeight;
2476	m_puiRowHeight = NULL;
2477	}
2478	delete m_scalingList;
2479	}
2480
2481	#if H_3D
2482	TComDLT::TComDLT()
2483	: m_bDltPresentFlag(false)
2484	, m_iNumDepthViews(0)
2485	, m_uiDepthViewBitDepth(8)
2486	{
2487	m_uiDepthViewBitDepth = g_bitDepthY;
2488
2489	for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
2490	{
2491	m_bUseDLTFlag [i] = false;
2492	m_bInterViewDltPredEnableFlag [i] = false;
2493
2494	// allocate some memory and initialize with default mapping
2495	m_iNumDepthmapValues[i] = ((1 << m_uiDepthViewBitDepth)-1)+1;
2496	m_iBitsPerDepthValue[i] = numBitsForValue(m_iNumDepthmapValues[i]);
2497
2498	m_iDepthValue2Idx[i] = (Int*) xMalloc(Int, m_iNumDepthmapValues[i]);
2499	m_iIdx2DepthValue[i] = (Int*) xMalloc(Int, m_iNumDepthmapValues[i]);
2500
2501	//default mapping
2502	for (Int d=0; d<m_iNumDepthmapValues[i]; d++)
2503	{
2504	m_iDepthValue2Idx[i][d] = d;
2505	m_iIdx2DepthValue[i][d] = d;
2506	}
2507	}
2508	}
2509
2510	TComDLT::~TComDLT()
2511	{
2512	for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
2513	{
2514	if ( m_iDepthValue2Idx[i] != NULL )
2515	{
2516	xFree( m_iDepthValue2Idx[i] );
2517	m_iDepthValue2Idx[i] = NULL;
2518	}
2519
2520	if ( m_iIdx2DepthValue[i] != NULL )
2521	{
2522	xFree( m_iIdx2DepthValue[i] );
2523	m_iIdx2DepthValue[i] = NULL;
2524	}
2525	}
2526	}
2527
2528	Void TComDLT::setDepthLUTs(Int layerIdInVps, Int* idxToDepthValueTable, Int iNumDepthValues)
2529	{
2530	if( idxToDepthValueTable == NULL \|\| iNumDepthValues == 0 ) // default mapping only
2531	return;
2532
2533	// copy idx2DepthValue to internal array
2534	memcpy(m_iIdx2DepthValue[layerIdInVps], idxToDepthValueTable, iNumDepthValues*sizeof(UInt));
2535
2536	UInt uiMaxDepthValue = ((1 << g_bitDepthY)-1);
2537	for(Int p=0; p<=uiMaxDepthValue; p++)
2538	{
2539	Int iIdxDown = 0;
2540	Int iIdxUp = iNumDepthValues-1;
2541	Bool bFound = false;
2542
2543	// iterate over indices to find lower closest depth
2544	Int i = 1;
2545	while(!bFound && i<iNumDepthValues)
2546	{
2547	if( m_iIdx2DepthValue[layerIdInVps][i] > p )
2548	{
2549	iIdxDown = i-1;
2550	bFound = true;
2551	}
2552
2553	i++;
2554	}
2555	// iterate over indices to find upper closest depth
2556	i = iNumDepthValues-2;
2557	bFound = false;
2558	while(!bFound && i>=0)
2559	{
2560	if( m_iIdx2DepthValue[layerIdInVps][i] < p )
2561	{
2562	iIdxUp = i+1;
2563	bFound = true;
2564	}
2565
2566	i--;
2567	}
2568
2569	// assert monotony
2570	assert(iIdxDown<=iIdxUp);
2571
2572	// assign closer depth value/idx
2573	if( abs(p-m_iIdx2DepthValue[layerIdInVps][iIdxDown]) < abs(p-m_iIdx2DepthValue[layerIdInVps][iIdxUp]) )
2574	{
2575	m_iDepthValue2Idx[layerIdInVps][p] = iIdxDown;
2576	}
2577	else
2578	{
2579	m_iDepthValue2Idx[layerIdInVps][p] = iIdxUp;
2580	}
2581
2582	}
2583
2584	// update DLT variables
2585	m_iNumDepthmapValues[layerIdInVps] = iNumDepthValues;
2586	m_iBitsPerDepthValue[layerIdInVps] = numBitsForValue(m_iNumDepthmapValues[layerIdInVps]);
2587	}
2588
2589	#if H_3D_DELTA_DLT
2590	Void TComDLT::getDeltaDLT( Int layerIdInVps, Int* piDLTInRef, UInt uiDLTInRefNum, Int* piDeltaDLTOut, UInt *puiDeltaDLTOutNum )
2591	{
2592	Bool abBM0[ 256 ];
2593	Bool abBM1[ 256 ];
2594
2595	memset( abBM0, 0, sizeof( abBM0 ));
2596	memset( abBM1, 0, sizeof( abBM1 ));
2597
2598	// convert reference DLT to bit string
2599	for( Int i = 0; i < uiDLTInRefNum; i++ )
2600	{
2601	abBM0[ piDLTInRef[ i ] ] = true;
2602	}
2603	// convert internal DLT to bit string
2604	for( Int i = 0; i < m_iNumDepthmapValues[ layerIdInVps ]; i++ )
2605	{
2606	abBM1[ m_iIdx2DepthValue[ layerIdInVps ][ i ] ] = true;
2607	}
2608
2609	*puiDeltaDLTOutNum = 0;
2610	for( Int i = 0; i < 256; i++ )
2611	{
2612	if( abBM0[ i ] ^ abBM1[ i ] )
2613	{
2614	piDeltaDLTOut[ *puiDeltaDLTOutNum ] = i;
2615	puiDeltaDLTOutNum = puiDeltaDLTOutNum + 1;
2616	}
2617	}
2618	}
2619
2620	Void TComDLT::setDeltaDLT( Int layerIdInVps, Int* piDLTInRef, UInt uiDLTInRefNum, Int* piDeltaDLTIn, UInt uiDeltaDLTInNum )
2621	{
2622	Bool abBM0[ 256 ];
2623	Bool abBM1[ 256 ];
2624
2625	memset( abBM0, 0, sizeof( abBM0 ));
2626	memset( abBM1, 0, sizeof( abBM1 ));
2627
2628	// convert reference DLT to bit string
2629	for( Int i = 0; i < uiDLTInRefNum; i++ )
2630	{
2631	abBM0[ piDLTInRef[ i ] ] = true;
2632	}
2633	// convert delta DLT to bit string
2634	for( Int i = 0; i < uiDeltaDLTInNum; i++ )
2635	{
2636	abBM1[ piDeltaDLTIn[ i ] ] = true;
2637	}
2638
2639	Int aiIdx2DepthValue[256];
2640	UInt uiNumDepthValues = 0;
2641	memset( aiIdx2DepthValue, 0, sizeof( aiIdx2DepthValue ));
2642
2643	for( Int i = 0; i < 256; i++ )
2644	{
2645	if( abBM0[ i ] ^ abBM1[ i ] )
2646	{
2647	aiIdx2DepthValue[ uiNumDepthValues++ ] = i;
2648	}
2649	}
2650
2651	// update internal tables
2652	setDepthLUTs(layerIdInVps, aiIdx2DepthValue, uiNumDepthValues);
2653	}
2654	#endif
2655
2656	#endif
2657
2658	#if H_MV
2659	Void TComSPS::inferRepFormat( TComVPS* vps, Int layerIdCurr )
2660	{
2661	if ( layerIdCurr > 0 )
2662	{
2663	Int repFormatIdx = getUpdateRepFormatFlag() ? getSpsRepFormatIdx() : vps->getVpsRepFormatIdx( vps->getLayerIdInVps( layerIdCurr ) ) ;
2664	TComRepFormat* repFormat = vps->getRepFormat( repFormatIdx );
2665	setChromaFormatIdc( repFormat->getChromaFormatVpsIdc() );
2666	//// ToDo: add when supported:
2667	// setSeperateColourPlaneFlag( repFormat->getSeparateColourPlaneVpsFlag() ) ;
2668
2669	setPicWidthInLumaSamples ( repFormat->getPicWidthVpsInLumaSamples() );
2670	setPicHeightInLumaSamples( repFormat->getPicHeightVpsInLumaSamples() );
2671
2672	setBitDepthY ( repFormat->getBitDepthVpsLumaMinus8() + 8 );
2673	setQpBDOffsetY ( (Int) (6*( getBitDepthY() - 8 )) );
2674
2675	setBitDepthC ( repFormat->getBitDepthVpsChromaMinus8() + 8 );
2676	setQpBDOffsetC ( (Int) (6* ( getBitDepthC() -8 ) ) );
2677	if ( getLayerId() > 0 && getUpdateRepFormatFlag() )
2678	{
2679	assert( getChromaFormatIdc() <= repFormat->getChromaFormatVpsIdc() );
2680	//// ToDo: add when supported:
2681	// assert( getSeperateColourPlaneFlag() <= repFormat->getSeparateColourPlaneVpsFlag() ) ;
2682
2683	assert( getPicWidthInLumaSamples() <= repFormat->getPicWidthVpsInLumaSamples() );
2684	assert( getPicHeightInLumaSamples() <= repFormat->getPicHeightVpsInLumaSamples() );
2685
2686	assert( getBitDepthY() <= repFormat->getBitDepthVpsLumaMinus8() + 8 );
2687	assert( getBitDepthC() <= repFormat->getBitDepthVpsChromaMinus8() + 8 );
2688	}
2689	}
2690
2691	// Set conformance window
2692	Int scal = TComSPS::getWinUnitX( getChromaFormatIdc() ) ;
2693	getConformanceWindow().scaleOffsets( scal );
2694	getVuiParameters()->getDefaultDisplayWindow().scaleOffsets( scal );
2695	}
2696
2697	Void TComSPS::inferScalingList( TComSPS* spsSrc )
2698	{
2699	if ( getSpsInferScalingListFlag() )
2700	{
2701	assert( spsSrc != NULL );
2702	assert( !spsSrc->getSpsInferScalingListFlag() );
2703	getScalingList()->inferFrom( spsSrc->getScalingList() );
2704	}
2705	}
2706	#endif
2707
2708	TComReferencePictureSet::TComReferencePictureSet()
2709	: m_numberOfPictures (0)
2710	, m_numberOfNegativePictures (0)
2711	, m_numberOfPositivePictures (0)
2712	, m_numberOfLongtermPictures (0)
2713	, m_interRPSPrediction (0)
2714	, m_deltaRIdxMinus1 (0)
2715	, m_deltaRPS (0)
2716	, m_numRefIdc (0)
2717	{
2718	::memset( m_deltaPOC, 0, sizeof(m_deltaPOC) );
2719	::memset( m_POC, 0, sizeof(m_POC) );
2720	::memset( m_used, 0, sizeof(m_used) );
2721	::memset( m_refIdc, 0, sizeof(m_refIdc) );
2722	}
2723
2724	TComReferencePictureSet::~TComReferencePictureSet()
2725	{
2726	}
2727
2728	Void TComReferencePictureSet::setUsed(Int bufferNum, Bool used)
2729	{
2730	m_used[bufferNum] = used;
2731	}
2732
2733	Void TComReferencePictureSet::setDeltaPOC(Int bufferNum, Int deltaPOC)
2734	{
2735	m_deltaPOC[bufferNum] = deltaPOC;
2736	}
2737
2738	Void TComReferencePictureSet::setNumberOfPictures(Int numberOfPictures)
2739	{
2740	m_numberOfPictures = numberOfPictures;
2741	}
2742
2743	Int TComReferencePictureSet::getUsed(Int bufferNum)
2744	{
2745	return m_used[bufferNum];
2746	}
2747
2748	Int TComReferencePictureSet::getDeltaPOC(Int bufferNum)
2749	{
2750	return m_deltaPOC[bufferNum];
2751	}
2752
2753	Int TComReferencePictureSet::getNumberOfPictures()
2754	{
2755	return m_numberOfPictures;
2756	}
2757
2758	Int TComReferencePictureSet::getPOC(Int bufferNum)
2759	{
2760	return m_POC[bufferNum];
2761	}
2762
2763	Void TComReferencePictureSet::setPOC(Int bufferNum, Int POC)
2764	{
2765	m_POC[bufferNum] = POC;
2766	}
2767
2768	Bool TComReferencePictureSet::getCheckLTMSBPresent(Int bufferNum)
2769	{
2770	return m_bCheckLTMSB[bufferNum];
2771	}
2772
2773	Void TComReferencePictureSet::setCheckLTMSBPresent(Int bufferNum, Bool b)
2774	{
2775	m_bCheckLTMSB[bufferNum] = b;
2776	}
2777
2778	/** set the reference idc value at uiBufferNum entry to the value of iRefIdc
2779	* \param uiBufferNum
2780	* \param iRefIdc
2781	* \returns Void
2782	*/
2783	Void TComReferencePictureSet::setRefIdc(Int bufferNum, Int refIdc)
2784	{
2785	m_refIdc[bufferNum] = refIdc;
2786	}
2787
2788	/** get the reference idc value at uiBufferNum
2789	* \param uiBufferNum
2790	* \returns Int
2791	*/
2792	Int TComReferencePictureSet::getRefIdc(Int bufferNum)
2793	{
2794	return m_refIdc[bufferNum];
2795	}
2796
2797	/** Sorts the deltaPOC and Used by current values in the RPS based on the deltaPOC values.
2798	* deltaPOC values are sorted with -ve values before the +ve values. -ve values are in decreasing order.
2799	* +ve values are in increasing order.
2800	* \returns Void
2801	*/
2802	Void TComReferencePictureSet::sortDeltaPOC()
2803	{
2804	// sort in increasing order (smallest first)
2805	for(Int j=1; j < getNumberOfPictures(); j++)
2806	{
2807	Int deltaPOC = getDeltaPOC(j);
2808	Bool used = getUsed(j);
2809	for (Int k=j-1; k >= 0; k--)
2810	{
2811	Int temp = getDeltaPOC(k);
2812	if (deltaPOC < temp)
2813	{
2814	setDeltaPOC(k+1, temp);
2815	setUsed(k+1, getUsed(k));
2816	setDeltaPOC(k, deltaPOC);
2817	setUsed(k, used);
2818	}
2819	}
2820	}
2821	// flip the negative values to largest first
2822	Int numNegPics = getNumberOfNegativePictures();
2823	for(Int j=0, k=numNegPics-1; j < numNegPics>>1; j++, k--)
2824	{
2825	Int deltaPOC = getDeltaPOC(j);
2826	Bool used = getUsed(j);
2827	setDeltaPOC(j, getDeltaPOC(k));
2828	setUsed(j, getUsed(k));
2829	setDeltaPOC(k, deltaPOC);
2830	setUsed(k, used);
2831	}
2832	}
2833
2834	/** Prints the deltaPOC and RefIdc (if available) values in the RPS.
2835	* A "*" is added to the deltaPOC value if it is Used bu current.
2836	* \returns Void
2837	*/
2838	Void TComReferencePictureSet::printDeltaPOC()
2839	{
2840	printf("DeltaPOC = { ");
2841	for(Int j=0; j < getNumberOfPictures(); j++)
2842	{
2843	printf("%d%s ", getDeltaPOC(j), (getUsed(j)==1)?"*":"");
2844	}
2845	if (getInterRPSPrediction())
2846	{
2847	printf("}, RefIdc = { ");
2848	for(Int j=0; j < getNumRefIdc(); j++)
2849	{
2850	printf("%d ", getRefIdc(j));
2851	}
2852	}
2853	printf("}\n");
2854	}
2855
2856	TComRPSList::TComRPSList()
2857	:m_referencePictureSets (NULL)
2858	{
2859	}
2860
2861	TComRPSList::~TComRPSList()
2862	{
2863	}
2864
2865	Void TComRPSList::create( Int numberOfReferencePictureSets)
2866	{
2867	m_numberOfReferencePictureSets = numberOfReferencePictureSets;
2868	m_referencePictureSets = new TComReferencePictureSet[numberOfReferencePictureSets];
2869	}
2870
2871	Void TComRPSList::destroy()
2872	{
2873	if (m_referencePictureSets)
2874	{
2875	delete [] m_referencePictureSets;
2876	}
2877	m_numberOfReferencePictureSets = 0;
2878	m_referencePictureSets = NULL;
2879	}
2880
2881
2882
2883	TComReferencePictureSet* TComRPSList::getReferencePictureSet(Int referencePictureSetNum)
2884	{
2885	return &m_referencePictureSets[referencePictureSetNum];
2886	}
2887
2888	Int TComRPSList::getNumberOfReferencePictureSets()
2889	{
2890	return m_numberOfReferencePictureSets;
2891	}
2892
2893	Void TComRPSList::setNumberOfReferencePictureSets(Int numberOfReferencePictureSets)
2894	{
2895	m_numberOfReferencePictureSets = numberOfReferencePictureSets;
2896	}
2897
2898	TComRefPicListModification::TComRefPicListModification()
2899	: m_bRefPicListModificationFlagL0 (false)
2900	, m_bRefPicListModificationFlagL1 (false)
2901	{
2902	::memset( m_RefPicSetIdxL0, 0, sizeof(m_RefPicSetIdxL0) );
2903	::memset( m_RefPicSetIdxL1, 0, sizeof(m_RefPicSetIdxL1) );
2904	}
2905
2906	TComRefPicListModification::~TComRefPicListModification()
2907	{
2908	}
2909
2910	TComScalingList::TComScalingList()
2911	{
2912	init();
2913	}
2914	TComScalingList::~TComScalingList()
2915	{
2916	destroy();
2917	}
2918
2919	/** set default quantization matrix to array
2920	*/
2921	Void TComSlice::setDefaultScalingList()
2922	{
2923	for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2924	{
2925	for(UInt listId=0;listId<g_scalingListNum[sizeId];listId++)
2926	{
2927	getScalingList()->processDefaultMatrix(sizeId, listId);
2928	}
2929	}
2930	}
2931	/** check if use default quantization matrix
2932	* \returns true if use default quantization matrix in all size
2933	*/
2934	Bool TComSlice::checkDefaultScalingList()
2935	{
2936	UInt defaultCounter=0;
2937
2938	for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2939	{
2940	for(UInt listId=0;listId<g_scalingListNum[sizeId];listId++)
2941	{
2942	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
2943	&& ((sizeId < SCALING_LIST_16x16) \|\| (getScalingList()->getScalingListDC(sizeId,listId) == 16))) // check DC value
2944	{
2945	defaultCounter++;
2946	}
2947	}
2948	}
2949	return (defaultCounter == (SCALING_LIST_NUM * SCALING_LIST_SIZE_NUM - 4)) ? false : true; // -4 for 32x32
2950	}
2951
2952	#if H_MV
2953	Void TComSlice::createInterLayerReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic>& refPicSetInterLayer0, std::vector<TComPic>& refPicSetInterLayer1 )
2954	{
2955	refPicSetInterLayer0.clear();
2956	refPicSetInterLayer1.clear();
2957
2958	for( Int i = 0; i < getNumActiveRefLayerPics(); i++ )
2959	{
2960	Int layerIdRef = getRefPicLayerId( i );
2961	TComPic* picRef = ivPicLists->getPic( layerIdRef, getPOC() ) ;
2962	assert ( picRef != 0 ); // There shall be no entry equal to "no reference picture" in RefPicSetInterLayer0 or RefPicSetInterLayer1.
2963
2964	picRef->getPicYuvRec()->extendPicBorder();
2965	picRef->setIsLongTerm( true );
2966	picRef->getSlice(0)->setReferenced( true );
2967
2968	Int viewIdCur = getVPS()->getViewId( getLayerId() );
2969	Int viewIdZero = getVPS()->getViewId( 0 );
2970	Int viewIdRef = getVPS()->getViewId( layerIdRef );
2971
2972	if ( ( viewIdCur <= viewIdZero && viewIdCur <= viewIdRef ) \|\| ( viewIdCur >= viewIdZero && viewIdCur >= viewIdRef ) )
2973	{
2974	refPicSetInterLayer0.push_back( picRef );
2975	}
2976	else
2977	{
2978	refPicSetInterLayer1.push_back( picRef );
2979	}
2980	// Consider to check here:
2981	// "If the current picture is a RADL picture, there shall be no entry in the RefPicSetInterLayer0 and RefPicSetInterLayer1 that is a RASL picture. "
2982	#if H_MV_HLS_7_MISC_P0130_20
2983	assert( picRef->getSlice(0)->getDiscardableFlag() == false ); // "There shall be no picture that has discardable_flag equal to 1 in RefPicSetInterLayer0 or RefPicSetInterLayer1".
2984	#endif
2985	}
2986	}
2987
2988	Void TComSlice::markIvRefPicsAsShortTerm( std::vector<TComPic> refPicSetInterLayer0, std::vector<TComPic> refPicSetInterLayer1 )
2989	{
2990	// Mark as shortterm
2991	for ( Int i = 0; i < refPicSetInterLayer0.size(); i++ )
2992	{
2993	refPicSetInterLayer0[i]->setIsLongTerm( false );
2994	}
2995
2996	for ( Int i = 0; i < refPicSetInterLayer1.size(); i++ )
2997	{
2998	refPicSetInterLayer1[i]->setIsLongTerm( false );
2999	}
3000
3001	}
3002	Void TComSlice::markIvRefPicsAsUnused( TComPicLists* ivPicLists, std::vector<Int> targetDecLayerIdSet, TComVPS* vps, Int curLayerId, Int curPoc )
3003	{
3004	// Fill targetDecLayerIdSet with all layers if empty (at encoder side)
3005	if (targetDecLayerIdSet.size() == 0 )
3006	{
3007	for ( Int layerIdInVps = 0; layerIdInVps <= vps->getMaxLayersMinus1(); layerIdInVps++ )
3008	{
3009	targetDecLayerIdSet.push_back( vps->getLayerIdInNuh( layerIdInVps ) );
3010	}
3011	}
3012
3013	Int numTargetDecLayers = (Int) targetDecLayerIdSet.size();
3014	Int latestDecIdx;
3015	for ( latestDecIdx = 0; latestDecIdx < numTargetDecLayers; latestDecIdx++)
3016	{
3017	if ( targetDecLayerIdSet[ latestDecIdx ] == curLayerId )
3018	{
3019	break;
3020	}
3021	}
3022
3023	for( Int i = 0; i <= latestDecIdx; i++ )
3024	{
3025	if ( vps->nuhLayerIdIncluded( targetDecLayerIdSet[ i ] ) )
3026	{
3027	TComPic* pcPic = ivPicLists->getPic( targetDecLayerIdSet[ i ], curPoc );
3028	if ( pcPic )
3029	{
3030	if( pcPic->getSlice(0)->isReferenced() && pcPic->getSlice(0)->getTemporalLayerNonReferenceFlag() )
3031	{
3032	Bool remainingInterLayerReferencesFlag = false;
3033	for( Int j = latestDecIdx + 1; j < numTargetDecLayers; j++ )
3034	{
3035	TComVPS* vpsSlice = pcPic->getSlice(0)->getVPS();
3036	if ( vps->nuhLayerIdIncluded( targetDecLayerIdSet[ j ] ) )
3037	{
3038	for( Int k = 0; k < vpsSlice->getNumDirectRefLayers( targetDecLayerIdSet[ j ] ); k++ )
3039	{
3040	if ( targetDecLayerIdSet[ i ] == vpsSlice->getRefLayerId( targetDecLayerIdSet[ j ], k ) )
3041	{
3042	remainingInterLayerReferencesFlag = true;
3043	}
3044	}
3045	}
3046	}
3047	if( !remainingInterLayerReferencesFlag )
3048	{
3049	pcPic->getSlice(0)->setReferenced( false );
3050	}
3051	}
3052	}
3053	}
3054	}
3055	}
3056
3057	Void TComSlice::printRefPicList()
3058	{
3059	for ( Int li = 0; li < 2; li++)
3060	{
3061	std::cout << std::endl << "RefPicListL" << li << ":" << std::endl;
3062	for (Int rIdx = 0; rIdx <= (m_aiNumRefIdx[li]-1); rIdx ++)
3063	{
3064	if (rIdx == 0 && li == 0) m_apcRefPicList[li][rIdx]->print( true );
3065
3066	m_apcRefPicList[li][rIdx]->print( false );
3067	}
3068	}
3069	}
3070
3071	Void TComSlice::markCurrPic( TComPic* currPic )
3072	{
3073	if ( !currPic->getSlice(0)->getDiscardableFlag() )
3074	{
3075	currPic->getSlice(0)->setReferenced( true ) ;
3076	currPic->setIsLongTerm( false );
3077	}
3078	else
3079	{
3080	currPic->getSlice(0)->setReferenced( false ) ;
3081	}
3082	}
3083
3084	Void TComSlice::setRefPicSetInterLayer( std::vector<TComPic> refPicSetInterLayer0, std::vector<TComPic> refPicSetInterLayer1 )
3085	{
3086	m_refPicSetInterLayer0 = refPicSetInterLayer0;
3087	m_refPicSetInterLayer1 = refPicSetInterLayer1;
3088	}
3089
3090	TComPic* TComSlice::getPicFromRefPicSetInterLayer(Int setIdc, Int layerId )
3091	{
3092	assert ( setIdc == 0 \|\| setIdc == 1);
3093	std::vector<TComPic> refPicSetInterLayer = ( setIdc == 0 ? m_refPicSetInterLayer0 : m_refPicSetInterLayer1);
3094	assert( refPicSetInterLayer != 0 );
3095
3096	TComPic* pcPic = NULL;
3097	for ( Int i = 0; i < (*refPicSetInterLayer).size(); i++ )
3098	{
3099	if ((*refPicSetInterLayer)[ i ]->getLayerId() == layerId )
3100	{
3101	pcPic = (*refPicSetInterLayer)[ i ];
3102	}
3103	}
3104
3105	assert(pcPic != NULL);
3106	return pcPic;
3107	}
3108
3109
3110	Int TComSlice::getRefLayerPicFlag( Int i )
3111	{
3112	TComVPS* vps = getVPS();
3113	Int refLayerIdx = vps->getLayerIdInVps( vps->getRefLayerId( getLayerId(), i ) );
3114
3115	Bool refLayerPicFlag = ( vps->getSubLayersVpsMaxMinus1( refLayerIdx ) >= getTLayer() ) &&
3116	( vps->getMaxTidIlRefPicsPlus1( refLayerIdx, vps->getLayerIdInVps( getLayerId() )) > getTLayer() );
3117
3118	return refLayerPicFlag;
3119	}
3120
3121	Int TComSlice::getRefLayerPicIdc( Int j )
3122	{
3123	Int refLayerPicIdc = -1;
3124	Int curj = 0;
3125	for( Int i = 0; i < getVPS()->getNumDirectRefLayers( getLayerId()) ; i++ )
3126	{
3127	if( getRefLayerPicFlag( i ) )
3128	{
3129	if ( curj == j )
3130	{
3131	refLayerPicIdc = i;
3132	break;
3133	}
3134	curj++;
3135	}
3136	}
3137
3138	assert( curj == j );
3139	assert( refLayerPicIdc != -1 );
3140	return refLayerPicIdc;
3141	}
3142
3143	Int TComSlice::getNumRefLayerPics( )
3144	{
3145	Int numRefLayerPics = 0;
3146	for( Int i = 0; i < getVPS()->getNumDirectRefLayers( getLayerId()) ; i++ )
3147	{
3148	numRefLayerPics += getRefLayerPicFlag( i );
3149	}
3150	return numRefLayerPics;
3151	}
3152
3153
3154
3155	Int TComSlice::getNumActiveRefLayerPics()
3156	{
3157	Int numActiveRefLayerPics;
3158
3159	#if H_MV_HLS_7_MISC_P0079_18
3160	if( getLayerId() == 0 \|\| getNumRefLayerPics() == 0 )
3161	#else
3162	if( getLayerId() == 0 \|\| getVPS()->getNumDirectRefLayers( getLayerId() ) == 0 )
3163	#endif
3164	{
3165	numActiveRefLayerPics = 0;
3166	}
3167	else if (getVPS()->getAllRefLayersActiveFlag() )
3168	{
3169	numActiveRefLayerPics = getNumRefLayerPics();
3170	}
3171	else if ( !getInterLayerPredEnabledFlag() )
3172	{
3173	numActiveRefLayerPics = 0;
3174	}
3175	else if( getVPS()->getMaxOneActiveRefLayerFlag() \|\| getVPS()->getNumDirectRefLayers( getLayerId() ) == 1 )
3176	{
3177	#if H_MV_HLS_7_MISC_P0079_18
3178	numActiveRefLayerPics = 1;
3179	#else
3180	numActiveRefLayerPics = getRefLayerPicFlag( 0 ) ? 1 : 0;
3181	#endif
3182	}
3183	else
3184	{
3185	numActiveRefLayerPics = getNumInterLayerRefPicsMinus1() + 1;
3186	}
3187	return numActiveRefLayerPics;
3188	}
3189
3190	Int TComSlice::getRefPicLayerId( Int i )
3191	{
3192	return getVPS()->getRefLayerId( getLayerId(), getInterLayerPredLayerIdc( i ) );
3193	}
3194
3195	#if H_3D_ARP
3196	Void TComSlice::setARPStepNum( TComPicLists*ivPicLists )
3197	{
3198	Bool tempRefPicInListsFlag = false;
3199	if(!getVPS()->getUseAdvRP(getLayerId()) \|\| this->isIRAP())
3200	{
3201	m_nARPStepNum = 0;
3202	}
3203	else
3204	{
3205	setFirstTRefIdx (REF_PIC_LIST_0, -1);
3206	setFirstTRefIdx (REF_PIC_LIST_1, -1);
3207	for ( Int refListIdx = 0; refListIdx < ((m_eSliceType==B_SLICE) ? 2 : 1); refListIdx++ )
3208	{
3209	#if MTK_ARP_REF_SELECTION_G0053
3210	Int diffPOC=MAX_INT;
3211	Int idx=-1;
3212	#endif
3213	for(Int i = 0; i < getNumRefIdx(RefPicList(refListIdx)); i++ )
3214	{
3215	if ( getRefPic(RefPicList(refListIdx), i)->getPOC() != getPOC() )
3216	{
3217	#if MTK_ARP_REF_SELECTION_G0053
3218	if( abs(getRefPic(RefPicList(refListIdx), i)->getPOC() - getPOC()) < diffPOC)
3219	{
3220	diffPOC=abs(getRefPic(RefPicList(refListIdx), i)->getPOC() - getPOC());
3221	idx=i;
3222	}
3223	#else
3224	setFirstTRefIdx (RefPicList(refListIdx), i);
3225	break;
3226	#endif
3227	}
3228	#if MTK_ARP_REF_SELECTION_G0053
3229	if(idx>=0)
3230	{
3231	setFirstTRefIdx (RefPicList(refListIdx), idx);
3232	}
3233	#endif
3234	}
3235	}
3236	tempRefPicInListsFlag = getFirstTRefIdx(REF_PIC_LIST_0) >= 0 \|\| getFirstTRefIdx(REF_PIC_LIST_1) >= 0;
3237	m_nARPStepNum = tempRefPicInListsFlag ? getVPS()->getARPStepNum(getLayerId()) : 0;
3238	}
3239
3240	if (tempRefPicInListsFlag)
3241	{
3242	for ( Int refListIdx = 0; refListIdx < ((m_eSliceType==B_SLICE) ? 2 : 1); refListIdx++ )
3243	{
3244	RefPicList eRefPicList = RefPicList( refListIdx );
3245	Int prevPOC = getRefPic(eRefPicList, getFirstTRefIdx(eRefPicList) )->getPOC();
3246	for( Int i = 0; i < getNumActiveRefLayerPics(); i++ )
3247	{
3248	Int layerIdInNuh = getRefPicLayerId( i );
3249	Int viewIdx = getVPS()->getViewId( layerIdInNuh );
3250	TComPic*pcPicPrev = ivPicLists->getPic(viewIdx, 0, prevPOC);
3251	if (getFirstTRefIdx(eRefPicList) >= 0 && pcPicPrev && pcPicPrev->getSlice( 0 )->isReferenced())
3252	{
3253	m_arpRefPicAvailable[eRefPicList][layerIdInNuh] = true;
3254	}
3255	else
3256	{
3257	m_arpRefPicAvailable[eRefPicList][layerIdInNuh] = false;
3258	}
3259	}
3260	}
3261	}
3262	}
3263	#endif
3264	#if H_3D_IC
3265	Void TComSlice::xSetApplyIC()
3266	{
3267	Int iMaxPelValue = ( 1 << g_bitDepthY );
3268	Int *aiRefOrgHist;
3269	Int *aiCurrHist;
3270	aiRefOrgHist = (Int *) xMalloc( Int,iMaxPelValue );
3271	aiCurrHist = (Int *) xMalloc( Int,iMaxPelValue );
3272	memset( aiRefOrgHist, 0, iMaxPelValue*sizeof(Int) );
3273	memset( aiCurrHist, 0, iMaxPelValue*sizeof(Int) );
3274	// Reference Idx Number
3275	Int iNumRefIdx = getNumRefIdx( REF_PIC_LIST_0 );
3276	TComPic* pcCurrPic = NULL;
3277	TComPic* pcRefPic = NULL;
3278	TComPicYuv* pcCurrPicYuv = NULL;
3279	TComPicYuv* pcRefPicYuvOrg = NULL;
3280	pcCurrPic = getPic();
3281	pcCurrPicYuv = pcCurrPic->getPicYuvOrg();
3282	Int iWidth = pcCurrPicYuv->getWidth();
3283	Int iHeight = pcCurrPicYuv->getHeight();
3284
3285
3286	// Get InterView Reference picture
3287	// !!!!! Assume only one Interview Reference Picture in L0
3288	for ( Int i = 0; i < iNumRefIdx; i++ )
3289	{
3290	pcRefPic = getRefPic( REF_PIC_LIST_0, i );
3291	if ( pcRefPic != NULL )
3292	{
3293	if ( pcCurrPic->getViewIndex() != pcRefPic->getViewIndex() )
3294	{
3295	pcRefPicYuvOrg = pcRefPic->getPicYuvOrg();
3296	}
3297	}
3298	}
3299
3300	if ( pcRefPicYuvOrg != NULL )
3301	{
3302	Pel* pCurrY = pcCurrPicYuv ->getLumaAddr();
3303	Pel* pRefOrgY = pcRefPicYuvOrg ->getLumaAddr();
3304	Int iCurrStride = pcCurrPicYuv->getStride();
3305	Int iRefStride = pcRefPicYuvOrg->getStride();
3306	Int iSumOrgSAD = 0;
3307	Double dThresholdOrgSAD = getIsDepth() ? 0.1 : 0.05;
3308
3309	// Histogram building - luminance
3310	for ( Int y = 0; y < iHeight; y++ )
3311	{
3312	for ( Int x = 0; x < iWidth; x++ )
3313	{
3314	aiCurrHist[pCurrY[x]]++;
3315	aiRefOrgHist[pRefOrgY[x]]++;
3316	}
3317	pCurrY += iCurrStride;
3318	pRefOrgY += iRefStride;
3319	}
3320	// Histogram SAD
3321	for ( Int i = 0; i < iMaxPelValue; i++ )
3322	{
3323	iSumOrgSAD += abs( aiCurrHist[i] - aiRefOrgHist[i] );
3324	}
3325	// Setting
3326	if ( iSumOrgSAD > Int( dThresholdOrgSAD * iWidth * iHeight ) )
3327	{
3328	m_bApplyIC = true;
3329	}
3330	else
3331	{
3332	m_bApplyIC = false;
3333	}
3334	}
3335
3336	xFree( aiCurrHist );
3337	xFree( aiRefOrgHist );
3338	aiCurrHist = NULL;
3339	aiRefOrgHist = NULL;
3340	}
3341	#endif
3342	#if H_3D
3343	Void TComSlice::setIvPicLists( TComPicLists* m_ivPicLists )
3344	{
3345	for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
3346	{
3347	for ( Int depthId = 0; depthId < 2; depthId++ )
3348	{
3349	m_ivPicsCurrPoc[ depthId ][ i ] = ( i <= m_viewIndex ) ? m_ivPicLists->getPic( i, ( depthId == 1) , getPOC() ) : NULL;
3350	}
3351	}
3352	}
3353	Void TComSlice::setDepthToDisparityLUTs()
3354	{
3355	Bool setupLUT = false;
3356	Int layerIdInVPS = getVPS()->getLayerIdInNuh( m_layerId );
3357
3358	#if H_3D_VSP
3359	setupLUT = setupLUT \|\| getVPS()->getViewSynthesisPredFlag( layerIdInVPS);
3360	#endif
3361
3362	#if H_3D_NBDV_REF
3363	setupLUT = setupLUT \|\| getVPS()->getDepthRefinementFlag( layerIdInVPS );
3364	#endif
3365
3366	#if H_3D_IV_MERGE
3367	setupLUT = setupLUT \|\| ( getVPS()->getIvMvPredFlag(layerIdInVPS ) && getIsDepth() );
3368	#endif
3369
3370	#if MTK_DDD_G0063
3371	if( getIsDepth() && getViewIndex() > 0 )
3372	{
3373	TComSlice *pcTextSlice = getTexturePic()->getSlice( 0 );
3374	memcpy( m_aiDDDInvScale, pcTextSlice->m_aiDDDInvScale, sizeof( Int ) * getViewIndex() );
3375	memcpy( m_aiDDDInvOffset, pcTextSlice->m_aiDDDInvOffset, sizeof( Int ) * getViewIndex() );
3376	memcpy( m_aiDDDShift, pcTextSlice->m_aiDDDShift, sizeof( Int ) * getViewIndex() );
3377	}
3378	#endif
3379
3380	if( !setupLUT )
3381	return;
3382
3383	/// GT: Allocation should be moved to a better place later;
3384	if ( m_depthToDisparityB == NULL )
3385	{
3386	m_depthToDisparityB = new Int*[ getViewIndex() ];
3387	for ( Int i = 0; i < getViewIndex(); i++ )
3388	{
3389	m_depthToDisparityB[ i ] = new Int[ Int(1 << g_bitDepthY) ];
3390	}
3391	}
3392
3393	if ( m_depthToDisparityF == NULL )
3394	{
3395	m_depthToDisparityF= new Int*[ getViewIndex() ];
3396	for ( Int i = 0; i < getViewIndex(); i++ )
3397	{
3398	m_depthToDisparityF[ i ] = new Int[ Int(1 << g_bitDepthY) ];
3399	}
3400	}
3401
3402	assert( m_depthToDisparityB != NULL );
3403	assert( m_depthToDisparityF != NULL );
3404
3405	TComVPS* vps = getVPS();
3406
3407	Int log2Div = g_bitDepthY - 1 + vps->getCamParPrecision();
3408	Int viewIndex = getViewIndex();
3409
3410	Bool camParaSH = vps->hasCamParInSliceHeader( viewIndex );
3411
3412	Int* codScale = camParaSH ? m_aaiCodedScale [ 0 ] : vps->getCodedScale ( viewIndex );
3413	Int* codOffset = camParaSH ? m_aaiCodedOffset[ 0 ] : vps->getCodedOffset ( viewIndex );
3414	Int* invCodScale = camParaSH ? m_aaiCodedScale [ 1 ] : vps->getInvCodedScale ( viewIndex );
3415	Int* invCodOffset = camParaSH ? m_aaiCodedOffset[ 1 ] : vps->getInvCodedOffset( viewIndex );
3416
3417	for (Int i = 0; i <= ( getViewIndex() - 1); i++)
3418	{
3419	for ( Int d = 0; d <= ( ( 1 << g_bitDepthY ) - 1 ); d++ )
3420	{
3421	Int offset = ( codOffset [ i ] << g_bitDepthY ) + ( ( 1 << log2Div ) >> 1 );
3422	m_depthToDisparityB[ i ][ d ] = ( codScale [ i ] * d + offset ) >> log2Div;
3423
3424	Int invOffset = ( invCodOffset[ i ] << g_bitDepthY ) + ( ( 1 << log2Div ) >> 1 );
3425	m_depthToDisparityF[ i ][ d ] = ( invCodScale[ i ] * d + invOffset ) >> log2Div;
3426	}
3427
3428	#if MTK_DDD_G0063
3429	InitializeDDDPara( vps->getCamParPrecision(), codScale[ i ], codOffset[ i ], i );
3430	#endif
3431	}
3432	}
3433	#endif
3434	#endif
3435
3436	#if MTK_DDD_G0063
3437	Void TComSlice::InitializeDDDPara( UInt uiCamParsCodedPrecision, Int iCodedScale,Int iCodedOffset, Int iBaseViewIdx )
3438	{
3439	UInt uiViewId = getViewIndex();
3440
3441	if( uiViewId == 0 )
3442	{
3443	m_aiDDDInvScale[ iBaseViewIdx ] = m_aiDDDInvOffset[ iBaseViewIdx ] = m_aiDDDShift[ iBaseViewIdx ] = 0;
3444	return;
3445	}
3446
3447
3448	Int iSign = iCodedScale >= 0 ? 1 : -1;
3449	iCodedScale = abs( iCodedScale );
3450
3451	Int iBitWidth = 0;
3452
3453	const Int iInvPres = 9;
3454
3455	while( ((( 1 << iBitWidth ) << 1 ) <= iCodedScale ) )
3456	{
3457	iBitWidth ++;
3458	}
3459	iBitWidth += iInvPres;
3460	Int iTargetValue = 1 << iBitWidth;
3461
3462	Int iMinError = MAX_INT;
3463	Int iBestD = 1 << ( iInvPres - 1 );
3464	for( Int d = 1 << ( iInvPres - 1 ); d < ( 1 << iInvPres ); d++ )
3465	{
3466	Int iError = abs( iCodedScale * d - iTargetValue );
3467	if( iError < iMinError )
3468	{
3469	iMinError = iError;
3470	iBestD = d;
3471	}
3472	if( iMinError == 0 )
3473	{
3474	break;
3475	}
3476	}
3477	Int iRoundingDir = 0;
3478	if( iCodedScale * iBestD > iTargetValue )
3479	{
3480	iRoundingDir = -1;
3481	}
3482	else if( iCodedScale * iBestD < iTargetValue )
3483	{
3484	iRoundingDir = 1;
3485	}
3486	Int iCamPres = uiCamParsCodedPrecision - 1;
3487	m_aiDDDInvScale [ iBaseViewIdx ] = ( iBestD << ( iCamPres + g_bitDepthY )) * iSign;
3488	m_aiDDDInvOffset[ iBaseViewIdx ] = -iSign * iBestD * ( iCodedOffset << g_bitDepthY );
3489	m_aiDDDShift [ iBaseViewIdx ] = iBitWidth;
3490	m_aiDDDInvOffset[ iBaseViewIdx ] += 1 << ( m_aiDDDShift[ iBaseViewIdx ] - 1 );
3491	m_aiDDDInvOffset[ iBaseViewIdx ] += ( 1 << ( m_aiDDDShift[ iBaseViewIdx ] - 4 ) ) * iRoundingDir;
3492
3493	return;
3494	}
3495	#endif
3496
3497	/** get scaling matrix from RefMatrixID
3498	* \param sizeId size index
3499	* \param Index of input matrix
3500	* \param Index of reference matrix
3501	*/
3502	Void TComScalingList::processRefMatrix( UInt sizeId, UInt listId , UInt refListId )
3503	{
3504	::memcpy(getScalingListAddress(sizeId, listId),((listId == refListId)? getScalingListDefaultAddress(sizeId, refListId): getScalingListAddress(sizeId, refListId)),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
3505	}
3506
3507	/** parse syntax infomation
3508	* \param pchFile syntax infomation
3509	* \returns false if successful
3510	*/
3511	Bool TComScalingList::xParseScalingList(Char* pchFile)
3512	{
3513	FILE *fp;
3514	Char line[1024];
3515	UInt sizeIdc,listIdc;
3516	UInt i,size = 0;
3517	Int *src=0,data;
3518	Char *ret;
3519	UInt retval;
3520
3521	if((fp = fopen(pchFile,"r")) == (FILE*)NULL)
3522	{
3523	printf("can't open file %s :: set Default Matrix\n",pchFile);
3524	return true;
3525	}
3526
3527	for(sizeIdc = 0; sizeIdc < SCALING_LIST_SIZE_NUM; sizeIdc++)
3528	{
3529	size = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeIdc]);
3530	for(listIdc = 0; listIdc < g_scalingListNum[sizeIdc]; listIdc++)
3531	{
3532	src = getScalingListAddress(sizeIdc, listIdc);
3533
3534	fseek(fp,0,0);
3535	do
3536	{
3537	ret = fgets(line, 1024, fp);
3538	if ((ret==NULL)\|\|(strstr(line, MatrixType[sizeIdc][listIdc])==NULL && feof(fp)))
3539	{
3540	printf("Error: can't read Matrix :: set Default Matrix\n");
3541	return true;
3542	}
3543	}
3544	while (strstr(line, MatrixType[sizeIdc][listIdc]) == NULL);
3545	for (i=0; i<size; i++)
3546	{
3547	retval = fscanf(fp, "%d,", &data);
3548	if (retval!=1)
3549	{
3550	printf("Error: can't read Matrix :: set Default Matrix\n");
3551	return true;
3552	}
3553	src[i] = data;
3554	}
3555	//set DC value for default matrix check
3556	setScalingListDC(sizeIdc,listIdc,src[0]);
3557
3558	if(sizeIdc > SCALING_LIST_8x8)
3559	{
3560	fseek(fp,0,0);
3561	do
3562	{
3563	ret = fgets(line, 1024, fp);
3564	if ((ret==NULL)\|\|(strstr(line, MatrixType_DC[sizeIdc][listIdc])==NULL && feof(fp)))
3565	{
3566	printf("Error: can't read DC :: set Default Matrix\n");
3567	return true;
3568	}
3569	}
3570	while (strstr(line, MatrixType_DC[sizeIdc][listIdc]) == NULL);
3571	retval = fscanf(fp, "%d,", &data);
3572	if (retval!=1)
3573	{
3574	printf("Error: can't read Matrix :: set Default Matrix\n");
3575	return true;
3576	}
3577	//overwrite DC value when size of matrix is larger than 16x16
3578	setScalingListDC(sizeIdc,listIdc,data);
3579	}
3580	}
3581	}
3582	fclose(fp);
3583	return false;
3584	}
3585
3586	#if H_MV
3587	Void TComScalingList::inferFrom( TComScalingList* srcScLi )
3588	{
3589	for(Int sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3590	{
3591	for(Int listId = 0; listId < g_scalingListNum[sizeId]; listId++)
3592	{
3593	setRefMatrixId (sizeId,listId, srcScLi->getRefMatrixId (sizeId,listId));
3594	setScalingListDC(sizeId,listId, srcScLi->getScalingListDC(sizeId,listId));
3595	::memcpy(getScalingListAddress(sizeId, listId),srcScLi->getScalingListAddress(sizeId, listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
3596	}
3597	}
3598	}
3599	#endif
3600	/** initialization process of quantization matrix array
3601	*/
3602	Void TComScalingList::init()
3603	{
3604	for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3605	{
3606	for(UInt listId = 0; listId < g_scalingListNum[sizeId]; listId++)
3607	{
3608	m_scalingListCoef[sizeId][listId] = new Int [min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])];
3609	}
3610	}
3611	m_scalingListCoef[SCALING_LIST_32x32][3] = m_scalingListCoef[SCALING_LIST_32x32][1]; // copy address for 32x32
3612	}
3613
3614	/** destroy quantization matrix array
3615	*/
3616	Void TComScalingList::destroy()
3617	{
3618	for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3619	{
3620	for(UInt listId = 0; listId < g_scalingListNum[sizeId]; listId++)
3621	{
3622	if(m_scalingListCoef[sizeId][listId]) delete [] m_scalingListCoef[sizeId][listId];
3623	}
3624	}
3625	}
3626
3627	/** get default address of quantization matrix
3628	* \param sizeId size index
3629	* \param listId list index
3630	* \returns pointer of quantization matrix
3631	*/
3632	Int* TComScalingList::getScalingListDefaultAddress(UInt sizeId, UInt listId)
3633	{
3634	Int *src = 0;
3635	switch(sizeId)
3636	{
3637	case SCALING_LIST_4x4:
3638	src = g_quantTSDefault4x4;
3639	break;
3640	case SCALING_LIST_8x8:
3641	src = (listId<3) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
3642	break;
3643	case SCALING_LIST_16x16:
3644	src = (listId<3) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
3645	break;
3646	case SCALING_LIST_32x32:
3647	src = (listId<1) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
3648	break;
3649	default:
3650	assert(0);
3651	src = NULL;
3652	break;
3653	}
3654	return src;
3655	}
3656
3657	/** process of default matrix
3658	* \param sizeId size index
3659	* \param Index of input matrix
3660	*/
3661	Void TComScalingList::processDefaultMatrix(UInt sizeId, UInt listId)
3662	{
3663	::memcpy(getScalingListAddress(sizeId, listId),getScalingListDefaultAddress(sizeId,listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
3664	setScalingListDC(sizeId,listId,SCALING_LIST_DC);
3665	}
3666
3667	/** check DC value of matrix for default matrix signaling
3668	*/
3669	Void TComScalingList::checkDcOfMatrix()
3670	{
3671	for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
3672	{
3673	for(UInt listId = 0; listId < g_scalingListNum[sizeId]; listId++)
3674	{
3675	//check default matrix?
3676	if(getScalingListDC(sizeId,listId) == 0)
3677	{
3678	processDefaultMatrix(sizeId, listId);
3679	}
3680	}
3681	}
3682	}
3683
3684	ParameterSetManager::ParameterSetManager()
3685	: m_vpsMap(MAX_NUM_VPS)
3686	, m_spsMap(MAX_NUM_SPS)
3687	, m_ppsMap(MAX_NUM_PPS)
3688	, m_activeVPSId(-1)
3689	#if !H_MV
3690	, m_activeSPSId(-1)
3691	, m_activePPSId(-1)
3692	{
3693	#else
3694	{
3695	for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
3696	{
3697	m_activeSPSId[ i ] = -1;
3698	m_activePPSId[ i ] = -1;
3699	}
3700	#endif
3701	}
3702
3703
3704	ParameterSetManager::~ParameterSetManager()
3705	{
3706	}
3707
3708	//! activate a SPS from a active parameter sets SEI message
3709	//! \returns true, if activation is successful
3710	#if H_MV
3711	Bool ParameterSetManager::activateSPSWithSEI(Int spsId, Int layerId )
3712	#else
3713	Bool ParameterSetManager::activateSPSWithSEI(Int spsId)
3714	#endif
3715	{
3716	TComSPS *sps = m_spsMap.getPS(spsId);
3717	if (sps)
3718	{
3719	Int vpsId = sps->getVPSId();
3720	if (m_vpsMap.getPS(vpsId))
3721	{
3722	m_activeVPSId = vpsId;
3723	#if H_MV
3724	m_activeSPSId[ layerId ] = spsId;
3725	#else
3726	m_activeSPSId = spsId;
3727	#endif
3728	return true;
3729	}
3730	else
3731	{
3732	printf("Warning: tried to activate SPS using an Active parameter sets SEI message. Referenced VPS does not exist.");
3733	}
3734	}
3735	else
3736	{
3737	printf("Warning: tried to activate non-existing SPS using an Active parameter sets SEI message.");
3738	}
3739	return false;
3740	}
3741
3742	//! activate a PPS and depending on isIDR parameter also SPS and VPS
3743	//! \returns true, if activation is successful
3744	#if H_MV
3745	Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP, Int layerId )
3746	#else
3747	Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP)
3748	#endif
3749	{
3750	TComPPS *pps = m_ppsMap.getPS(ppsId);
3751	if (pps)
3752	{
3753	Int spsId = pps->getSPSId();
3754	#if H_MV
3755	if (!isIRAP && (spsId != m_activeSPSId[ layerId ]))
3756	#else
3757	if (!isIRAP && (spsId != m_activeSPSId))
3758	#endif
3759	{
3760	printf("Warning: tried to activate PPS referring to a inactive SPS at non-IRAP.");
3761	return false;
3762	}
3763
3764	TComSPS *sps = m_spsMap.getPS(spsId);
3765	if (sps)
3766	{
3767	Int vpsId = sps->getVPSId();
3768	if (!isIRAP && (vpsId != m_activeVPSId))
3769	{
3770	printf("Warning: tried to activate PPS referring to a inactive VPS at non-IRAP.");
3771	return false;
3772	}
3773	if (m_vpsMap.getPS(vpsId))
3774	{
3775	#if H_MV
3776	m_activePPSId[ layerId ] = ppsId;
3777	m_activeVPSId = vpsId;
3778	m_activeSPSId[ layerId ] = spsId;
3779	#else
3780	m_activePPSId = ppsId;
3781	m_activeVPSId = vpsId;
3782	m_activeSPSId = spsId;
3783	#endif
3784	return true;
3785	}
3786	else
3787	{
3788	printf("Warning: tried to activate PPS that refers to a non-existing VPS.");
3789	}
3790	}
3791	else
3792	{
3793	printf("Warning: tried to activate a PPS that refers to a non-existing SPS.");
3794	}
3795	}
3796	else
3797	{
3798	printf("Warning: tried to activate non-existing PPS.");
3799	}
3800	return false;
3801	}
3802
3803	ProfileTierLevel::ProfileTierLevel()
3804	: m_profileSpace (0)
3805	, m_tierFlag (false)
3806	, m_profileIdc (0)
3807	, m_levelIdc (0)
3808	, m_progressiveSourceFlag (false)
3809	, m_interlacedSourceFlag (false)
3810	, m_nonPackedConstraintFlag(false)
3811	, m_frameOnlyConstraintFlag(false)
3812	{
3813	::memset(m_profileCompatibilityFlag, 0, sizeof(m_profileCompatibilityFlag));
3814	}
3815
3816	TComPTL::TComPTL()
3817	{
3818	::memset(m_subLayerProfilePresentFlag, 0, sizeof(m_subLayerProfilePresentFlag));
3819	::memset(m_subLayerLevelPresentFlag, 0, sizeof(m_subLayerLevelPresentFlag ));
3820	}
3821
3822	#if H_MV
3823	Void TComPTL::copyLevelFrom( TComPTL* source )
3824	{
3825	getGeneralPTL()->setLevelIdc( source->getGeneralPTL()->getLevelIdc() );
3826	for( Int subLayer = 0; subLayer < 6; subLayer++ )
3827	{
3828	setSubLayerLevelPresentFlag( subLayer, source->getSubLayerLevelPresentFlag( subLayer ) );
3829	getSubLayerPTL( subLayer )->setLevelIdc( source->getSubLayerPTL( subLayer )->getLevelIdc() );
3830	}
3831	}
3832	#endif
3833	//! \}
3834
3835	#if H_MV
3836	TComVPSVUI::TComVPSVUI()
3837	{
3838	m_crossLayerIrapAlignedFlag = true;
3839	#if H_MV_HLS_7_MISC_P0068_21
3840	m_allLayersIdrAlignedFlag = false;
3841	#endif
3842	m_bitRatePresentVpsFlag = false;
3843	m_picRatePresentVpsFlag = false;
3844	for ( Int i = 0; i < MAX_VPS_OP_SETS_PLUS1; i++)
3845	{
3846	for ( Int j = 0; j < MAX_TLAYER; j++)
3847	{
3848	m_bitRatePresentFlag [i][j] = false;
3849	m_picRatePresentFlag [i][j] = false;
3850	m_avgBitRate [i][j] = -1;
3851	m_maxBitRate [i][j] = -1;
3852	m_constantPicRateIdc [i][j] = -1;
3853	m_avgPicRate [i][j] = -1;
3854	}
3855	}
3856
3857	m_ilpRestrictedRefLayersFlag = false;
3858
3859	for ( Int i = 0; i < MAX_NUM_LAYERS; i++)
3860	{
3861	for ( Int j = 0; j < MAX_NUM_LAYERS; j++)
3862	{
3863	m_tileBoundariesAlignedFlag [i][j] = false;
3864	m_minSpatialSegmentOffsetPlus1[i][j] = 0;
3865	m_ctuBasedOffsetEnabledFlag [i][j] = false;
3866	m_minHorizontalCtuOffsetPlus1 [i][j] = -1;
3867	}
3868	#if H_MV_HLS_7_MISC_P0182_13
3869	m_baseLayerParameterSetCompatibilityFlag[i] = false;
3870	#endif
3871	}
3872	for ( Int i = 0; i < MAX_NUM_VIDEO_SIGNAL_INFO; i++ )
3873	{
3874	m_videoSignalInfo [i] = NULL;
3875	}
3876
3877	m_vpsVuiBspHrdPresentFlag = false;
3878	m_vpsVuiBspHrdParameters = new TComVpsVuiBspHrdParameters();
3879	}
3880
3881	TComVPSVUI::~TComVPSVUI()
3882	{
3883	for ( Int i = 0; i < MAX_NUM_VIDEO_SIGNAL_INFO; i++ )
3884	{
3885	if (m_videoSignalInfo[ i ] != NULL ) delete m_videoSignalInfo[ i ];
3886	m_videoSignalInfo [ i ] = NULL;
3887	}
3888
3889	if ( m_vpsVuiBspHrdParameters ) delete m_vpsVuiBspHrdParameters;
3890	m_vpsVuiBspHrdParameters = NULL;
3891	}
3892
3893	Void TComRepFormat::inferChromaAndBitDepth( TComRepFormat* prevRepFormat, Bool encoderFlag )
3894	{
3895	if ( !encoderFlag )
3896	{
3897	setChromaAndBitDepthVpsPresentFlag( prevRepFormat->getChromaAndBitDepthVpsPresentFlag() );
3898	setSeparateColourPlaneVpsFlag ( prevRepFormat->getSeparateColourPlaneVpsFlag () );
3899	setBitDepthVpsLumaMinus8 ( prevRepFormat->getBitDepthVpsLumaMinus8 () );
3900	setBitDepthVpsChromaMinus8 ( prevRepFormat->getBitDepthVpsChromaMinus8 () );
3901	}
3902	else
3903	{
3904	assert( getChromaAndBitDepthVpsPresentFlag() == prevRepFormat->getChromaAndBitDepthVpsPresentFlag() );
3905	assert( getSeparateColourPlaneVpsFlag () == prevRepFormat->getSeparateColourPlaneVpsFlag () );
3906	assert( getBitDepthVpsLumaMinus8 () == prevRepFormat->getBitDepthVpsLumaMinus8 () );
3907	assert( getBitDepthVpsChromaMinus8 () == prevRepFormat->getBitDepthVpsChromaMinus8 () );
3908	}
3909	}
3910
3911	Void TComVpsVuiBspHrdParameters::checkLayerInBspFlag( TComVPS* vps, Int h )
3912	{
3913	// It is a requirement of bitstream conformance that bitstream partition with index j shall not include
3914	// direct or indirect reference layers of any layers in bitstream partition i for any values of i and j
3915	// in the range of 0 to num_bitstream_partitions[ h ] ?1, inclusive, such that i is less than j.
3916
3917	for ( Int partJ = 0; partJ < getNumBitstreamPartitions( h ); partJ++ )
3918	{
3919	for ( Int partI = 0; partI < partJ; partI++ )
3920	{
3921	for ( Int layerJ = 0; layerJ < vps->getMaxLayersMinus1(); layerJ++ )
3922	{
3923	if ( m_layerInBspFlag[ h ][partJ][layerJ ] )
3924	{
3925	for ( Int layerI = 0; layerI < vps->getMaxLayersMinus1(); layerI++ )
3926	{
3927	if ( m_layerInBspFlag[ h ][partI][layerI] )
3928	{
3929	assert( !vps->getInDirectDependencyFlag( layerI, layerJ ) );
3930	}
3931	}
3932	}
3933	}
3934	}
3935	}
3936	}
3937
3938	Void TComVUI::inferVideoSignalInfo( TComVPS* vps, Int layerIdCurr )
3939	{
3940	if ( layerIdCurr == 0 \|\| !vps->getVpsVuiPresentFlag() )
3941	{
3942	return;
3943	}
3944
3945	TComVPSVUI* vpsVUI = vps->getVPSVUI();
3946	assert( vpsVUI != NULL );
3947
3948	TComVideoSignalInfo* videoSignalInfo = vpsVUI->getVideoSignalInfo( vpsVUI->getVpsVideoSignalInfoIdx( vps->getLayerIdInVps( layerIdCurr ) ) );
3949	assert( videoSignalInfo != NULL );
3950
3951	setVideoFormat ( videoSignalInfo->getVideoVpsFormat () );
3952	setVideoFullRangeFlag ( videoSignalInfo->getVideoFullRangeVpsFlag () );
3953	setColourPrimaries ( videoSignalInfo->getColourPrimariesVps () );
3954	setTransferCharacteristics( videoSignalInfo->getTransferCharacteristicsVps() );
3955	setMatrixCoefficients ( videoSignalInfo->getMatrixCoeffsVps () );
3956	}
3957	#endif

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

Download in other formats: