|
0
|
1 /* The copyright in this software is being made available under the BSD
|
|
|
2 * License, included below. This software may be subject to other third party
|
|
|
3 * and contributor rights, including patent rights, and no such rights are
|
|
|
4 * granted under this license.
|
|
|
5 *
|
|
|
6 * Copyright (c) 2010-2014, ITU/ISO/IEC
|
|
|
7 * All rights reserved.
|
|
|
8 *
|
|
|
9 * Redistribution and use in source and binary forms, with or without
|
|
|
10 * modification, are permitted provided that the following conditions are met:
|
|
|
11 *
|
|
|
12 * * Redistributions of source code must retain the above copyright notice,
|
|
|
13 * this list of conditions and the following disclaimer.
|
|
|
14 * * Redistributions in binary form must reproduce the above copyright notice,
|
|
|
15 * this list of conditions and the following disclaimer in the documentation
|
|
|
16 * and/or other materials provided with the distribution.
|
|
|
17 * * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
|
|
|
18 * be used to endorse or promote products derived from this software without
|
|
|
19 * specific prior written permission.
|
|
|
20 *
|
|
|
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
|
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
|
|
|
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
|
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
|
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
|
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
|
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
|
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
|
|
31 * THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
32 */
|
|
|
33
|
|
|
34 /** \file TComSlice.cpp
|
|
|
35 \brief slice header and SPS class
|
|
|
36 */
|
|
|
37
|
|
|
38 #include "CommonDef.h"
|
|
|
39 #include "TComSlice.h"
|
|
|
40 #include "TComPic.h"
|
|
|
41 #include "TLibEncoder/TEncSbac.h"
|
|
|
42 //#include "TLibDecoder/TDecSbac.h"
|
|
|
43
|
|
|
44
|
|
|
45 //! \ingroup TLibCommon
|
|
|
46 //! \{
|
|
|
47
|
|
|
48 TComSlice::TComSlice()
|
|
|
49 : m_iPPSId ( -1 )
|
|
|
50 , m_PicOutputFlag ( true )
|
|
|
51 , m_iPOC ( 0 )
|
|
|
52 , m_iLastIDR ( 0 )
|
|
|
53 , m_iAssociatedIRAP ( 0 )
|
|
|
54 , m_iAssociatedIRAPType ( NAL_UNIT_INVALID )
|
|
|
55 , m_pcRPS ( 0 )
|
|
|
56 , m_LocalRPS ( )
|
|
|
57 , m_iBDidx ( 0 )
|
|
|
58 , m_RefPicListModification ( )
|
|
|
59 , m_eNalUnitType ( NAL_UNIT_CODED_SLICE_IDR_W_RADL )
|
|
|
60 , m_eSliceType ( I_SLICE )
|
|
|
61 , m_iSliceQp ( 0 )
|
|
|
62 , m_dependentSliceSegmentFlag ( false )
|
|
|
63 #if ADAPTIVE_QP_SELECTION
|
|
|
64 , m_iSliceQpBase ( 0 )
|
|
|
65 #endif
|
|
|
66 , m_ChromaQpAdjEnabled ( false )
|
|
|
67 , m_deblockingFilterDisable ( false )
|
|
|
68 , m_deblockingFilterOverrideFlag ( false )
|
|
|
69 , m_deblockingFilterBetaOffsetDiv2( 0 )
|
|
|
70 , m_deblockingFilterTcOffsetDiv2 ( 0 )
|
|
|
71 , m_bCheckLDC ( false )
|
|
|
72 , m_iSliceQpDelta ( 0 )
|
|
|
73 , m_iDepth ( 0 )
|
|
|
74 , m_bRefenced ( false )
|
|
|
75 , m_pcVPS ( NULL )
|
|
|
76 , m_pcSPS ( NULL )
|
|
|
77 , m_pcPPS ( NULL )
|
|
|
78 , m_pcPic ( NULL )
|
|
|
79 #if ADAPTIVE_QP_SELECTION
|
|
|
80 , m_pcTrQuant ( NULL )
|
|
|
81 #endif
|
|
|
82 , m_colFromL0Flag ( 1 )
|
|
|
83 , m_noOutputPriorPicsFlag ( false )
|
|
|
84 , m_noRaslOutputFlag ( false )
|
|
|
85 , m_handleCraAsBlaFlag ( false )
|
|
|
86 , m_colRefIdx ( 0 )
|
|
|
87 , m_maxNumMergeCand ( 0 )
|
|
|
88 , m_uiTLayer ( 0 )
|
|
|
89 , m_bTLayerSwitchingFlag ( false )
|
|
|
90 , m_sliceMode ( NO_SLICES )
|
|
|
91 , m_sliceArgument ( 0 )
|
|
|
92 , m_sliceCurStartCtuTsAddr ( 0 )
|
|
|
93 , m_sliceCurEndCtuTsAddr ( 0 )
|
|
|
94 , m_sliceIdx ( 0 )
|
|
|
95 , m_sliceSegmentMode ( NO_SLICES )
|
|
|
96 , m_sliceSegmentArgument ( 0 )
|
|
|
97 , m_sliceSegmentCurStartCtuTsAddr ( 0 )
|
|
|
98 , m_sliceSegmentCurEndCtuTsAddr ( 0 )
|
|
|
99 , m_nextSlice ( false )
|
|
|
100 , m_nextSliceSegment ( false )
|
|
|
101 , m_sliceBits ( 0 )
|
|
|
102 , m_sliceSegmentBits ( 0 )
|
|
|
103 , m_bFinalized ( false )
|
|
|
104 , m_substreamSizes ( )
|
|
|
105 , m_scalingList ( NULL )
|
|
|
106 , m_cabacInitFlag ( false )
|
|
|
107 , m_bLMvdL1Zero ( false )
|
|
|
108 , m_temporalLayerNonReferenceFlag ( false )
|
|
|
109 , m_LFCrossSliceBoundaryFlag ( false )
|
|
|
110 , m_enableTMVPFlag ( true )
|
|
|
111 {
|
|
|
112 for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
|
|
|
113 {
|
|
|
114 m_aiNumRefIdx[i] = 0;
|
|
|
115 }
|
|
|
116
|
|
|
117 for (UInt component = 0; component < MAX_NUM_COMPONENT; component++)
|
|
|
118 {
|
|
|
119 m_lambdas [component] = 0.0;
|
|
|
120 m_iSliceChromaQpDelta[component] = 0;
|
|
|
121 }
|
|
|
122
|
|
|
123 initEqualRef();
|
|
|
124
|
|
|
125 for ( Int idx = 0; idx < MAX_NUM_REF; idx++ )
|
|
|
126 {
|
|
|
127 m_list1IdxToList0Idx[idx] = -1;
|
|
|
128 }
|
|
|
129
|
|
|
130 for(Int iNumCount = 0; iNumCount < MAX_NUM_REF; iNumCount++)
|
|
|
131 {
|
|
|
132 for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
|
|
|
133 {
|
|
|
134 m_apcRefPicList [i][iNumCount] = NULL;
|
|
|
135 m_aiRefPOCList [i][iNumCount] = 0;
|
|
|
136 }
|
|
|
137 }
|
|
|
138
|
|
|
139 resetWpScaling();
|
|
|
140 initWpAcDcParam();
|
|
|
141
|
|
|
142 for(Int ch=0; ch < MAX_NUM_CHANNEL_TYPE; ch++)
|
|
|
143 {
|
|
|
144 m_saoEnabledFlag[ch] = false;
|
|
|
145 }
|
|
|
146 }
|
|
|
147
|
|
|
148 TComSlice::~TComSlice()
|
|
|
149 {
|
|
|
150 }
|
|
|
151
|
|
|
152
|
|
|
153 Void TComSlice::initSlice()
|
|
|
154 {
|
|
|
155 for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
|
|
|
156 {
|
|
|
157 m_aiNumRefIdx[i] = 0;
|
|
|
158 }
|
|
|
159 m_colFromL0Flag = 1;
|
|
|
160
|
|
|
161 m_colRefIdx = 0;
|
|
|
162 initEqualRef();
|
|
|
163
|
|
|
164 m_bCheckLDC = false;
|
|
|
165
|
|
|
166 for (UInt component = 0; component < MAX_NUM_COMPONENT; component++) m_iSliceChromaQpDelta[component] = 0;
|
|
|
167
|
|
|
168 m_maxNumMergeCand = MRG_MAX_NUM_CANDS;
|
|
|
169
|
|
|
170 m_bFinalized=false;
|
|
|
171
|
|
|
172 m_substreamSizes.clear();
|
|
|
173 m_cabacInitFlag = false;
|
|
|
174 m_enableTMVPFlag = true;
|
|
|
175 }
|
|
|
176
|
|
|
177 Bool TComSlice::getRapPicFlag()
|
|
|
178 {
|
|
|
179 return getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
|
|
|
180 || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP
|
|
|
181 || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
|
|
|
182 || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
|
|
|
183 || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
|
|
|
184 || getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA;
|
|
|
185 }
|
|
|
186
|
|
|
187
|
|
|
188 Void TComSlice::sortPicList (TComList<TComPic*>& rcListPic)
|
|
|
189 {
|
|
|
190 TComPic* pcPicExtract;
|
|
|
191 TComPic* pcPicInsert;
|
|
|
192
|
|
|
193 TComList<TComPic*>::iterator iterPicExtract;
|
|
|
194 TComList<TComPic*>::iterator iterPicExtract_1;
|
|
|
195 TComList<TComPic*>::iterator iterPicInsert;
|
|
|
196
|
|
|
197 for (Int i = 1; i < (Int)(rcListPic.size()); i++)
|
|
|
198 {
|
|
|
199 iterPicExtract = rcListPic.begin();
|
|
|
200 for (Int j = 0; j < i; j++) iterPicExtract++;
|
|
|
201 pcPicExtract = *(iterPicExtract);
|
|
|
202 pcPicExtract->setCurrSliceIdx(0);
|
|
|
203
|
|
|
204 iterPicInsert = rcListPic.begin();
|
|
|
205 while (iterPicInsert != iterPicExtract)
|
|
|
206 {
|
|
|
207 pcPicInsert = *(iterPicInsert);
|
|
|
208 pcPicInsert->setCurrSliceIdx(0);
|
|
|
209 if (pcPicInsert->getPOC() >= pcPicExtract->getPOC())
|
|
|
210 {
|
|
|
211 break;
|
|
|
212 }
|
|
|
213
|
|
|
214 iterPicInsert++;
|
|
|
215 }
|
|
|
216
|
|
|
217 iterPicExtract_1 = iterPicExtract; iterPicExtract_1++;
|
|
|
218
|
|
|
219 // swap iterPicExtract and iterPicInsert, iterPicExtract = curr. / iterPicInsert = insertion position
|
|
|
220 rcListPic.insert (iterPicInsert, iterPicExtract, iterPicExtract_1);
|
|
|
221 rcListPic.erase (iterPicExtract);
|
|
|
222 }
|
|
|
223 }
|
|
|
224
|
|
|
225 TComPic* TComSlice::xGetRefPic (TComList<TComPic*>& rcListPic, Int poc)
|
|
|
226 {
|
|
|
227 TComList<TComPic*>::iterator iterPic = rcListPic.begin();
|
|
|
228 TComPic* pcPic = *(iterPic);
|
|
|
229 while ( iterPic != rcListPic.end() )
|
|
|
230 {
|
|
|
231 if(pcPic->getPOC() == poc)
|
|
|
232 {
|
|
|
233 break;
|
|
|
234 }
|
|
|
235 iterPic++;
|
|
|
236 pcPic = *(iterPic);
|
|
|
237 }
|
|
|
238 return pcPic;
|
|
|
239 }
|
|
|
240
|
|
|
241
|
|
|
242 TComPic* TComSlice::xGetLongTermRefPic(TComList<TComPic*>& rcListPic, Int poc, Bool pocHasMsb)
|
|
|
243 {
|
|
|
244 TComList<TComPic*>::iterator iterPic = rcListPic.begin();
|
|
|
245 TComPic* pcPic = *(iterPic);
|
|
|
246 TComPic* pcStPic = pcPic;
|
|
|
247
|
|
|
248 Int pocCycle = 1 << getSPS()->getBitsForPOC();
|
|
|
249 if (!pocHasMsb)
|
|
|
250 {
|
|
|
251 poc = poc & (pocCycle - 1);
|
|
|
252 }
|
|
|
253
|
|
|
254 while ( iterPic != rcListPic.end() )
|
|
|
255 {
|
|
|
256 pcPic = *(iterPic);
|
|
|
257 if (pcPic && pcPic->getPOC()!=this->getPOC() && pcPic->getSlice( 0 )->isReferenced())
|
|
|
258 {
|
|
|
259 Int picPoc = pcPic->getPOC();
|
|
|
260 if (!pocHasMsb)
|
|
|
261 {
|
|
|
262 picPoc = picPoc & (pocCycle - 1);
|
|
|
263 }
|
|
|
264
|
|
|
265 if (poc == picPoc)
|
|
|
266 {
|
|
|
267 if(pcPic->getIsLongTerm())
|
|
|
268 {
|
|
|
269 return pcPic;
|
|
|
270 }
|
|
|
271 else
|
|
|
272 {
|
|
|
273 pcStPic = pcPic;
|
|
|
274 }
|
|
|
275 break;
|
|
|
276 }
|
|
|
277 }
|
|
|
278
|
|
|
279 iterPic++;
|
|
|
280 }
|
|
|
281
|
|
|
282 return pcStPic;
|
|
|
283 }
|
|
|
284
|
|
|
285 Void TComSlice::setRefPOCList ()
|
|
|
286 {
|
|
|
287 for (Int iDir = 0; iDir < NUM_REF_PIC_LIST_01; iDir++)
|
|
|
288 {
|
|
|
289 for (Int iNumRefIdx = 0; iNumRefIdx < m_aiNumRefIdx[iDir]; iNumRefIdx++)
|
|
|
290 {
|
|
|
291 m_aiRefPOCList[iDir][iNumRefIdx] = m_apcRefPicList[iDir][iNumRefIdx]->getPOC();
|
|
|
292 }
|
|
|
293 }
|
|
|
294
|
|
|
295 }
|
|
|
296
|
|
|
297 Void TComSlice::setList1IdxToList0Idx()
|
|
|
298 {
|
|
|
299 Int idxL0, idxL1;
|
|
|
300 for ( idxL1 = 0; idxL1 < getNumRefIdx( REF_PIC_LIST_1 ); idxL1++ )
|
|
|
301 {
|
|
|
302 m_list1IdxToList0Idx[idxL1] = -1;
|
|
|
303 for ( idxL0 = 0; idxL0 < getNumRefIdx( REF_PIC_LIST_0 ); idxL0++ )
|
|
|
304 {
|
|
|
305 if ( m_apcRefPicList[REF_PIC_LIST_0][idxL0]->getPOC() == m_apcRefPicList[REF_PIC_LIST_1][idxL1]->getPOC() )
|
|
|
306 {
|
|
|
307 m_list1IdxToList0Idx[idxL1] = idxL0;
|
|
|
308 break;
|
|
|
309 }
|
|
|
310 }
|
|
|
311 }
|
|
|
312 }
|
|
|
313
|
|
|
314 Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr )
|
|
|
315 {
|
|
|
316 if (!checkNumPocTotalCurr)
|
|
|
317 {
|
|
|
318 if (m_eSliceType == I_SLICE)
|
|
|
319 {
|
|
|
320 ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
|
|
|
321 ::memset( m_aiNumRefIdx, 0, sizeof ( m_aiNumRefIdx ));
|
|
|
322
|
|
|
323 return;
|
|
|
324 }
|
|
|
325
|
|
|
326 m_aiNumRefIdx[REF_PIC_LIST_0] = getNumRefIdx(REF_PIC_LIST_0);
|
|
|
327 m_aiNumRefIdx[REF_PIC_LIST_1] = getNumRefIdx(REF_PIC_LIST_1);
|
|
|
328 }
|
|
|
329
|
|
|
330 TComPic* pcRefPic= NULL;
|
|
|
331 static const UInt MAX_NUM_NEGATIVE_PICTURES=16;
|
|
|
332 TComPic* RefPicSetStCurr0[MAX_NUM_NEGATIVE_PICTURES];
|
|
|
333 TComPic* RefPicSetStCurr1[MAX_NUM_NEGATIVE_PICTURES];
|
|
|
334 TComPic* RefPicSetLtCurr[MAX_NUM_NEGATIVE_PICTURES];
|
|
|
335 UInt NumPocStCurr0 = 0;
|
|
|
336 UInt NumPocStCurr1 = 0;
|
|
|
337 UInt NumPocLtCurr = 0;
|
|
|
338 Int i;
|
|
|
339
|
|
|
340 for(i=0; i < m_pcRPS->getNumberOfNegativePictures(); i++)
|
|
|
341 {
|
|
|
342 if(m_pcRPS->getUsed(i))
|
|
|
343 {
|
|
|
344 pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
|
|
|
345 pcRefPic->setIsLongTerm(0);
|
|
|
346 pcRefPic->getPicYuvRec()->extendPicBorder();
|
|
|
347 RefPicSetStCurr0[NumPocStCurr0] = pcRefPic;
|
|
|
348 NumPocStCurr0++;
|
|
|
349 pcRefPic->setCheckLTMSBPresent(false);
|
|
|
350 }
|
|
|
351 }
|
|
|
352
|
|
|
353 for(; i < m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures(); i++)
|
|
|
354 {
|
|
|
355 if(m_pcRPS->getUsed(i))
|
|
|
356 {
|
|
|
357 pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
|
|
|
358 pcRefPic->setIsLongTerm(0);
|
|
|
359 pcRefPic->getPicYuvRec()->extendPicBorder();
|
|
|
360 RefPicSetStCurr1[NumPocStCurr1] = pcRefPic;
|
|
|
361 NumPocStCurr1++;
|
|
|
362 pcRefPic->setCheckLTMSBPresent(false);
|
|
|
363 }
|
|
|
364 }
|
|
|
365
|
|
|
366 for(i = m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()+m_pcRPS->getNumberOfLongtermPictures()-1; i > m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()-1 ; i--)
|
|
|
367 {
|
|
|
368 if(m_pcRPS->getUsed(i))
|
|
|
369 {
|
|
|
370 pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
|
|
|
371 pcRefPic->setIsLongTerm(1);
|
|
|
372 pcRefPic->getPicYuvRec()->extendPicBorder();
|
|
|
373 RefPicSetLtCurr[NumPocLtCurr] = pcRefPic;
|
|
|
374 NumPocLtCurr++;
|
|
|
375 }
|
|
|
376 if(pcRefPic==NULL)
|
|
|
377 {
|
|
|
378 pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
|
|
|
379 }
|
|
|
380 pcRefPic->setCheckLTMSBPresent(m_pcRPS->getCheckLTMSBPresent(i));
|
|
|
381 }
|
|
|
382
|
|
|
383 // ref_pic_list_init
|
|
|
384 TComPic* rpsCurrList0[MAX_NUM_REF+1];
|
|
|
385 TComPic* rpsCurrList1[MAX_NUM_REF+1];
|
|
|
386 Int numPocTotalCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr;
|
|
|
387
|
|
|
388 if (checkNumPocTotalCurr)
|
|
|
389 {
|
|
|
390 // 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:
|
|
|
391 // - If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
|
|
|
392 // - Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
|
|
|
393 if (getRapPicFlag())
|
|
|
394 {
|
|
|
395 assert(numPocTotalCurr == 0);
|
|
|
396 }
|
|
|
397
|
|
|
398 if (m_eSliceType == I_SLICE)
|
|
|
399 {
|
|
|
400 ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
|
|
|
401 ::memset( m_aiNumRefIdx, 0, sizeof ( m_aiNumRefIdx ));
|
|
|
402
|
|
|
403 return;
|
|
|
404 }
|
|
|
405
|
|
|
406 assert(numPocTotalCurr > 0);
|
|
|
407
|
|
|
408 m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
|
|
|
409 m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
|
|
|
410 }
|
|
|
411
|
|
|
412 Int cIdx = 0;
|
|
|
413 for ( i=0; i<NumPocStCurr0; i++, cIdx++)
|
|
|
414 {
|
|
|
415 rpsCurrList0[cIdx] = RefPicSetStCurr0[i];
|
|
|
416 }
|
|
|
417 for ( i=0; i<NumPocStCurr1; i++, cIdx++)
|
|
|
418 {
|
|
|
419 rpsCurrList0[cIdx] = RefPicSetStCurr1[i];
|
|
|
420 }
|
|
|
421 for ( i=0; i<NumPocLtCurr; i++, cIdx++)
|
|
|
422 {
|
|
|
423 rpsCurrList0[cIdx] = RefPicSetLtCurr[i];
|
|
|
424 }
|
|
|
425 assert(cIdx == numPocTotalCurr);
|
|
|
426
|
|
|
427 if (m_eSliceType==B_SLICE)
|
|
|
428 {
|
|
|
429 cIdx = 0;
|
|
|
430 for ( i=0; i<NumPocStCurr1; i++, cIdx++)
|
|
|
431 {
|
|
|
432 rpsCurrList1[cIdx] = RefPicSetStCurr1[i];
|
|
|
433 }
|
|
|
434 for ( i=0; i<NumPocStCurr0; i++, cIdx++)
|
|
|
435 {
|
|
|
436 rpsCurrList1[cIdx] = RefPicSetStCurr0[i];
|
|
|
437 }
|
|
|
438 for ( i=0; i<NumPocLtCurr; i++, cIdx++)
|
|
|
439 {
|
|
|
440 rpsCurrList1[cIdx] = RefPicSetLtCurr[i];
|
|
|
441 }
|
|
|
442 assert(cIdx == numPocTotalCurr);
|
|
|
443 }
|
|
|
444
|
|
|
445 ::memset(m_bIsUsedAsLongTerm, 0, sizeof(m_bIsUsedAsLongTerm));
|
|
|
446
|
|
|
447 for (Int rIdx = 0; rIdx < m_aiNumRefIdx[REF_PIC_LIST_0]; rIdx ++)
|
|
|
448 {
|
|
|
449 cIdx = m_RefPicListModification.getRefPicListModificationFlagL0() ? m_RefPicListModification.getRefPicSetIdxL0(rIdx) : rIdx % numPocTotalCurr;
|
|
|
450 assert(cIdx >= 0 && cIdx < numPocTotalCurr);
|
|
|
451 m_apcRefPicList[REF_PIC_LIST_0][rIdx] = rpsCurrList0[ cIdx ];
|
|
|
452 m_bIsUsedAsLongTerm[REF_PIC_LIST_0][rIdx] = ( cIdx >= NumPocStCurr0 + NumPocStCurr1 );
|
|
|
453 }
|
|
|
454 if ( m_eSliceType != B_SLICE )
|
|
|
455 {
|
|
|
456 m_aiNumRefIdx[REF_PIC_LIST_1] = 0;
|
|
|
457 ::memset( m_apcRefPicList[REF_PIC_LIST_1], 0, sizeof(m_apcRefPicList[REF_PIC_LIST_1]));
|
|
|
458 }
|
|
|
459 else
|
|
|
460 {
|
|
|
461 for (Int rIdx = 0; rIdx < m_aiNumRefIdx[REF_PIC_LIST_1]; rIdx ++)
|
|
|
462 {
|
|
|
463 cIdx = m_RefPicListModification.getRefPicListModificationFlagL1() ? m_RefPicListModification.getRefPicSetIdxL1(rIdx) : rIdx % numPocTotalCurr;
|
|
|
464 assert(cIdx >= 0 && cIdx < numPocTotalCurr);
|
|
|
465 m_apcRefPicList[REF_PIC_LIST_1][rIdx] = rpsCurrList1[ cIdx ];
|
|
|
466 m_bIsUsedAsLongTerm[REF_PIC_LIST_1][rIdx] = ( cIdx >= NumPocStCurr0 + NumPocStCurr1 );
|
|
|
467 }
|
|
|
468 }
|
|
|
469 }
|
|
|
470
|
|
|
471 Int TComSlice::getNumRpsCurrTempList()
|
|
|
472 {
|
|
|
473 Int numRpsCurrTempList = 0;
|
|
|
474
|
|
|
475 if (m_eSliceType == I_SLICE)
|
|
|
476 {
|
|
|
477 return 0;
|
|
|
478 }
|
|
|
479 for(UInt i=0; i < m_pcRPS->getNumberOfNegativePictures()+ m_pcRPS->getNumberOfPositivePictures() + m_pcRPS->getNumberOfLongtermPictures(); i++)
|
|
|
480 {
|
|
|
481 if(m_pcRPS->getUsed(i))
|
|
|
482 {
|
|
|
483 numRpsCurrTempList++;
|
|
|
484 }
|
|
|
485 }
|
|
|
486 return numRpsCurrTempList;
|
|
|
487 }
|
|
|
488
|
|
|
489 Void TComSlice::initEqualRef()
|
|
|
490 {
|
|
|
491 for (Int iDir = 0; iDir < NUM_REF_PIC_LIST_01; iDir++)
|
|
|
492 {
|
|
|
493 for (Int iRefIdx1 = 0; iRefIdx1 < MAX_NUM_REF; iRefIdx1++)
|
|
|
494 {
|
|
|
495 for (Int iRefIdx2 = iRefIdx1; iRefIdx2 < MAX_NUM_REF; iRefIdx2++)
|
|
|
496 {
|
|
|
497 m_abEqualRef[iDir][iRefIdx1][iRefIdx2] = m_abEqualRef[iDir][iRefIdx2][iRefIdx1] = (iRefIdx1 == iRefIdx2? true : false);
|
|
|
498 }
|
|
|
499 }
|
|
|
500 }
|
|
|
501 }
|
|
|
502
|
|
|
503 Void TComSlice::checkColRefIdx(UInt curSliceIdx, TComPic* pic)
|
|
|
504 {
|
|
|
505 Int i;
|
|
|
506 TComSlice* curSlice = pic->getSlice(curSliceIdx);
|
|
|
507 Int currColRefPOC = curSlice->getRefPOC( RefPicList(1 - curSlice->getColFromL0Flag()), curSlice->getColRefIdx());
|
|
|
508 TComSlice* preSlice;
|
|
|
509 Int preColRefPOC;
|
|
|
510 for(i=curSliceIdx-1; i>=0; i--)
|
|
|
511 {
|
|
|
512 preSlice = pic->getSlice(i);
|
|
|
513 if(preSlice->getSliceType() != I_SLICE)
|
|
|
514 {
|
|
|
515 preColRefPOC = preSlice->getRefPOC( RefPicList(1 - preSlice->getColFromL0Flag()), preSlice->getColRefIdx());
|
|
|
516 if(currColRefPOC != preColRefPOC)
|
|
|
517 {
|
|
|
518 printf("Collocated_ref_idx shall always be the same for all slices of a coded picture!\n");
|
|
|
519 exit(EXIT_FAILURE);
|
|
|
520 }
|
|
|
521 else
|
|
|
522 {
|
|
|
523 break;
|
|
|
524 }
|
|
|
525 }
|
|
|
526 }
|
|
|
527 }
|
|
|
528
|
|
|
529 Void TComSlice::checkCRA(TComReferencePictureSet *pReferencePictureSet, Int& pocCRA, NalUnitType& associatedIRAPType, TComList<TComPic *>& rcListPic)
|
|
|
530 {
|
|
|
531 for(Int i = 0; i < pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures(); i++)
|
|
|
532 {
|
|
|
533 if(pocCRA < MAX_UINT && getPOC() > pocCRA)
|
|
|
534 {
|
|
|
535 assert(getPOC()+pReferencePictureSet->getDeltaPOC(i) >= pocCRA);
|
|
|
536 }
|
|
|
537 }
|
|
|
538 for(Int i = pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures(); i < pReferencePictureSet->getNumberOfPictures(); i++)
|
|
|
539 {
|
|
|
540 if(pocCRA < MAX_UINT && getPOC() > pocCRA)
|
|
|
541 {
|
|
|
542 if (!pReferencePictureSet->getCheckLTMSBPresent(i))
|
|
|
543 {
|
|
|
544 assert(xGetLongTermRefPic(rcListPic, pReferencePictureSet->getPOC(i), false)->getPOC() >= pocCRA);
|
|
|
545 }
|
|
|
546 else
|
|
|
547 {
|
|
|
548 assert(pReferencePictureSet->getPOC(i) >= pocCRA);
|
|
|
549 }
|
|
|
550 }
|
|
|
551 }
|
|
|
552 if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ) // IDR picture found
|
|
|
553 {
|
|
|
554 pocCRA = getPOC();
|
|
|
555 associatedIRAPType = getNalUnitType();
|
|
|
556 }
|
|
|
557 else if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA ) // CRA picture found
|
|
|
558 {
|
|
|
559 pocCRA = getPOC();
|
|
|
560 associatedIRAPType = getNalUnitType();
|
|
|
561 }
|
|
|
562 else if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
|
|
|
563 || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
|
|
|
564 || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP ) // BLA picture found
|
|
|
565 {
|
|
|
566 pocCRA = getPOC();
|
|
|
567 associatedIRAPType = getNalUnitType();
|
|
|
568 }
|
|
|
569 }
|
|
|
570
|
|
|
571 /** Function for marking the reference pictures when an IDR/CRA/CRANT/BLA/BLANT is encountered.
|
|
|
572 * \param pocCRA POC of the CRA/CRANT/BLA/BLANT picture
|
|
|
573 * \param bRefreshPending flag indicating if a deferred decoding refresh is pending
|
|
|
574 * \param rcListPic reference to the reference picture list
|
|
|
575 * This function marks the reference pictures as "unused for reference" in the following conditions.
|
|
|
576 * If the nal_unit_type is IDR/BLA/BLANT, all pictures in the reference picture list
|
|
|
577 * are marked as "unused for reference"
|
|
|
578 * If the nal_unit_type is BLA/BLANT, set the pocCRA to the temporal reference of the current picture.
|
|
|
579 * Otherwise
|
|
|
580 * If the bRefreshPending flag is true (a deferred decoding refresh is pending) and the current
|
|
|
581 * temporal reference is greater than the temporal reference of the latest CRA/CRANT/BLA/BLANT picture (pocCRA),
|
|
|
582 * mark all reference pictures except the latest CRA/CRANT/BLA/BLANT picture as "unused for reference" and set
|
|
|
583 * the bRefreshPending flag to false.
|
|
|
584 * If the nal_unit_type is CRA/CRANT, set the bRefreshPending flag to true and pocCRA to the temporal
|
|
|
585 * reference of the current picture.
|
|
|
586 * Note that the current picture is already placed in the reference list and its marking is not changed.
|
|
|
587 * If the current picture has a nal_ref_idc that is not 0, it will remain marked as "used for reference".
|
|
|
588 */
|
|
|
589 Void TComSlice::decodingRefreshMarking(Int& pocCRA, Bool& bRefreshPending, TComList<TComPic*>& rcListPic)
|
|
|
590 {
|
|
|
591 TComPic* rpcPic;
|
|
|
592 Int pocCurr = getPOC();
|
|
|
593
|
|
|
594 if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
|
|
|
595 || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
|
|
|
596 || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
|
|
|
597 || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
|
|
|
598 || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ) // IDR or BLA picture
|
|
|
599 {
|
|
|
600 // mark all pictures as not used for reference
|
|
|
601 TComList<TComPic*>::iterator iterPic = rcListPic.begin();
|
|
|
602 while (iterPic != rcListPic.end())
|
|
|
603 {
|
|
|
604 rpcPic = *(iterPic);
|
|
|
605 rpcPic->setCurrSliceIdx(0);
|
|
|
606 if (rpcPic->getPOC() != pocCurr) rpcPic->getSlice(0)->setReferenced(false);
|
|
|
607 iterPic++;
|
|
|
608 }
|
|
|
609 if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
|
|
|
610 || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
|
|
|
611 || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP )
|
|
|
612 {
|
|
|
613 pocCRA = pocCurr;
|
|
|
614 }
|
|
|
615 #if EFFICIENT_FIELD_IRAP
|
|
|
616 bRefreshPending = true;
|
|
|
617 #endif
|
|
|
618 }
|
|
|
619 else // CRA or No DR
|
|
|
620 {
|
|
|
621 #if EFFICIENT_FIELD_IRAP
|
|
|
622 if(getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_IDR_N_LP || getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL)
|
|
|
623 {
|
|
|
624 if (bRefreshPending==true && pocCurr > m_iLastIDR) // IDR reference marking pending
|
|
|
625 {
|
|
|
626 TComList<TComPic*>::iterator iterPic = rcListPic.begin();
|
|
|
627 while (iterPic != rcListPic.end())
|
|
|
628 {
|
|
|
629 rpcPic = *(iterPic);
|
|
|
630 if (rpcPic->getPOC() != pocCurr && rpcPic->getPOC() != m_iLastIDR)
|
|
|
631 {
|
|
|
632 rpcPic->getSlice(0)->setReferenced(false);
|
|
|
633 }
|
|
|
634 iterPic++;
|
|
|
635 }
|
|
|
636 bRefreshPending = false;
|
|
|
637 }
|
|
|
638 }
|
|
|
639 else
|
|
|
640 {
|
|
|
641 #endif
|
|
|
642 if (bRefreshPending==true && pocCurr > pocCRA) // CRA reference marking pending
|
|
|
643 {
|
|
|
644 TComList<TComPic*>::iterator iterPic = rcListPic.begin();
|
|
|
645 while (iterPic != rcListPic.end())
|
|
|
646 {
|
|
|
647 rpcPic = *(iterPic);
|
|
|
648 if (rpcPic->getPOC() != pocCurr && rpcPic->getPOC() != pocCRA)
|
|
|
649 {
|
|
|
650 rpcPic->getSlice(0)->setReferenced(false);
|
|
|
651 }
|
|
|
652 iterPic++;
|
|
|
653 }
|
|
|
654 bRefreshPending = false;
|
|
|
655 }
|
|
|
656 #if EFFICIENT_FIELD_IRAP
|
|
|
657 }
|
|
|
658 #endif
|
|
|
659 if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA ) // CRA picture found
|
|
|
660 {
|
|
|
661 bRefreshPending = true;
|
|
|
662 pocCRA = pocCurr;
|
|
|
663 }
|
|
|
664 }
|
|
|
665 }
|
|
|
666
|
|
|
667 Void TComSlice::copySliceInfo(TComSlice *pSrc)
|
|
|
668 {
|
|
|
669 assert( pSrc != NULL );
|
|
|
670
|
|
|
671 Int i, j, k;
|
|
|
672
|
|
|
673 m_iPOC = pSrc->m_iPOC;
|
|
|
674 m_eNalUnitType = pSrc->m_eNalUnitType;
|
|
|
675 m_eSliceType = pSrc->m_eSliceType;
|
|
|
676 m_iSliceQp = pSrc->m_iSliceQp;
|
|
|
677 #if ADAPTIVE_QP_SELECTION
|
|
|
678 m_iSliceQpBase = pSrc->m_iSliceQpBase;
|
|
|
679 #endif
|
|
|
680 m_ChromaQpAdjEnabled = pSrc->m_ChromaQpAdjEnabled;
|
|
|
681 m_deblockingFilterDisable = pSrc->m_deblockingFilterDisable;
|
|
|
682 m_deblockingFilterOverrideFlag = pSrc->m_deblockingFilterOverrideFlag;
|
|
|
683 m_deblockingFilterBetaOffsetDiv2 = pSrc->m_deblockingFilterBetaOffsetDiv2;
|
|
|
684 m_deblockingFilterTcOffsetDiv2 = pSrc->m_deblockingFilterTcOffsetDiv2;
|
|
|
685
|
|
|
686 for (i = 0; i < NUM_REF_PIC_LIST_01; i++)
|
|
|
687 {
|
|
|
688 m_aiNumRefIdx[i] = pSrc->m_aiNumRefIdx[i];
|
|
|
689 }
|
|
|
690
|
|
|
691 for (i = 0; i < MAX_NUM_REF; i++)
|
|
|
692 {
|
|
|
693 m_list1IdxToList0Idx[i] = pSrc->m_list1IdxToList0Idx[i];
|
|
|
694 }
|
|
|
695
|
|
|
696 m_bCheckLDC = pSrc->m_bCheckLDC;
|
|
|
697 m_iSliceQpDelta = pSrc->m_iSliceQpDelta;
|
|
|
698 for (UInt component = 0; component < MAX_NUM_COMPONENT; component++) m_iSliceChromaQpDelta[component] = pSrc->m_iSliceChromaQpDelta[component];
|
|
|
699 for (i = 0; i < NUM_REF_PIC_LIST_01; i++)
|
|
|
700 {
|
|
|
701 for (j = 0; j < MAX_NUM_REF; j++)
|
|
|
702 {
|
|
|
703 m_apcRefPicList[i][j] = pSrc->m_apcRefPicList[i][j];
|
|
|
704 m_aiRefPOCList[i][j] = pSrc->m_aiRefPOCList[i][j];
|
|
|
705 m_bIsUsedAsLongTerm[i][j] = pSrc->m_bIsUsedAsLongTerm[i][j];
|
|
|
706 }
|
|
|
707 m_bIsUsedAsLongTerm[i][MAX_NUM_REF] = pSrc->m_bIsUsedAsLongTerm[i][MAX_NUM_REF];
|
|
|
708 }
|
|
|
709 m_iDepth = pSrc->m_iDepth;
|
|
|
710
|
|
|
711 // referenced slice
|
|
|
712 m_bRefenced = pSrc->m_bRefenced;
|
|
|
713
|
|
|
714 // access channel
|
|
|
715 m_pcSPS = pSrc->m_pcSPS;
|
|
|
716 m_pcPPS = pSrc->m_pcPPS;
|
|
|
717 m_pcRPS = pSrc->m_pcRPS;
|
|
|
718 m_iLastIDR = pSrc->m_iLastIDR;
|
|
|
719
|
|
|
720 m_pcPic = pSrc->m_pcPic;
|
|
|
721
|
|
|
722 m_colFromL0Flag = pSrc->m_colFromL0Flag;
|
|
|
723 m_colRefIdx = pSrc->m_colRefIdx;
|
|
|
724
|
|
|
725 setLambdas(pSrc->getLambdas());
|
|
|
726
|
|
|
727 for (i = 0; i < NUM_REF_PIC_LIST_01; i++)
|
|
|
728 {
|
|
|
729 for (j = 0; j < MAX_NUM_REF; j++)
|
|
|
730 {
|
|
|
731 for (k =0; k < MAX_NUM_REF; k++)
|
|
|
732 {
|
|
|
733 m_abEqualRef[i][j][k] = pSrc->m_abEqualRef[i][j][k];
|
|
|
734 }
|
|
|
735 }
|
|
|
736 }
|
|
|
737
|
|
|
738 m_uiTLayer = pSrc->m_uiTLayer;
|
|
|
739 m_bTLayerSwitchingFlag = pSrc->m_bTLayerSwitchingFlag;
|
|
|
740
|
|
|
741 m_sliceMode = pSrc->m_sliceMode;
|
|
|
742 m_sliceArgument = pSrc->m_sliceArgument;
|
|
|
743 m_sliceCurStartCtuTsAddr = pSrc->m_sliceCurStartCtuTsAddr;
|
|
|
744 m_sliceCurEndCtuTsAddr = pSrc->m_sliceCurEndCtuTsAddr;
|
|
|
745 m_sliceIdx = pSrc->m_sliceIdx;
|
|
|
746 m_sliceSegmentMode = pSrc->m_sliceSegmentMode;
|
|
|
747 m_sliceSegmentArgument = pSrc->m_sliceSegmentArgument;
|
|
|
748 m_sliceSegmentCurStartCtuTsAddr = pSrc->m_sliceSegmentCurStartCtuTsAddr;
|
|
|
749 m_sliceSegmentCurEndCtuTsAddr = pSrc->m_sliceSegmentCurEndCtuTsAddr;
|
|
|
750 m_nextSlice = pSrc->m_nextSlice;
|
|
|
751 m_nextSliceSegment = pSrc->m_nextSliceSegment;
|
|
|
752
|
|
|
753 for ( UInt e=0 ; e<NUM_REF_PIC_LIST_01 ; e++ )
|
|
|
754 {
|
|
|
755 for ( UInt n=0 ; n<MAX_NUM_REF ; n++ )
|
|
|
756 {
|
|
|
757 memcpy(m_weightPredTable[e][n], pSrc->m_weightPredTable[e][n], sizeof(WPScalingParam)*MAX_NUM_COMPONENT );
|
|
|
758 }
|
|
|
759 }
|
|
|
760
|
|
|
761 for( UInt ch = 0 ; ch < MAX_NUM_CHANNEL_TYPE; ch++)
|
|
|
762 {
|
|
|
763 m_saoEnabledFlag[ch] = pSrc->m_saoEnabledFlag[ch];
|
|
|
764 }
|
|
|
765
|
|
|
766 m_cabacInitFlag = pSrc->m_cabacInitFlag;
|
|
|
767
|
|
|
768 m_bLMvdL1Zero = pSrc->m_bLMvdL1Zero;
|
|
|
769 m_LFCrossSliceBoundaryFlag = pSrc->m_LFCrossSliceBoundaryFlag;
|
|
|
770 m_enableTMVPFlag = pSrc->m_enableTMVPFlag;
|
|
|
771 m_maxNumMergeCand = pSrc->m_maxNumMergeCand;
|
|
|
772 }
|
|
|
773
|
|
|
774
|
|
|
775 Int TComSlice::m_prevTid0POC = 0;
|
|
|
776
|
|
|
777 /** Function for setting the slice's temporal layer ID and corresponding temporal_layer_switching_point_flag.
|
|
|
778 * \param uiTLayer Temporal layer ID of the current slice
|
|
|
779 * The decoder calls this function to set temporal_layer_switching_point_flag for each temporal layer based on
|
|
|
780 * the SPS's temporal_id_nesting_flag and the parsed PPS. Then, current slice's temporal layer ID and
|
|
|
781 * temporal_layer_switching_point_flag is set accordingly.
|
|
|
782 */
|
|
|
783 Void TComSlice::setTLayerInfo( UInt uiTLayer )
|
|
|
784 {
|
|
|
785 m_uiTLayer = uiTLayer;
|
|
|
786 }
|
|
|
787
|
|
|
788 /** Function for checking if this is a switching-point
|
|
|
789 */
|
|
|
790 Bool TComSlice::isTemporalLayerSwitchingPoint(TComList<TComPic*>& rcListPic)
|
|
|
791 {
|
|
|
792 TComPic* rpcPic;
|
|
|
793 // loop through all pictures in the reference picture buffer
|
|
|
794 TComList<TComPic*>::iterator iterPic = rcListPic.begin();
|
|
|
795 while ( iterPic != rcListPic.end())
|
|
|
796 {
|
|
|
797 rpcPic = *(iterPic++);
|
|
|
798 if(rpcPic->getSlice(0)->isReferenced() && rpcPic->getPOC() != getPOC())
|
|
|
799 {
|
|
|
800 if(rpcPic->getTLayer() >= getTLayer())
|
|
|
801 {
|
|
|
802 return false;
|
|
|
803 }
|
|
|
804 }
|
|
|
805 }
|
|
|
806 return true;
|
|
|
807 }
|
|
|
808
|
|
|
809 /** Function for checking if this is a STSA candidate
|
|
|
810 */
|
|
|
811 Bool TComSlice::isStepwiseTemporalLayerSwitchingPointCandidate(TComList<TComPic*>& rcListPic)
|
|
|
812 {
|
|
|
813 TComPic* rpcPic;
|
|
|
814
|
|
|
815 TComList<TComPic*>::iterator iterPic = rcListPic.begin();
|
|
|
816 while ( iterPic != rcListPic.end())
|
|
|
817 {
|
|
|
818 rpcPic = *(iterPic++);
|
|
|
819 if(rpcPic->getSlice(0)->isReferenced() && (rpcPic->getUsedByCurr()==true) && rpcPic->getPOC() != getPOC())
|
|
|
820 {
|
|
|
821 if(rpcPic->getTLayer() >= getTLayer())
|
|
|
822 {
|
|
|
823 return false;
|
|
|
824 }
|
|
|
825 }
|
|
|
826 }
|
|
|
827 return true;
|
|
|
828 }
|
|
|
829
|
|
|
830
|
|
|
831 Void TComSlice::checkLeadingPictureRestrictions(TComList<TComPic*>& rcListPic)
|
|
|
832 {
|
|
|
833 TComPic* rpcPic;
|
|
|
834
|
|
|
835 Int nalUnitType = this->getNalUnitType();
|
|
|
836
|
|
|
837 // When a picture is a leading picture, it shall be a RADL or RASL picture.
|
|
|
838 if(this->getAssociatedIRAPPOC() > this->getPOC())
|
|
|
839 {
|
|
|
840 // Do not check IRAP pictures since they may get a POC lower than their associated IRAP
|
|
|
841 if(nalUnitType < NAL_UNIT_CODED_SLICE_BLA_W_LP ||
|
|
|
842 nalUnitType > NAL_UNIT_RESERVED_IRAP_VCL23)
|
|
|
843 {
|
|
|
844 assert(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
|
|
|
845 nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R ||
|
|
|
846 nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N ||
|
|
|
847 nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R);
|
|
|
848 }
|
|
|
849 }
|
|
|
850
|
|
|
851 // When a picture is a trailing picture, it shall not be a RADL or RASL picture.
|
|
|
852 if(this->getAssociatedIRAPPOC() < this->getPOC())
|
|
|
853 {
|
|
|
854 assert(nalUnitType != NAL_UNIT_CODED_SLICE_RASL_N &&
|
|
|
855 nalUnitType != NAL_UNIT_CODED_SLICE_RASL_R &&
|
|
|
856 nalUnitType != NAL_UNIT_CODED_SLICE_RADL_N &&
|
|
|
857 nalUnitType != NAL_UNIT_CODED_SLICE_RADL_R);
|
|
|
858 }
|
|
|
859
|
|
|
860 // No RASL pictures shall be present in the bitstream that are associated
|
|
|
861 // with a BLA picture having nal_unit_type equal to BLA_W_RADL or BLA_N_LP.
|
|
|
862 if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
|
|
|
863 nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
|
|
|
864 {
|
|
|
865 assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_W_RADL &&
|
|
|
866 this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_N_LP);
|
|
|
867 }
|
|
|
868
|
|
|
869 // No RASL pictures shall be present in the bitstream that are associated with
|
|
|
870 // an IDR picture.
|
|
|
871 if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
|
|
|
872 nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
|
|
|
873 {
|
|
|
874 assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_N_LP &&
|
|
|
875 this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_W_RADL);
|
|
|
876 }
|
|
|
877
|
|
|
878 // No RADL pictures shall be present in the bitstream that are associated with
|
|
|
879 // a BLA picture having nal_unit_type equal to BLA_N_LP or that are associated
|
|
|
880 // with an IDR picture having nal_unit_type equal to IDR_N_LP.
|
|
|
881 if(nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N ||
|
|
|
882 nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R)
|
|
|
883 {
|
|
|
884 assert(this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_BLA_N_LP &&
|
|
|
885 this->getAssociatedIRAPType() != NAL_UNIT_CODED_SLICE_IDR_N_LP);
|
|
|
886 }
|
|
|
887
|
|
|
888 // loop through all pictures in the reference picture buffer
|
|
|
889 TComList<TComPic*>::iterator iterPic = rcListPic.begin();
|
|
|
890 while ( iterPic != rcListPic.end())
|
|
|
891 {
|
|
|
892 rpcPic = *(iterPic++);
|
|
|
893 #if BUGFIX_INTRAPERIOD
|
|
|
894 if(!rpcPic->getReconMark())
|
|
|
895 {
|
|
|
896 continue;
|
|
|
897 }
|
|
|
898 #endif
|
|
|
899 if (rpcPic->getPOC() == this->getPOC())
|
|
|
900 {
|
|
|
901 continue;
|
|
|
902 }
|
|
|
903
|
|
|
904 // Any picture that has PicOutputFlag equal to 1 that precedes an IRAP picture
|
|
|
905 // in decoding order shall precede the IRAP picture in output order.
|
|
|
906 // (Note that any picture following in output order would be present in the DPB)
|
|
|
907 if(rpcPic->getSlice(0)->getPicOutputFlag() == 1 && !this->getNoOutputPriorPicsFlag())
|
|
|
908 {
|
|
|
909 if(nalUnitType == NAL_UNIT_CODED_SLICE_BLA_N_LP ||
|
|
|
910 nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_LP ||
|
|
|
911 nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_RADL ||
|
|
|
912 nalUnitType == NAL_UNIT_CODED_SLICE_CRA ||
|
|
|
913 nalUnitType == NAL_UNIT_CODED_SLICE_IDR_N_LP ||
|
|
|
914 nalUnitType == NAL_UNIT_CODED_SLICE_IDR_W_RADL)
|
|
|
915 {
|
|
|
916 assert(rpcPic->getPOC() < this->getPOC());
|
|
|
917 }
|
|
|
918 }
|
|
|
919
|
|
|
920 // Any picture that has PicOutputFlag equal to 1 that precedes an IRAP picture
|
|
|
921 // in decoding order shall precede any RADL picture associated with the IRAP
|
|
|
922 // picture in output order.
|
|
|
923 if(rpcPic->getSlice(0)->getPicOutputFlag() == 1)
|
|
|
924 {
|
|
|
925 if((nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N ||
|
|
|
926 nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R))
|
|
|
927 {
|
|
|
928 // rpcPic precedes the IRAP in decoding order
|
|
|
929 if(this->getAssociatedIRAPPOC() > rpcPic->getSlice(0)->getAssociatedIRAPPOC())
|
|
|
930 {
|
|
|
931 // rpcPic must not be the IRAP picture
|
|
|
932 if(this->getAssociatedIRAPPOC() != rpcPic->getPOC())
|
|
|
933 {
|
|
|
934 assert(rpcPic->getPOC() < this->getPOC());
|
|
|
935 }
|
|
|
936 }
|
|
|
937 }
|
|
|
938 }
|
|
|
939
|
|
|
940 // When a picture is a leading picture, it shall precede, in decoding order,
|
|
|
941 // all trailing pictures that are associated with the same IRAP picture.
|
|
|
942 if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
|
|
|
943 nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R ||
|
|
|
944 nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N ||
|
|
|
945 nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R)
|
|
|
946 {
|
|
|
947 if(rpcPic->getSlice(0)->getAssociatedIRAPPOC() == this->getAssociatedIRAPPOC())
|
|
|
948 {
|
|
|
949 // rpcPic is a picture that preceded the leading in decoding order since it exist in the DPB
|
|
|
950 // rpcPic would violate the constraint if it was a trailing picture
|
|
|
951 assert(rpcPic->getPOC() <= this->getAssociatedIRAPPOC());
|
|
|
952 }
|
|
|
953 }
|
|
|
954
|
|
|
955 // Any RASL picture associated with a CRA or BLA picture shall precede any
|
|
|
956 // RADL picture associated with the CRA or BLA picture in output order
|
|
|
957 if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
|
|
|
958 nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
|
|
|
959 {
|
|
|
960 if((this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_N_LP ||
|
|
|
961 this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_W_LP ||
|
|
|
962 this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL ||
|
|
|
963 this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_CRA) &&
|
|
|
964 this->getAssociatedIRAPPOC() == rpcPic->getSlice(0)->getAssociatedIRAPPOC())
|
|
|
965 {
|
|
|
966 if(rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N ||
|
|
|
967 rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_R)
|
|
|
968 {
|
|
|
969 assert(rpcPic->getPOC() > this->getPOC());
|
|
|
970 }
|
|
|
971 }
|
|
|
972 }
|
|
|
973
|
|
|
974 // Any RASL picture associated with a CRA picture shall follow, in output
|
|
|
975 // order, any IRAP picture that precedes the CRA picture in decoding order.
|
|
|
976 if(nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N ||
|
|
|
977 nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R)
|
|
|
978 {
|
|
|
979 if(this->getAssociatedIRAPType() == NAL_UNIT_CODED_SLICE_CRA)
|
|
|
980 {
|
|
|
981 if(rpcPic->getSlice(0)->getPOC() < this->getAssociatedIRAPPOC() &&
|
|
|
982 (rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP ||
|
|
|
983 rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP ||
|
|
|
984 rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL ||
|
|
|
985 rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ||
|
|
|
986 rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL ||
|
|
|
987 rpcPic->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA))
|
|
|
988 {
|
|
|
989 assert(this->getPOC() > rpcPic->getSlice(0)->getPOC());
|
|
|
990 }
|
|
|
991 }
|
|
|
992 }
|
|
|
993 }
|
|
|
994 }
|
|
|
995
|
|
|
996
|
|
|
997
|
|
|
998 /** Function for applying picture marking based on the Reference Picture Set in pReferencePictureSet.
|
|
|
999 */
|
|
|
1000 Void TComSlice::applyReferencePictureSet( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet)
|
|
|
1001 {
|
|
|
1002 TComPic* rpcPic;
|
|
|
1003 Int i, isReference;
|
|
|
1004
|
|
|
1005 checkLeadingPictureRestrictions(rcListPic);
|
|
|
1006
|
|
|
1007 // loop through all pictures in the reference picture buffer
|
|
|
1008 TComList<TComPic*>::iterator iterPic = rcListPic.begin();
|
|
|
1009 while ( iterPic != rcListPic.end())
|
|
|
1010 {
|
|
|
1011 rpcPic = *(iterPic++);
|
|
|
1012
|
|
|
1013 if(!rpcPic->getSlice( 0 )->isReferenced())
|
|
|
1014 {
|
|
|
1015 continue;
|
|
|
1016 }
|
|
|
1017
|
|
|
1018 isReference = 0;
|
|
|
1019 // loop through all pictures in the Reference Picture Set
|
|
|
1020 // to see if the picture should be kept as reference picture
|
|
|
1021 for(i=0;i<pReferencePictureSet->getNumberOfPositivePictures()+pReferencePictureSet->getNumberOfNegativePictures();i++)
|
|
|
1022 {
|
|
|
1023 if(!rpcPic->getIsLongTerm() && rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i))
|
|
|
1024 {
|
|
|
1025 isReference = 1;
|
|
|
1026 rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
|
|
|
1027 rpcPic->setIsLongTerm(0);
|
|
|
1028 }
|
|
|
1029 }
|
|
|
1030 for(;i<pReferencePictureSet->getNumberOfPictures();i++)
|
|
|
1031 {
|
|
|
1032 if(pReferencePictureSet->getCheckLTMSBPresent(i)==true)
|
|
|
1033 {
|
|
|
1034 if(rpcPic->getIsLongTerm() && (rpcPic->getPicSym()->getSlice(0)->getPOC()) == pReferencePictureSet->getPOC(i))
|
|
|
1035 {
|
|
|
1036 isReference = 1;
|
|
|
1037 rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
|
|
|
1038 }
|
|
|
1039 }
|
|
|
1040 else
|
|
|
1041 {
|
|
|
1042 Int pocCycle = 1<<rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
|
|
|
1043 Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC() & (pocCycle-1);
|
|
|
1044 Int refPoc = pReferencePictureSet->getPOC(i) & (pocCycle-1);
|
|
|
1045 if(rpcPic->getIsLongTerm() && curPoc == refPoc)
|
|
|
1046 {
|
|
|
1047 isReference = 1;
|
|
|
1048 rpcPic->setUsedByCurr(pReferencePictureSet->getUsed(i));
|
|
|
1049 }
|
|
|
1050 }
|
|
|
1051
|
|
|
1052 }
|
|
|
1053 // mark the picture as "unused for reference" if it is not in
|
|
|
1054 // the Reference Picture Set
|
|
|
1055 if(rpcPic->getPicSym()->getSlice(0)->getPOC() != this->getPOC() && isReference == 0)
|
|
|
1056 {
|
|
|
1057 rpcPic->getSlice( 0 )->setReferenced( false );
|
|
|
1058 rpcPic->setUsedByCurr(0);
|
|
|
1059 rpcPic->setIsLongTerm(0);
|
|
|
1060 }
|
|
|
1061 //check that pictures of higher temporal layers are not used
|
|
|
1062 assert(rpcPic->getSlice( 0 )->isReferenced()==0||rpcPic->getUsedByCurr()==0||rpcPic->getTLayer()<=this->getTLayer());
|
|
|
1063 //check that pictures of higher or equal temporal layer are not in the RPS if the current picture is a TSA picture
|
|
|
1064 if(this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_R || this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N)
|
|
|
1065 {
|
|
|
1066 assert(rpcPic->getSlice( 0 )->isReferenced()==0||rpcPic->getTLayer()<this->getTLayer());
|
|
|
1067 }
|
|
|
1068 //check that pictures marked as temporal layer non-reference pictures are not used for reference
|
|
|
1069 if(rpcPic->getPicSym()->getSlice(0)->getPOC() != this->getPOC() && rpcPic->getTLayer()==this->getTLayer())
|
|
|
1070 {
|
|
|
1071 assert(rpcPic->getSlice( 0 )->isReferenced()==0||rpcPic->getUsedByCurr()==0||rpcPic->getSlice( 0 )->getTemporalLayerNonReferenceFlag()==false);
|
|
|
1072 }
|
|
|
1073 }
|
|
|
1074 }
|
|
|
1075
|
|
|
1076 /** Function for applying picture marking based on the Reference Picture Set in pReferencePictureSet.
|
|
|
1077 */
|
|
|
1078 #if ALLOW_RECOVERY_POINT_AS_RAP
|
|
|
1079 Int TComSlice::checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool printErrors, Int pocRandomAccess, Bool bUseRecoveryPoint)
|
|
|
1080 #else
|
|
|
1081 Int TComSlice::checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool printErrors, Int pocRandomAccess)
|
|
|
1082 #endif
|
|
|
1083 {
|
|
|
1084 #if ALLOW_RECOVERY_POINT_AS_RAP
|
|
|
1085 Int atLeastOneUnabledByRecoveryPoint = 0;
|
|
|
1086 Int atLeastOneFlushedByPreviousIDR = 0;
|
|
|
1087 #endif
|
|
|
1088 TComPic* rpcPic;
|
|
|
1089 Int i, isAvailable;
|
|
|
1090 Int atLeastOneLost = 0;
|
|
|
1091 Int atLeastOneRemoved = 0;
|
|
|
1092 Int iPocLost = 0;
|
|
|
1093
|
|
|
1094 // loop through all long-term pictures in the Reference Picture Set
|
|
|
1095 // to see if the picture should be kept as reference picture
|
|
|
1096 for(i=pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();i<pReferencePictureSet->getNumberOfPictures();i++)
|
|
|
1097 {
|
|
|
1098 isAvailable = 0;
|
|
|
1099 // loop through all pictures in the reference picture buffer
|
|
|
1100 TComList<TComPic*>::iterator iterPic = rcListPic.begin();
|
|
|
1101 while ( iterPic != rcListPic.end())
|
|
|
1102 {
|
|
|
1103 rpcPic = *(iterPic++);
|
|
|
1104 if(pReferencePictureSet->getCheckLTMSBPresent(i)==true)
|
|
|
1105 {
|
|
|
1106 if(rpcPic->getIsLongTerm() && (rpcPic->getPicSym()->getSlice(0)->getPOC()) == pReferencePictureSet->getPOC(i) && rpcPic->getSlice(0)->isReferenced())
|
|
|
1107 {
|
|
|
1108 #if ALLOW_RECOVERY_POINT_AS_RAP
|
|
|
1109 if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + pReferencePictureSet->getDeltaPOC(i) < pocRandomAccess)
|
|
|
1110 {
|
|
|
1111 isAvailable = 0;
|
|
|
1112 }
|
|
|
1113 else
|
|
|
1114 {
|
|
|
1115 isAvailable = 1;
|
|
|
1116 }
|
|
|
1117 #else
|
|
|
1118 isAvailable = 1;
|
|
|
1119 #endif
|
|
|
1120 }
|
|
|
1121 }
|
|
|
1122 else
|
|
|
1123 {
|
|
|
1124 Int pocCycle = 1<<rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
|
|
|
1125 Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC() & (pocCycle-1);
|
|
|
1126 Int refPoc = pReferencePictureSet->getPOC(i) & (pocCycle-1);
|
|
|
1127 if(rpcPic->getIsLongTerm() && curPoc == refPoc && rpcPic->getSlice(0)->isReferenced())
|
|
|
1128 {
|
|
|
1129 #if ALLOW_RECOVERY_POINT_AS_RAP
|
|
|
1130 if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + pReferencePictureSet->getDeltaPOC(i) < pocRandomAccess)
|
|
|
1131 {
|
|
|
1132 isAvailable = 0;
|
|
|
1133 }
|
|
|
1134 else
|
|
|
1135 {
|
|
|
1136 isAvailable = 1;
|
|
|
1137 }
|
|
|
1138 #else
|
|
|
1139 isAvailable = 1;
|
|
|
1140 #endif
|
|
|
1141 }
|
|
|
1142 }
|
|
|
1143 }
|
|
|
1144 // if there was no such long-term check the short terms
|
|
|
1145 if(!isAvailable)
|
|
|
1146 {
|
|
|
1147 iterPic = rcListPic.begin();
|
|
|
1148 while ( iterPic != rcListPic.end())
|
|
|
1149 {
|
|
|
1150 rpcPic = *(iterPic++);
|
|
|
1151
|
|
|
1152 Int pocCycle = 1 << rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC();
|
|
|
1153 Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC();
|
|
|
1154 Int refPoc = pReferencePictureSet->getPOC(i);
|
|
|
1155 if (!pReferencePictureSet->getCheckLTMSBPresent(i))
|
|
|
1156 {
|
|
|
1157 curPoc = curPoc & (pocCycle - 1);
|
|
|
1158 refPoc = refPoc & (pocCycle - 1);
|
|
|
1159 }
|
|
|
1160
|
|
|
1161 if (rpcPic->getSlice(0)->isReferenced() && curPoc == refPoc)
|
|
|
1162 {
|
|
|
1163 #if ALLOW_RECOVERY_POINT_AS_RAP
|
|
|
1164 if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + pReferencePictureSet->getDeltaPOC(i) < pocRandomAccess)
|
|
|
1165 {
|
|
|
1166 isAvailable = 0;
|
|
|
1167 }
|
|
|
1168 else
|
|
|
1169 {
|
|
|
1170 isAvailable = 1;
|
|
|
1171 rpcPic->setIsLongTerm(1);
|
|
|
1172 break;
|
|
|
1173 }
|
|
|
1174 #else
|
|
|
1175 isAvailable = 1;
|
|
|
1176 rpcPic->setIsLongTerm(1);
|
|
|
1177 break;
|
|
|
1178 #endif
|
|
|
1179 }
|
|
|
1180 }
|
|
|
1181 }
|
|
|
1182 // report that a picture is lost if it is in the Reference Picture Set
|
|
|
1183 // but not available as reference picture
|
|
|
1184 if(isAvailable == 0)
|
|
|
1185 {
|
|
|
1186 if (this->getPOC() + pReferencePictureSet->getDeltaPOC(i) >= pocRandomAccess)
|
|
|
1187 {
|
|
|
1188 if(!pReferencePictureSet->getUsed(i) )
|
|
|
1189 {
|
|
|
1190 if(printErrors)
|
|
|
1191 {
|
|
|
1192 printf("\nLong-term reference picture with POC = %3d seems to have been removed or not correctly decoded.", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
|
|
|
1193 }
|
|
|
1194 atLeastOneRemoved = 1;
|
|
|
1195 }
|
|
|
1196 else
|
|
|
1197 {
|
|
|
1198 if(printErrors)
|
|
|
1199 {
|
|
|
1200 printf("\nLong-term reference picture with POC = %3d is lost or not correctly decoded!", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
|
|
|
1201 }
|
|
|
1202 atLeastOneLost = 1;
|
|
|
1203 iPocLost=this->getPOC() + pReferencePictureSet->getDeltaPOC(i);
|
|
|
1204 }
|
|
|
1205 }
|
|
|
1206 #if ALLOW_RECOVERY_POINT_AS_RAP
|
|
|
1207 else if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess)
|
|
|
1208 {
|
|
|
1209 atLeastOneUnabledByRecoveryPoint = 1;
|
|
|
1210 }
|
|
|
1211 else if(bUseRecoveryPoint && (this->getAssociatedIRAPType()==NAL_UNIT_CODED_SLICE_IDR_N_LP || this->getAssociatedIRAPType()==NAL_UNIT_CODED_SLICE_IDR_W_RADL))
|
|
|
1212 {
|
|
|
1213 atLeastOneFlushedByPreviousIDR = 1;
|
|
|
1214 }
|
|
|
1215 #endif
|
|
|
1216 }
|
|
|
1217 }
|
|
|
1218 // loop through all short-term pictures in the Reference Picture Set
|
|
|
1219 // to see if the picture should be kept as reference picture
|
|
|
1220 for(i=0;i<pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();i++)
|
|
|
1221 {
|
|
|
1222 isAvailable = 0;
|
|
|
1223 // loop through all pictures in the reference picture buffer
|
|
|
1224 TComList<TComPic*>::iterator iterPic = rcListPic.begin();
|
|
|
1225 while ( iterPic != rcListPic.end())
|
|
|
1226 {
|
|
|
1227 rpcPic = *(iterPic++);
|
|
|
1228
|
|
|
1229 if(!rpcPic->getIsLongTerm() && rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i) && rpcPic->getSlice(0)->isReferenced())
|
|
|
1230 {
|
|
|
1231 #if ALLOW_RECOVERY_POINT_AS_RAP
|
|
|
1232 if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + pReferencePictureSet->getDeltaPOC(i) < pocRandomAccess)
|
|
|
1233 {
|
|
|
1234 isAvailable = 0;
|
|
|
1235 }
|
|
|
1236 else
|
|
|
1237 {
|
|
|
1238 isAvailable = 1;
|
|
|
1239 }
|
|
|
1240 #else
|
|
|
1241 isAvailable = 1;
|
|
|
1242 #endif
|
|
|
1243 }
|
|
|
1244 }
|
|
|
1245 // report that a picture is lost if it is in the Reference Picture Set
|
|
|
1246 // but not available as reference picture
|
|
|
1247 if(isAvailable == 0)
|
|
|
1248 {
|
|
|
1249 if (this->getPOC() + pReferencePictureSet->getDeltaPOC(i) >= pocRandomAccess)
|
|
|
1250 {
|
|
|
1251 if(!pReferencePictureSet->getUsed(i) )
|
|
|
1252 {
|
|
|
1253 if(printErrors)
|
|
|
1254 {
|
|
|
1255 printf("\nShort-term reference picture with POC = %3d seems to have been removed or not correctly decoded.", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
|
|
|
1256 }
|
|
|
1257 atLeastOneRemoved = 1;
|
|
|
1258 }
|
|
|
1259 else
|
|
|
1260 {
|
|
|
1261 if(printErrors)
|
|
|
1262 {
|
|
|
1263 printf("\nShort-term reference picture with POC = %3d is lost or not correctly decoded!", this->getPOC() + pReferencePictureSet->getDeltaPOC(i));
|
|
|
1264 }
|
|
|
1265 atLeastOneLost = 1;
|
|
|
1266 iPocLost=this->getPOC() + pReferencePictureSet->getDeltaPOC(i);
|
|
|
1267 }
|
|
|
1268 }
|
|
|
1269 #if ALLOW_RECOVERY_POINT_AS_RAP
|
|
|
1270 else if(bUseRecoveryPoint && this->getPOC() > pocRandomAccess)
|
|
|
1271 {
|
|
|
1272 atLeastOneUnabledByRecoveryPoint = 1;
|
|
|
1273 }
|
|
|
1274 else if(bUseRecoveryPoint && (this->getAssociatedIRAPType()==NAL_UNIT_CODED_SLICE_IDR_N_LP || this->getAssociatedIRAPType()==NAL_UNIT_CODED_SLICE_IDR_W_RADL))
|
|
|
1275 {
|
|
|
1276 atLeastOneFlushedByPreviousIDR = 1;
|
|
|
1277 }
|
|
|
1278 #endif
|
|
|
1279 }
|
|
|
1280 }
|
|
|
1281
|
|
|
1282 #if ALLOW_RECOVERY_POINT_AS_RAP
|
|
|
1283 if(atLeastOneUnabledByRecoveryPoint || atLeastOneFlushedByPreviousIDR)
|
|
|
1284 {
|
|
|
1285 return -1;
|
|
|
1286 }
|
|
|
1287 #endif
|
|
|
1288 if(atLeastOneLost)
|
|
|
1289 {
|
|
|
1290 return iPocLost+1;
|
|
|
1291 }
|
|
|
1292 if(atLeastOneRemoved)
|
|
|
1293 {
|
|
|
1294 return -2;
|
|
|
1295 }
|
|
|
1296 else
|
|
|
1297 {
|
|
|
1298 return 0;
|
|
|
1299 }
|
|
|
1300 }
|
|
|
1301
|
|
|
1302 /** Function for constructing an explicit Reference Picture Set out of the available pictures in a referenced Reference Picture Set
|
|
|
1303 */
|
|
|
1304 #if ALLOW_RECOVERY_POINT_AS_RAP
|
|
|
1305 Void TComSlice::createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool isRAP, Int pocRandomAccess, Bool bUseRecoveryPoint)
|
|
|
1306 #else
|
|
|
1307 Void TComSlice::createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool isRAP)
|
|
|
1308 #endif
|
|
|
1309 {
|
|
|
1310 TComPic* rpcPic;
|
|
|
1311 Int i, j;
|
|
|
1312 Int k = 0;
|
|
|
1313 Int nrOfNegativePictures = 0;
|
|
|
1314 Int nrOfPositivePictures = 0;
|
|
|
1315 TComReferencePictureSet* pcRPS = this->getLocalRPS();
|
|
|
1316 #if EFFICIENT_FIELD_IRAP
|
|
|
1317 Bool irapIsInRPS = false;
|
|
|
1318 #endif
|
|
|
1319
|
|
|
1320 // loop through all pictures in the Reference Picture Set
|
|
|
1321 for(i=0;i<pReferencePictureSet->getNumberOfPictures();i++)
|
|
|
1322 {
|
|
|
1323 j = 0;
|
|
|
1324 // loop through all pictures in the reference picture buffer
|
|
|
1325 TComList<TComPic*>::iterator iterPic = rcListPic.begin();
|
|
|
1326 while ( iterPic != rcListPic.end())
|
|
|
1327 {
|
|
|
1328 j++;
|
|
|
1329 rpcPic = *(iterPic++);
|
|
|
1330
|
|
|
1331 if(rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getPOC() + pReferencePictureSet->getDeltaPOC(i) && rpcPic->getSlice(0)->isReferenced())
|
|
|
1332 {
|
|
|
1333 // This picture exists as a reference picture
|
|
|
1334 // and should be added to the explicit Reference Picture Set
|
|
|
1335 pcRPS->setDeltaPOC(k, pReferencePictureSet->getDeltaPOC(i));
|
|
|
1336 pcRPS->setUsed(k, pReferencePictureSet->getUsed(i) && (!isRAP));
|
|
|
1337 #if ALLOW_RECOVERY_POINT_AS_RAP
|
|
|
1338 pcRPS->setUsed(k, pcRPS->getUsed(k) && !(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + pReferencePictureSet->getDeltaPOC(i) < pocRandomAccess) );
|
|
|
1339 #endif
|
|
|
1340
|
|
|
1341 if(pcRPS->getDeltaPOC(k) < 0)
|
|
|
1342 {
|
|
|
1343 nrOfNegativePictures++;
|
|
|
1344 }
|
|
|
1345 else
|
|
|
1346 {
|
|
|
1347 #if EFFICIENT_FIELD_IRAP
|
|
|
1348 if(rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getAssociatedIRAPPOC() && this->getAssociatedIRAPPOC() == this->getPOC()+1)
|
|
|
1349 {
|
|
|
1350 irapIsInRPS = true;
|
|
|
1351 }
|
|
|
1352 #endif
|
|
|
1353 nrOfPositivePictures++;
|
|
|
1354 }
|
|
|
1355 k++;
|
|
|
1356 }
|
|
|
1357 }
|
|
|
1358 }
|
|
|
1359
|
|
|
1360 #if EFFICIENT_FIELD_IRAP
|
|
|
1361 Bool useNewRPS = false;
|
|
|
1362 // if current picture is complimentary field associated to IRAP, add the IRAP to its RPS.
|
|
|
1363 if(m_pcPic->isField() && !irapIsInRPS)
|
|
|
1364 {
|
|
|
1365 TComList<TComPic*>::iterator iterPic = rcListPic.begin();
|
|
|
1366 while ( iterPic != rcListPic.end())
|
|
|
1367 {
|
|
|
1368 rpcPic = *(iterPic++);
|
|
|
1369 if(rpcPic->getPicSym()->getSlice(0)->getPOC() == this->getAssociatedIRAPPOC() && this->getAssociatedIRAPPOC() == this->getPOC()+1)
|
|
|
1370 {
|
|
|
1371 pcRPS->setDeltaPOC(k, 1);
|
|
|
1372 pcRPS->setUsed(k, true);
|
|
|
1373 nrOfPositivePictures++;
|
|
|
1374 k ++;
|
|
|
1375 useNewRPS = true;
|
|
|
1376 }
|
|
|
1377 }
|
|
|
1378 }
|
|
|
1379 #endif
|
|
|
1380 pcRPS->setNumberOfNegativePictures(nrOfNegativePictures);
|
|
|
1381 pcRPS->setNumberOfPositivePictures(nrOfPositivePictures);
|
|
|
1382 pcRPS->setNumberOfPictures(nrOfNegativePictures+nrOfPositivePictures);
|
|
|
1383 // This is a simplistic inter rps example. A smarter encoder will look for a better reference RPS to do the
|
|
|
1384 // inter RPS prediction with. Here we just use the reference used by pReferencePictureSet.
|
|
|
1385 // If pReferencePictureSet is not inter_RPS_predicted, then inter_RPS_prediction is for the current RPS also disabled.
|
|
|
1386 if (!pReferencePictureSet->getInterRPSPrediction()
|
|
|
1387 #if EFFICIENT_FIELD_IRAP
|
|
|
1388 || useNewRPS
|
|
|
1389 #endif
|
|
|
1390 )
|
|
|
1391 {
|
|
|
1392 pcRPS->setInterRPSPrediction(false);
|
|
|
1393 pcRPS->setNumRefIdc(0);
|
|
|
1394 }
|
|
|
1395 else
|
|
|
1396 {
|
|
|
1397 Int rIdx = this->getRPSidx() - pReferencePictureSet->getDeltaRIdxMinus1() - 1;
|
|
|
1398 Int deltaRPS = pReferencePictureSet->getDeltaRPS();
|
|
|
1399 TComReferencePictureSet* pcRefRPS = this->getSPS()->getRPSList()->getReferencePictureSet(rIdx);
|
|
|
1400 Int iRefPics = pcRefRPS->getNumberOfPictures();
|
|
|
1401 Int iNewIdc=0;
|
|
|
1402 for(i=0; i<= iRefPics; i++)
|
|
|
1403 {
|
|
|
1404 Int deltaPOC = ((i != iRefPics)? pcRefRPS->getDeltaPOC(i) : 0); // check if the reference abs POC is >= 0
|
|
|
1405 Int iRefIdc = 0;
|
|
|
1406 for (j=0; j < pcRPS->getNumberOfPictures(); j++) // loop through the pictures in the new RPS
|
|
|
1407 {
|
|
|
1408 if ( (deltaPOC + deltaRPS) == pcRPS->getDeltaPOC(j))
|
|
|
1409 {
|
|
|
1410 if (pcRPS->getUsed(j))
|
|
|
1411 {
|
|
|
1412 iRefIdc = 1;
|
|
|
1413 }
|
|
|
1414 else
|
|
|
1415 {
|
|
|
1416 iRefIdc = 2;
|
|
|
1417 }
|
|
|
1418 }
|
|
|
1419 }
|
|
|
1420 pcRPS->setRefIdc(i, iRefIdc);
|
|
|
1421 iNewIdc++;
|
|
|
1422 }
|
|
|
1423 pcRPS->setInterRPSPrediction(true);
|
|
|
1424 pcRPS->setNumRefIdc(iNewIdc);
|
|
|
1425 pcRPS->setDeltaRPS(deltaRPS);
|
|
|
1426 pcRPS->setDeltaRIdxMinus1(pReferencePictureSet->getDeltaRIdxMinus1() + this->getSPS()->getRPSList()->getNumberOfReferencePictureSets() - this->getRPSidx());
|
|
|
1427 }
|
|
|
1428
|
|
|
1429 this->setRPS(pcRPS);
|
|
|
1430 this->setRPSidx(-1);
|
|
|
1431 }
|
|
|
1432
|
|
|
1433 /** get AC and DC values for weighted pred
|
|
|
1434 * \param *wp
|
|
|
1435 * \returns Void
|
|
|
1436 */
|
|
|
1437 Void TComSlice::getWpAcDcParam(WPACDCParam *&wp)
|
|
|
1438 {
|
|
|
1439 wp = m_weightACDCParam;
|
|
|
1440 }
|
|
|
1441
|
|
|
1442 /** init AC and DC values for weighted pred
|
|
|
1443 * \returns Void
|
|
|
1444 */
|
|
|
1445 Void TComSlice::initWpAcDcParam()
|
|
|
1446 {
|
|
|
1447 for(Int iComp = 0; iComp < MAX_NUM_COMPONENT; iComp++ )
|
|
|
1448 {
|
|
|
1449 m_weightACDCParam[iComp].iAC = 0;
|
|
|
1450 m_weightACDCParam[iComp].iDC = 0;
|
|
|
1451 }
|
|
|
1452 }
|
|
|
1453
|
|
|
1454 /** get WP tables for weighted pred
|
|
|
1455 * \param RefPicList
|
|
|
1456 * \param iRefIdx
|
|
|
1457 * \param *&WPScalingParam
|
|
|
1458 * \returns Void
|
|
|
1459 */
|
|
|
1460 Void TComSlice::getWpScaling( RefPicList e, Int iRefIdx, WPScalingParam *&wp )
|
|
|
1461 {
|
|
|
1462 assert (e<NUM_REF_PIC_LIST_01);
|
|
|
1463 wp = m_weightPredTable[e][iRefIdx];
|
|
|
1464 }
|
|
|
1465
|
|
|
1466 /** reset Default WP tables settings : no weight.
|
|
|
1467 * \param WPScalingParam
|
|
|
1468 * \returns Void
|
|
|
1469 */
|
|
|
1470 Void TComSlice::resetWpScaling()
|
|
|
1471 {
|
|
|
1472 for ( Int e=0 ; e<NUM_REF_PIC_LIST_01 ; e++ )
|
|
|
1473 {
|
|
|
1474 for ( Int i=0 ; i<MAX_NUM_REF ; i++ )
|
|
|
1475 {
|
|
|
1476 for ( Int yuv=0 ; yuv<MAX_NUM_COMPONENT ; yuv++ )
|
|
|
1477 {
|
|
|
1478 WPScalingParam *pwp = &(m_weightPredTable[e][i][yuv]);
|
|
|
1479 pwp->bPresentFlag = false;
|
|
|
1480 pwp->uiLog2WeightDenom = 0;
|
|
|
1481 pwp->uiLog2WeightDenom = 0;
|
|
|
1482 pwp->iWeight = 1;
|
|
|
1483 pwp->iOffset = 0;
|
|
|
1484 }
|
|
|
1485 }
|
|
|
1486 }
|
|
|
1487 }
|
|
|
1488
|
|
|
1489 /** init WP table
|
|
|
1490 * \returns Void
|
|
|
1491 */
|
|
|
1492 Void TComSlice::initWpScaling()
|
|
|
1493 {
|
|
|
1494 const Bool bUseHighPrecisionPredictionWeighting = getSPS()->getUseHighPrecisionPredictionWeighting();
|
|
|
1495 for ( Int e=0 ; e<NUM_REF_PIC_LIST_01 ; e++ )
|
|
|
1496 {
|
|
|
1497 for ( Int i=0 ; i<MAX_NUM_REF ; i++ )
|
|
|
1498 {
|
|
|
1499 for ( Int yuv=0 ; yuv<MAX_NUM_COMPONENT ; yuv++ )
|
|
|
1500 {
|
|
|
1501 WPScalingParam *pwp = &(m_weightPredTable[e][i][yuv]);
|
|
|
1502 if ( !pwp->bPresentFlag )
|
|
|
1503 {
|
|
|
1504 // Inferring values not present :
|
|
|
1505 pwp->iWeight = (1 << pwp->uiLog2WeightDenom);
|
|
|
1506 pwp->iOffset = 0;
|
|
|
1507 }
|
|
|
1508
|
|
|
1509 const Int offsetScalingFactor = bUseHighPrecisionPredictionWeighting ? 1 : (1 << (g_bitDepth[toChannelType(ComponentID(yuv))]-8));
|
|
|
1510
|
|
|
1511 pwp->w = pwp->iWeight;
|
|
|
1512 pwp->o = pwp->iOffset * offsetScalingFactor; //NOTE: This value of the ".o" variable is never used - .o is set immediately before it gets used
|
|
|
1513 pwp->shift = pwp->uiLog2WeightDenom;
|
|
|
1514 pwp->round = (pwp->uiLog2WeightDenom>=1) ? (1 << (pwp->uiLog2WeightDenom-1)) : (0);
|
|
|
1515 }
|
|
|
1516 }
|
|
|
1517 }
|
|
|
1518 }
|
|
|
1519
|
|
|
1520 // ------------------------------------------------------------------------------------------------
|
|
|
1521 // Video parameter set (VPS)
|
|
|
1522 // ------------------------------------------------------------------------------------------------
|
|
|
1523 TComVPS::TComVPS()
|
|
|
1524 : m_VPSId ( 0)
|
|
|
1525 , m_uiMaxTLayers ( 1)
|
|
|
1526 , m_uiMaxLayers ( 1)
|
|
|
1527 , m_bTemporalIdNestingFlag (false)
|
|
|
1528 , m_numHrdParameters ( 0)
|
|
|
1529 , m_maxNuhReservedZeroLayerId ( 0)
|
|
|
1530 , m_hrdParameters (NULL)
|
|
|
1531 , m_hrdOpSetIdx (NULL)
|
|
|
1532 , m_cprmsPresentFlag (NULL)
|
|
|
1533 {
|
|
|
1534
|
|
|
1535 for( Int i = 0; i < MAX_TLAYER; i++)
|
|
|
1536 {
|
|
|
1537 m_numReorderPics[i] = 0;
|
|
|
1538 m_uiMaxDecPicBuffering[i] = 1;
|
|
|
1539 m_uiMaxLatencyIncrease[i] = 0;
|
|
|
1540 }
|
|
|
1541 }
|
|
|
1542
|
|
|
1543 TComVPS::~TComVPS()
|
|
|
1544 {
|
|
|
1545 if( m_hrdParameters != NULL ) delete[] m_hrdParameters;
|
|
|
1546 if( m_hrdOpSetIdx != NULL ) delete[] m_hrdOpSetIdx;
|
|
|
1547 if( m_cprmsPresentFlag != NULL ) delete[] m_cprmsPresentFlag;
|
|
|
1548 }
|
|
|
1549
|
|
|
1550 // ------------------------------------------------------------------------------------------------
|
|
|
1551 // Sequence parameter set (SPS)
|
|
|
1552 // ------------------------------------------------------------------------------------------------
|
|
|
1553
|
|
|
1554 TComSPS::TComSPS()
|
|
|
1555 : m_SPSId ( 0)
|
|
|
1556 , m_VPSId ( 0)
|
|
|
1557 , m_chromaFormatIdc (CHROMA_420)
|
|
|
1558 , m_uiMaxTLayers ( 1)
|
|
|
1559 // Structure
|
|
|
1560 , m_picWidthInLumaSamples (352)
|
|
|
1561 , m_picHeightInLumaSamples (288)
|
|
|
1562 , m_log2MinCodingBlockSize ( 0)
|
|
|
1563 , m_log2DiffMaxMinCodingBlockSize(0)
|
|
|
1564 , m_uiMaxCUWidth ( 32)
|
|
|
1565 , m_uiMaxCUHeight ( 32)
|
|
|
1566 , m_uiMaxCUDepth ( 3)
|
|
|
1567 , m_bLongTermRefsPresent (false)
|
|
|
1568 , m_uiQuadtreeTULog2MaxSize ( 0)
|
|
|
1569 , m_uiQuadtreeTULog2MinSize ( 0)
|
|
|
1570 , m_uiQuadtreeTUMaxDepthInter ( 0)
|
|
|
1571 , m_uiQuadtreeTUMaxDepthIntra ( 0)
|
|
|
1572 // Tool list
|
|
|
1573 , m_usePCM (false)
|
|
|
1574 , m_pcmLog2MaxSize ( 5)
|
|
|
1575 , m_uiPCMLog2MinSize ( 7)
|
|
|
1576 , m_useExtendedPrecision (false)
|
|
|
1577 , m_useHighPrecisionPredictionWeighting(false)
|
|
|
1578 , m_useResidualRotation (false)
|
|
|
1579 , m_useSingleSignificanceMapContext(false)
|
|
|
1580 , m_useGolombRiceParameterAdaptation(false)
|
|
|
1581 , m_alignCABACBeforeBypass (false)
|
|
|
1582 , m_bPCMFilterDisableFlag (false)
|
|
|
1583 , m_disableIntraReferenceSmoothing(false)
|
|
|
1584 , m_uiBitsForPOC ( 8)
|
|
|
1585 , m_numLongTermRefPicSPS ( 0)
|
|
|
1586 , m_uiMaxTrSize ( 32)
|
|
|
1587 , m_bUseSAO (false)
|
|
|
1588 , m_bTemporalIdNestingFlag (false)
|
|
|
1589 , m_scalingListEnabledFlag (false)
|
|
|
1590 , m_useStrongIntraSmoothing (false)
|
|
|
1591 , m_vuiParametersPresentFlag (false)
|
|
|
1592 , m_vuiParameters ()
|
|
|
1593 {
|
|
|
1594 for(Int ch=0; ch<MAX_NUM_CHANNEL_TYPE; ch++)
|
|
|
1595 {
|
|
|
1596 m_uiBitDepth [ch] = 8;
|
|
|
1597 m_uiPCMBitDepth[ch] = 8;
|
|
|
1598 m_qpBDOffset [ch] = 0;
|
|
|
1599 }
|
|
|
1600
|
|
|
1601 for ( Int i = 0; i < MAX_TLAYER; i++ )
|
|
|
1602 {
|
|
|
1603 m_uiMaxLatencyIncrease[i] = 0;
|
|
|
1604 m_uiMaxDecPicBuffering[i] = 1;
|
|
|
1605 m_numReorderPics[i] = 0;
|
|
|
1606 }
|
|
|
1607
|
|
|
1608 for (UInt signallingModeIndex = 0; signallingModeIndex < NUMBER_OF_RDPCM_SIGNALLING_MODES; signallingModeIndex++)
|
|
|
1609 {
|
|
|
1610 m_useResidualDPCM[signallingModeIndex] = false;
|
|
|
1611 }
|
|
|
1612
|
|
|
1613 m_scalingList = new TComScalingList;
|
|
|
1614 ::memset(m_ltRefPicPocLsbSps, 0, sizeof(m_ltRefPicPocLsbSps));
|
|
|
1615 ::memset(m_usedByCurrPicLtSPSFlag, 0, sizeof(m_usedByCurrPicLtSPSFlag));
|
|
|
1616 }
|
|
|
1617
|
|
|
1618 TComSPS::~TComSPS()
|
|
|
1619 {
|
|
|
1620 delete m_scalingList;
|
|
|
1621 m_RPSList.destroy();
|
|
|
1622 }
|
|
|
1623
|
|
|
1624 Void TComSPS::createRPSList( Int numRPS )
|
|
|
1625 {
|
|
|
1626 m_RPSList.destroy();
|
|
|
1627 m_RPSList.create(numRPS);
|
|
|
1628 }
|
|
|
1629
|
|
|
1630 Void TComSPS::setHrdParameters( UInt frameRate, UInt numDU, UInt bitRate, Bool randomAccess )
|
|
|
1631 {
|
|
|
1632 if( !getVuiParametersPresentFlag() )
|
|
|
1633 {
|
|
|
1634 return;
|
|
|
1635 }
|
|
|
1636
|
|
|
1637 TComVUI *vui = getVuiParameters();
|
|
|
1638 TComHRD *hrd = vui->getHrdParameters();
|
|
|
1639
|
|
|
1640 TimingInfo *timingInfo = vui->getTimingInfo();
|
|
|
1641 timingInfo->setTimingInfoPresentFlag( true );
|
|
|
1642 switch( frameRate )
|
|
|
1643 {
|
|
|
1644 case 24:
|
|
|
1645 timingInfo->setNumUnitsInTick( 1125000 ); timingInfo->setTimeScale ( 27000000 );
|
|
|
1646 break;
|
|
|
1647 case 25:
|
|
|
1648 timingInfo->setNumUnitsInTick( 1080000 ); timingInfo->setTimeScale ( 27000000 );
|
|
|
1649 break;
|
|
|
1650 case 30:
|
|
|
1651 timingInfo->setNumUnitsInTick( 900900 ); timingInfo->setTimeScale ( 27000000 );
|
|
|
1652 break;
|
|
|
1653 case 50:
|
|
|
1654 timingInfo->setNumUnitsInTick( 540000 ); timingInfo->setTimeScale ( 27000000 );
|
|
|
1655 break;
|
|
|
1656 case 60:
|
|
|
1657 timingInfo->setNumUnitsInTick( 450450 ); timingInfo->setTimeScale ( 27000000 );
|
|
|
1658 break;
|
|
|
1659 default:
|
|
|
1660 timingInfo->setNumUnitsInTick( 1001 ); timingInfo->setTimeScale ( 60000 );
|
|
|
1661 break;
|
|
|
1662 }
|
|
|
1663
|
|
|
1664 Bool rateCnt = ( bitRate > 0 );
|
|
|
1665 hrd->setNalHrdParametersPresentFlag( rateCnt );
|
|
|
1666 hrd->setVclHrdParametersPresentFlag( rateCnt );
|
|
|
1667
|
|
|
1668 hrd->setSubPicCpbParamsPresentFlag( ( numDU > 1 ) );
|
|
|
1669
|
|
|
1670 if( hrd->getSubPicCpbParamsPresentFlag() )
|
|
|
1671 {
|
|
|
1672 hrd->setTickDivisorMinus2( 100 - 2 ); //
|
|
|
1673 hrd->setDuCpbRemovalDelayLengthMinus1( 7 ); // 8-bit precision ( plus 1 for last DU in AU )
|
|
|
1674 hrd->setSubPicCpbParamsInPicTimingSEIFlag( true );
|
|
|
1675 hrd->setDpbOutputDelayDuLengthMinus1( 5 + 7 ); // With sub-clock tick factor of 100, at least 7 bits to have the same value as AU dpb delay
|
|
|
1676 }
|
|
|
1677 else
|
|
|
1678 {
|
|
|
1679 hrd->setSubPicCpbParamsInPicTimingSEIFlag( false );
|
|
|
1680 }
|
|
|
1681
|
|
|
1682 hrd->setBitRateScale( 4 ); // in units of 2~( 6 + 4 ) = 1,024 bps
|
|
|
1683 hrd->setCpbSizeScale( 6 ); // in units of 2~( 4 + 4 ) = 1,024 bit
|
|
|
1684 hrd->setDuCpbSizeScale( 6 ); // in units of 2~( 4 + 4 ) = 1,024 bit
|
|
|
1685
|
|
|
1686 hrd->setInitialCpbRemovalDelayLengthMinus1(15); // assuming 0.5 sec, log2( 90,000 * 0.5 ) = 16-bit
|
|
|
1687 if( randomAccess )
|
|
|
1688 {
|
|
|
1689 hrd->setCpbRemovalDelayLengthMinus1(5); // 32 = 2^5 (plus 1)
|
|
|
1690 hrd->setDpbOutputDelayLengthMinus1 (5); // 32 + 3 = 2^6
|
|
|
1691 }
|
|
|
1692 else
|
|
|
1693 {
|
|
|
1694 hrd->setCpbRemovalDelayLengthMinus1(9); // max. 2^10
|
|
|
1695 hrd->setDpbOutputDelayLengthMinus1 (9); // max. 2^10
|
|
|
1696 }
|
|
|
1697
|
|
|
1698 /*
|
|
|
1699 Note: only the case of "vps_max_temporal_layers_minus1 = 0" is supported.
|
|
|
1700 */
|
|
|
1701 Int i, j;
|
|
|
1702 UInt bitrateValue, cpbSizeValue;
|
|
|
1703 UInt duCpbSizeValue;
|
|
|
1704 UInt duBitRateValue = 0;
|
|
|
1705
|
|
|
1706 for( i = 0; i < MAX_TLAYER; i ++ )
|
|
|
1707 {
|
|
|
1708 hrd->setFixedPicRateFlag( i, 1 );
|
|
|
1709 hrd->setPicDurationInTcMinus1( i, 0 );
|
|
|
1710 hrd->setLowDelayHrdFlag( i, 0 );
|
|
|
1711 hrd->setCpbCntMinus1( i, 0 );
|
|
|
1712
|
|
|
1713 bitrateValue = bitRate;
|
|
|
1714 cpbSizeValue = bitRate; // 1 second
|
|
|
1715 duCpbSizeValue = bitRate/numDU;
|
|
|
1716 duBitRateValue = bitRate;
|
|
|
1717
|
|
|
1718 for( j = 0; j < ( hrd->getCpbCntMinus1( i ) + 1 ); j ++ )
|
|
|
1719 {
|
|
|
1720 hrd->setBitRateValueMinus1( i, j, 0, ( bitrateValue - 1 ) );
|
|
|
1721 hrd->setCpbSizeValueMinus1( i, j, 0, ( cpbSizeValue - 1 ) );
|
|
|
1722 hrd->setDuCpbSizeValueMinus1( i, j, 0, ( duCpbSizeValue - 1 ) );
|
|
|
1723 hrd->setCbrFlag( i, j, 0, ( j == 0 ) );
|
|
|
1724
|
|
|
1725 hrd->setBitRateValueMinus1( i, j, 1, ( bitrateValue - 1) );
|
|
|
1726 hrd->setCpbSizeValueMinus1( i, j, 1, ( cpbSizeValue - 1 ) );
|
|
|
1727 hrd->setDuCpbSizeValueMinus1( i, j, 1, ( duCpbSizeValue - 1 ) );
|
|
|
1728 hrd->setDuBitRateValueMinus1( i, j, 1, ( duBitRateValue - 1 ) );
|
|
|
1729 hrd->setCbrFlag( i, j, 1, ( j == 0 ) );
|
|
|
1730 }
|
|
|
1731 }
|
|
|
1732 }
|
|
|
1733
|
|
|
1734 const Int TComSPS::m_winUnitX[]={1,2,2,1};
|
|
|
1735 const Int TComSPS::m_winUnitY[]={1,2,1,1};
|
|
|
1736
|
|
|
1737 TComPPS::TComPPS()
|
|
|
1738 : m_PPSId (0)
|
|
|
1739 , m_SPSId (0)
|
|
|
1740 , m_picInitQPMinus26 (0)
|
|
|
1741 , m_useDQP (false)
|
|
|
1742 , m_bConstrainedIntraPred (false)
|
|
|
1743 , m_bSliceChromaQpFlag (false)
|
|
|
1744 , m_pcSPS (NULL)
|
|
|
1745 , m_uiMaxCuDQPDepth (0)
|
|
|
1746 , m_uiMinCuDQPSize (0)
|
|
|
1747 , m_MaxCuChromaQpAdjDepth (0)
|
|
|
1748 , m_MinCuChromaQpAdjSize (0)
|
|
|
1749 , m_ChromaQpAdjTableSize (0)
|
|
|
1750 , m_chromaCbQpOffset (0)
|
|
|
1751 , m_chromaCrQpOffset (0)
|
|
|
1752 , m_numRefIdxL0DefaultActive (1)
|
|
|
1753 , m_numRefIdxL1DefaultActive (1)
|
|
|
1754 , m_useCrossComponentPrediction (false)
|
|
|
1755 , m_TransquantBypassEnableFlag (false)
|
|
|
1756 , m_useTransformSkip (false)
|
|
|
1757 , m_transformSkipLog2MaxSize (2)
|
|
|
1758 , m_dependentSliceSegmentsEnabledFlag(false)
|
|
|
1759 , m_tilesEnabledFlag (false)
|
|
|
1760 , m_entropyCodingSyncEnabledFlag (false)
|
|
|
1761 , m_loopFilterAcrossTilesEnabledFlag (true)
|
|
|
1762 , m_uniformSpacingFlag (false)
|
|
|
1763 , m_numTileColumnsMinus1 (0)
|
|
|
1764 , m_numTileRowsMinus1 (0)
|
|
|
1765 , m_numSubstreams (1)
|
|
|
1766 , m_signHideFlag (0)
|
|
|
1767 , m_cabacInitPresentFlag (false)
|
|
|
1768 , m_encCABACTableIdx (I_SLICE)
|
|
|
1769 , m_sliceHeaderExtensionPresentFlag (false)
|
|
|
1770 , m_loopFilterAcrossSlicesEnabledFlag(false)
|
|
|
1771 , m_listsModificationPresentFlag (0)
|
|
|
1772 , m_numExtraSliceHeaderBits (0)
|
|
|
1773 {
|
|
|
1774 m_scalingList = new TComScalingList;
|
|
|
1775 for(Int ch=0; ch<MAX_NUM_CHANNEL_TYPE; ch++)
|
|
|
1776 {
|
|
|
1777 m_saoOffsetBitShift[ch] = 0;
|
|
|
1778 }
|
|
|
1779 m_ChromaQpAdjTable[0].u.comp.CbOffset = 0;
|
|
|
1780 m_ChromaQpAdjTable[0].u.comp.CrOffset = 0;
|
|
|
1781 }
|
|
|
1782
|
|
|
1783 TComPPS::~TComPPS()
|
|
|
1784 {
|
|
|
1785 delete m_scalingList;
|
|
|
1786 }
|
|
|
1787
|
|
|
1788 TComReferencePictureSet::TComReferencePictureSet()
|
|
|
1789 : m_numberOfPictures (0)
|
|
|
1790 , m_numberOfNegativePictures (0)
|
|
|
1791 , m_numberOfPositivePictures (0)
|
|
|
1792 , m_numberOfLongtermPictures (0)
|
|
|
1793 , m_interRPSPrediction (0)
|
|
|
1794 , m_deltaRIdxMinus1 (0)
|
|
|
1795 , m_deltaRPS (0)
|
|
|
1796 , m_numRefIdc (0)
|
|
|
1797 {
|
|
|
1798 ::memset( m_deltaPOC, 0, sizeof(m_deltaPOC) );
|
|
|
1799 ::memset( m_POC, 0, sizeof(m_POC) );
|
|
|
1800 ::memset( m_used, 0, sizeof(m_used) );
|
|
|
1801 ::memset( m_refIdc, 0, sizeof(m_refIdc) );
|
|
|
1802 }
|
|
|
1803
|
|
|
1804 TComReferencePictureSet::~TComReferencePictureSet()
|
|
|
1805 {
|
|
|
1806 }
|
|
|
1807
|
|
|
1808 Void TComReferencePictureSet::setUsed(Int bufferNum, Bool used)
|
|
|
1809 {
|
|
|
1810 m_used[bufferNum] = used;
|
|
|
1811 }
|
|
|
1812
|
|
|
1813 Void TComReferencePictureSet::setDeltaPOC(Int bufferNum, Int deltaPOC)
|
|
|
1814 {
|
|
|
1815 m_deltaPOC[bufferNum] = deltaPOC;
|
|
|
1816 }
|
|
|
1817
|
|
|
1818 Void TComReferencePictureSet::setNumberOfPictures(Int numberOfPictures)
|
|
|
1819 {
|
|
|
1820 m_numberOfPictures = numberOfPictures;
|
|
|
1821 }
|
|
|
1822
|
|
|
1823 Int TComReferencePictureSet::getUsed(Int bufferNum)
|
|
|
1824 {
|
|
|
1825 return m_used[bufferNum];
|
|
|
1826 }
|
|
|
1827
|
|
|
1828 Int TComReferencePictureSet::getDeltaPOC(Int bufferNum)
|
|
|
1829 {
|
|
|
1830 return m_deltaPOC[bufferNum];
|
|
|
1831 }
|
|
|
1832
|
|
|
1833 Int TComReferencePictureSet::getNumberOfPictures()
|
|
|
1834 {
|
|
|
1835 return m_numberOfPictures;
|
|
|
1836 }
|
|
|
1837
|
|
|
1838 Int TComReferencePictureSet::getPOC(Int bufferNum)
|
|
|
1839 {
|
|
|
1840 return m_POC[bufferNum];
|
|
|
1841 }
|
|
|
1842
|
|
|
1843 Void TComReferencePictureSet::setPOC(Int bufferNum, Int POC)
|
|
|
1844 {
|
|
|
1845 m_POC[bufferNum] = POC;
|
|
|
1846 }
|
|
|
1847
|
|
|
1848 Bool TComReferencePictureSet::getCheckLTMSBPresent(Int bufferNum)
|
|
|
1849 {
|
|
|
1850 return m_bCheckLTMSB[bufferNum];
|
|
|
1851 }
|
|
|
1852
|
|
|
1853 Void TComReferencePictureSet::setCheckLTMSBPresent(Int bufferNum, Bool b)
|
|
|
1854 {
|
|
|
1855 m_bCheckLTMSB[bufferNum] = b;
|
|
|
1856 }
|
|
|
1857
|
|
|
1858 /** set the reference idc value at uiBufferNum entry to the value of iRefIdc
|
|
|
1859 * \param uiBufferNum
|
|
|
1860 * \param iRefIdc
|
|
|
1861 * \returns Void
|
|
|
1862 */
|
|
|
1863 Void TComReferencePictureSet::setRefIdc(Int bufferNum, Int refIdc)
|
|
|
1864 {
|
|
|
1865 m_refIdc[bufferNum] = refIdc;
|
|
|
1866 }
|
|
|
1867
|
|
|
1868 /** get the reference idc value at uiBufferNum
|
|
|
1869 * \param uiBufferNum
|
|
|
1870 * \returns Int
|
|
|
1871 */
|
|
|
1872 Int TComReferencePictureSet::getRefIdc(Int bufferNum)
|
|
|
1873 {
|
|
|
1874 return m_refIdc[bufferNum];
|
|
|
1875 }
|
|
|
1876
|
|
|
1877 /** Sorts the deltaPOC and Used by current values in the RPS based on the deltaPOC values.
|
|
|
1878 * deltaPOC values are sorted with -ve values before the +ve values. -ve values are in decreasing order.
|
|
|
1879 * +ve values are in increasing order.
|
|
|
1880 * \returns Void
|
|
|
1881 */
|
|
|
1882 Void TComReferencePictureSet::sortDeltaPOC()
|
|
|
1883 {
|
|
|
1884 // sort in increasing order (smallest first)
|
|
|
1885 for(Int j=1; j < getNumberOfPictures(); j++)
|
|
|
1886 {
|
|
|
1887 Int deltaPOC = getDeltaPOC(j);
|
|
|
1888 Bool used = getUsed(j);
|
|
|
1889 for (Int k=j-1; k >= 0; k--)
|
|
|
1890 {
|
|
|
1891 Int temp = getDeltaPOC(k);
|
|
|
1892 if (deltaPOC < temp)
|
|
|
1893 {
|
|
|
1894 setDeltaPOC(k+1, temp);
|
|
|
1895 setUsed(k+1, getUsed(k));
|
|
|
1896 setDeltaPOC(k, deltaPOC);
|
|
|
1897 setUsed(k, used);
|
|
|
1898 }
|
|
|
1899 }
|
|
|
1900 }
|
|
|
1901 // flip the negative values to largest first
|
|
|
1902 Int numNegPics = getNumberOfNegativePictures();
|
|
|
1903 for(Int j=0, k=numNegPics-1; j < numNegPics>>1; j++, k--)
|
|
|
1904 {
|
|
|
1905 Int deltaPOC = getDeltaPOC(j);
|
|
|
1906 Bool used = getUsed(j);
|
|
|
1907 setDeltaPOC(j, getDeltaPOC(k));
|
|
|
1908 setUsed(j, getUsed(k));
|
|
|
1909 setDeltaPOC(k, deltaPOC);
|
|
|
1910 setUsed(k, used);
|
|
|
1911 }
|
|
|
1912 }
|
|
|
1913
|
|
|
1914 /** Prints the deltaPOC and RefIdc (if available) values in the RPS.
|
|
|
1915 * A "*" is added to the deltaPOC value if it is Used bu current.
|
|
|
1916 * \returns Void
|
|
|
1917 */
|
|
|
1918 Void TComReferencePictureSet::printDeltaPOC()
|
|
|
1919 {
|
|
|
1920 printf("DeltaPOC = { ");
|
|
|
1921 for(Int j=0; j < getNumberOfPictures(); j++)
|
|
|
1922 {
|
|
|
1923 printf("%d%s ", getDeltaPOC(j), (getUsed(j)==1)?"*":"");
|
|
|
1924 }
|
|
|
1925 if (getInterRPSPrediction())
|
|
|
1926 {
|
|
|
1927 printf("}, RefIdc = { ");
|
|
|
1928 for(Int j=0; j < getNumRefIdc(); j++)
|
|
|
1929 {
|
|
|
1930 printf("%d ", getRefIdc(j));
|
|
|
1931 }
|
|
|
1932 }
|
|
|
1933 printf("}\n");
|
|
|
1934 }
|
|
|
1935
|
|
|
1936 TComRPSList::TComRPSList()
|
|
|
1937 :m_referencePictureSets (NULL)
|
|
|
1938 {
|
|
|
1939 }
|
|
|
1940
|
|
|
1941 TComRPSList::~TComRPSList()
|
|
|
1942 {
|
|
|
1943 }
|
|
|
1944
|
|
|
1945 Void TComRPSList::create( Int numberOfReferencePictureSets)
|
|
|
1946 {
|
|
|
1947 m_numberOfReferencePictureSets = numberOfReferencePictureSets;
|
|
|
1948 m_referencePictureSets = new TComReferencePictureSet[numberOfReferencePictureSets];
|
|
|
1949 }
|
|
|
1950
|
|
|
1951 Void TComRPSList::destroy()
|
|
|
1952 {
|
|
|
1953 if (m_referencePictureSets)
|
|
|
1954 {
|
|
|
1955 delete [] m_referencePictureSets;
|
|
|
1956 }
|
|
|
1957 m_numberOfReferencePictureSets = 0;
|
|
|
1958 m_referencePictureSets = NULL;
|
|
|
1959 }
|
|
|
1960
|
|
|
1961
|
|
|
1962
|
|
|
1963 TComReferencePictureSet* TComRPSList::getReferencePictureSet(Int referencePictureSetNum)
|
|
|
1964 {
|
|
|
1965 return &m_referencePictureSets[referencePictureSetNum];
|
|
|
1966 }
|
|
|
1967
|
|
|
1968 Int TComRPSList::getNumberOfReferencePictureSets()
|
|
|
1969 {
|
|
|
1970 return m_numberOfReferencePictureSets;
|
|
|
1971 }
|
|
|
1972
|
|
|
1973 Void TComRPSList::setNumberOfReferencePictureSets(Int numberOfReferencePictureSets)
|
|
|
1974 {
|
|
|
1975 m_numberOfReferencePictureSets = numberOfReferencePictureSets;
|
|
|
1976 }
|
|
|
1977
|
|
|
1978 TComRefPicListModification::TComRefPicListModification()
|
|
|
1979 : m_bRefPicListModificationFlagL0 (false)
|
|
|
1980 , m_bRefPicListModificationFlagL1 (false)
|
|
|
1981 {
|
|
|
1982 ::memset( m_RefPicSetIdxL0, 0, sizeof(m_RefPicSetIdxL0) );
|
|
|
1983 ::memset( m_RefPicSetIdxL1, 0, sizeof(m_RefPicSetIdxL1) );
|
|
|
1984 }
|
|
|
1985
|
|
|
1986 TComRefPicListModification::~TComRefPicListModification()
|
|
|
1987 {
|
|
|
1988 }
|
|
|
1989
|
|
|
1990 TComScalingList::TComScalingList()
|
|
|
1991 {
|
|
|
1992 init();
|
|
|
1993 }
|
|
|
1994
|
|
|
1995 TComScalingList::~TComScalingList()
|
|
|
1996 {
|
|
|
1997 destroy();
|
|
|
1998 }
|
|
|
1999
|
|
|
2000 /** set default quantization matrix to array
|
|
|
2001 */
|
|
|
2002 Void TComSlice::setDefaultScalingList()
|
|
|
2003 {
|
|
|
2004 for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
|
|
|
2005 {
|
|
|
2006 for(UInt listId=0;listId<SCALING_LIST_NUM;listId++)
|
|
|
2007 {
|
|
|
2008 getScalingList()->processDefaultMatrix(sizeId, listId);
|
|
|
2009 }
|
|
|
2010 }
|
|
|
2011 }
|
|
|
2012 /** check if use default quantization matrix
|
|
|
2013 * \returns true if use default quantization matrix in all size
|
|
|
2014 */
|
|
|
2015 Bool TComSlice::checkDefaultScalingList()
|
|
|
2016 {
|
|
|
2017 UInt defaultCounter=0;
|
|
|
2018
|
|
|
2019 for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
|
|
|
2020 {
|
|
|
2021 for(UInt listId=0;listId<SCALING_LIST_NUM;listId++)
|
|
|
2022 {
|
|
|
2023 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
|
|
|
2024 && ((sizeId < SCALING_LIST_16x16) || (getScalingList()->getScalingListDC(sizeId,listId) == 16))) // check DC value
|
|
|
2025 {
|
|
|
2026 defaultCounter++;
|
|
|
2027 }
|
|
|
2028 }
|
|
|
2029 }
|
|
|
2030
|
|
|
2031 return (defaultCounter == (SCALING_LIST_NUM * SCALING_LIST_SIZE_NUM )) ? false : true;
|
|
|
2032 }
|
|
|
2033
|
|
|
2034 /** get scaling matrix from RefMatrixID
|
|
|
2035 * \param sizeId size index
|
|
|
2036 * \param Index of input matrix
|
|
|
2037 * \param Index of reference matrix
|
|
|
2038 */
|
|
|
2039 Void TComScalingList::processRefMatrix( UInt sizeId, UInt listId , UInt refListId )
|
|
|
2040 {
|
|
|
2041 ::memcpy(getScalingListAddress(sizeId, listId),((listId == refListId)? getScalingListDefaultAddress(sizeId, refListId): getScalingListAddress(sizeId, refListId)),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
|
|
|
2042 }
|
|
|
2043
|
|
|
2044 /** parse syntax infomation
|
|
|
2045 * \param pchFile syntax infomation
|
|
|
2046 * \returns false if successful
|
|
|
2047 */
|
|
|
2048
|
|
|
2049 static Void outputScalingListHelp(std::ostream &os)
|
|
|
2050 {
|
|
|
2051 os << "The scaling list file specifies all matrices and their DC values; none can be missing,\n"
|
|
|
2052 "but their order is arbitrary.\n\n"
|
|
|
2053 "The matrices are specified by:\n"
|
|
|
2054 "<matrix name><unchecked data>\n"
|
|
|
2055 " <value>,<value>,<value>,....\n\n"
|
|
|
2056 " Line-feeds can be added arbitrarily between values, and the number of values needs to be\n"
|
|
|
2057 " at least the number of entries for the matrix (superfluous entries are ignored).\n"
|
|
|
2058 " The <unchecked data> is text on the same line as the matrix that is not checked\n"
|
|
|
2059 " except to ensure that the matrix name token is unique. It is recommended that it is ' ='\n"
|
|
|
2060 " The values in the matrices are the absolute values (0-255), not the delta values as\n"
|
|
|
2061 " exchanged between the encoder and decoder\n\n"
|
|
|
2062 "The DC values (for matrix sizes larger than 8x8) are specified by:\n"
|
|
|
2063 "<matrix name>_DC<unchecked data>\n"
|
|
|
2064 " <value>\n";
|
|
|
2065
|
|
|
2066 os << "The permitted matrix names are:\n";
|
|
|
2067 for(UInt sizeIdc = 0; sizeIdc < SCALING_LIST_SIZE_NUM; sizeIdc++)
|
|
|
2068 {
|
|
|
2069 for(UInt listIdc = 0; listIdc < SCALING_LIST_NUM; listIdc++)
|
|
|
2070 {
|
|
|
2071 if ((sizeIdc!=SCALING_LIST_32x32) || (listIdc%(SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES) == 0))
|
|
|
2072 {
|
|
|
2073 os << " " << MatrixType[sizeIdc][listIdc] << '\n';
|
|
|
2074 }
|
|
|
2075 }
|
|
|
2076 }
|
|
|
2077 }
|
|
|
2078
|
|
|
2079 Void TComScalingList::outputScalingLists(std::ostream &os) const
|
|
|
2080 {
|
|
|
2081 for(UInt sizeIdc = 0; sizeIdc < SCALING_LIST_SIZE_NUM; sizeIdc++)
|
|
|
2082 {
|
|
|
2083 const UInt size = min(8,4<<(sizeIdc));
|
|
|
2084 for(UInt listIdc = 0; listIdc < SCALING_LIST_NUM; listIdc++)
|
|
|
2085 {
|
|
|
2086 if ((sizeIdc!=SCALING_LIST_32x32) || (listIdc%(SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES) == 0))
|
|
|
2087 {
|
|
|
2088 const Int *src = getScalingListAddress(sizeIdc, listIdc);
|
|
|
2089 os << (MatrixType[sizeIdc][listIdc]) << " =\n ";
|
|
|
2090 for(UInt y=0; y<size; y++)
|
|
|
2091 {
|
|
|
2092 for(UInt x=0; x<size; x++, src++)
|
|
|
2093 {
|
|
|
2094 os << std::setw(3) << (*src) << ", ";
|
|
|
2095 }
|
|
|
2096 os << (y+1<size?"\n ":"\n");
|
|
|
2097 }
|
|
|
2098 if(sizeIdc > SCALING_LIST_8x8)
|
|
|
2099 {
|
|
|
2100 os << MatrixType_DC[sizeIdc][listIdc] << " = \n " << std::setw(3) << getScalingListDC(sizeIdc, listIdc) << "\n";
|
|
|
2101 }
|
|
|
2102 os << "\n";
|
|
|
2103 }
|
|
|
2104 }
|
|
|
2105 }
|
|
|
2106 }
|
|
|
2107
|
|
|
2108 Bool TComScalingList::xParseScalingList(Char* pchFile)
|
|
|
2109 {
|
|
|
2110 static const Int LINE_SIZE=1024;
|
|
|
2111 FILE *fp = NULL;
|
|
|
2112 Char line[LINE_SIZE];
|
|
|
2113
|
|
|
2114 if (pchFile == NULL)
|
|
|
2115 {
|
|
|
2116 fprintf(stderr, "Error: no scaling list file specified. Help on scaling lists being output\n");
|
|
|
2117 outputScalingListHelp(std::cout);
|
|
|
2118 std::cout << "\n\nExample scaling list file using default values:\n\n";
|
|
|
2119 outputScalingLists(std::cout);
|
|
|
2120 exit (1);
|
|
|
2121 return true;
|
|
|
2122 }
|
|
|
2123 else if ((fp = fopen(pchFile,"r")) == (FILE*)NULL)
|
|
|
2124 {
|
|
|
2125 fprintf(stderr, "Error: cannot open scaling list file %s for reading\n",pchFile);
|
|
|
2126 return true;
|
|
|
2127 }
|
|
|
2128
|
|
|
2129 for(UInt sizeIdc = 0; sizeIdc < SCALING_LIST_SIZE_NUM; sizeIdc++)
|
|
|
2130 {
|
|
|
2131 const UInt size = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeIdc]);
|
|
|
2132
|
|
|
2133 for(UInt listIdc = 0; listIdc < SCALING_LIST_NUM; listIdc++)
|
|
|
2134 {
|
|
|
2135 Int * const src = getScalingListAddress(sizeIdc, listIdc);
|
|
|
2136
|
|
|
2137 if ((sizeIdc==SCALING_LIST_32x32) && (listIdc%(SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES) != 0)) // derive chroma32x32 from chroma16x16
|
|
|
2138 {
|
|
|
2139 const Int *srcNextSmallerSize = getScalingListAddress(sizeIdc-1, listIdc);
|
|
|
2140 for(UInt i=0; i<size; i++)
|
|
|
2141 {
|
|
|
2142 src[i] = srcNextSmallerSize[i];
|
|
|
2143 }
|
|
|
2144 setScalingListDC(sizeIdc,listIdc,(sizeIdc > SCALING_LIST_8x8) ? getScalingListDC(sizeIdc-1, listIdc) : src[0]);
|
|
|
2145 }
|
|
|
2146 else
|
|
|
2147 {
|
|
|
2148 {
|
|
|
2149 fseek(fp, 0, SEEK_SET);
|
|
|
2150 Bool bFound=false;
|
|
|
2151 while ((!feof(fp)) && (!bFound))
|
|
|
2152 {
|
|
|
2153 Char *ret = fgets(line, LINE_SIZE, fp);
|
|
|
2154 Char *findNamePosition= ret==NULL ? NULL : strstr(line, MatrixType[sizeIdc][listIdc]);
|
|
|
2155 // This could be a match against the DC string as well, so verify it isn't
|
|
|
2156 if (findNamePosition!= NULL && (MatrixType_DC[sizeIdc][listIdc]==NULL || strstr(line, MatrixType_DC[sizeIdc][listIdc])==NULL))
|
|
|
2157 {
|
|
|
2158 bFound=true;
|
|
|
2159 }
|
|
|
2160 }
|
|
|
2161 if (!bFound)
|
|
|
2162 {
|
|
|
2163 fprintf(stderr, "Error: cannot find Matrix %s from scaling list file %s\n", MatrixType[sizeIdc][listIdc], pchFile);
|
|
|
2164 return true;
|
|
|
2165 }
|
|
|
2166 }
|
|
|
2167 for (UInt i=0; i<size; i++)
|
|
|
2168 {
|
|
|
2169 Int data;
|
|
|
2170 if (fscanf(fp, "%d,", &data)!=1)
|
|
|
2171 {
|
|
|
2172 fprintf(stderr, "Error: cannot read value #%d for Matrix %s from scaling list file %s at file position %ld\n", i, MatrixType[sizeIdc][listIdc], pchFile, ftell(fp));
|
|
|
2173 return true;
|
|
|
2174 }
|
|
|
2175 if (data<0 || data>255)
|
|
|
2176 {
|
|
|
2177 fprintf(stderr, "Error: QMatrix entry #%d of value %d for Matrix %s from scaling list file %s at file position %ld is out of range (0 to 255)\n", i, data, MatrixType[sizeIdc][listIdc], pchFile, ftell(fp));
|
|
|
2178 return true;
|
|
|
2179 }
|
|
|
2180 src[i] = data;
|
|
|
2181 }
|
|
|
2182
|
|
|
2183 //set DC value for default matrix check
|
|
|
2184 setScalingListDC(sizeIdc,listIdc,src[0]);
|
|
|
2185
|
|
|
2186 if(sizeIdc > SCALING_LIST_8x8)
|
|
|
2187 {
|
|
|
2188 {
|
|
|
2189 fseek(fp, 0, SEEK_SET);
|
|
|
2190 Bool bFound=false;
|
|
|
2191 while ((!feof(fp)) && (!bFound))
|
|
|
2192 {
|
|
|
2193 Char *ret = fgets(line, LINE_SIZE, fp);
|
|
|
2194 Char *findNamePosition= ret==NULL ? NULL : strstr(line, MatrixType_DC[sizeIdc][listIdc]);
|
|
|
2195 if (findNamePosition!= NULL)
|
|
|
2196 {
|
|
|
2197 // This won't be a match against the non-DC string.
|
|
|
2198 bFound=true;
|
|
|
2199 }
|
|
|
2200 }
|
|
|
2201 if (!bFound)
|
|
|
2202 {
|
|
|
2203 fprintf(stderr, "Error: cannot find DC Matrix %s from scaling list file %s\n", MatrixType_DC[sizeIdc][listIdc], pchFile);
|
|
|
2204 return true;
|
|
|
2205 }
|
|
|
2206 }
|
|
|
2207 Int data;
|
|
|
2208 if (fscanf(fp, "%d,", &data)!=1)
|
|
|
2209 {
|
|
|
2210 fprintf(stderr, "Error: cannot read DC %s from scaling list file %s at file position %ld\n", MatrixType_DC[sizeIdc][listIdc], pchFile, ftell(fp));
|
|
|
2211 return true;
|
|
|
2212 }
|
|
|
2213 if (data<0 || data>255)
|
|
|
2214 {
|
|
|
2215 fprintf(stderr, "Error: DC value %d for Matrix %s from scaling list file %s at file position %ld is out of range (0 to 255)\n", data, MatrixType[sizeIdc][listIdc], pchFile, ftell(fp));
|
|
|
2216 return true;
|
|
|
2217 }
|
|
|
2218 //overwrite DC value when size of matrix is larger than 16x16
|
|
|
2219 setScalingListDC(sizeIdc,listIdc,data);
|
|
|
2220 }
|
|
|
2221 }
|
|
|
2222 }
|
|
|
2223 }
|
|
|
2224 // std::cout << "\n\nRead scaling lists of:\n\n";
|
|
|
2225 // outputScalingLists(std::cout);
|
|
|
2226
|
|
|
2227 fclose(fp);
|
|
|
2228 return false;
|
|
|
2229 }
|
|
|
2230
|
|
|
2231 /** initialization process of quantization matrix array
|
|
|
2232 */
|
|
|
2233 Void TComScalingList::init()
|
|
|
2234 {
|
|
|
2235 for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
|
|
|
2236 {
|
|
|
2237 for(UInt listId = 0; listId < SCALING_LIST_NUM; listId++)
|
|
|
2238 {
|
|
|
2239 m_scalingListCoef[sizeId][listId] = new Int [min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])];
|
|
|
2240 }
|
|
|
2241 }
|
|
|
2242 }
|
|
|
2243
|
|
|
2244 /** destroy quantization matrix array
|
|
|
2245 */
|
|
|
2246 Void TComScalingList::destroy()
|
|
|
2247 {
|
|
|
2248 for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
|
|
|
2249 {
|
|
|
2250 for(UInt listId = 0; listId < SCALING_LIST_NUM; listId++)
|
|
|
2251 {
|
|
|
2252 if(m_scalingListCoef[sizeId][listId]) delete [] m_scalingListCoef[sizeId][listId];
|
|
|
2253 }
|
|
|
2254 }
|
|
|
2255 }
|
|
|
2256
|
|
|
2257 /** get default address of quantization matrix
|
|
|
2258 * \param sizeId size index
|
|
|
2259 * \param listId list index
|
|
|
2260 * \returns pointer of quantization matrix
|
|
|
2261 */
|
|
|
2262 Int* TComScalingList::getScalingListDefaultAddress(UInt sizeId, UInt listId)
|
|
|
2263 {
|
|
|
2264 Int *src = 0;
|
|
|
2265 switch(sizeId)
|
|
|
2266 {
|
|
|
2267 case SCALING_LIST_4x4:
|
|
|
2268 src = g_quantTSDefault4x4;
|
|
|
2269 break;
|
|
|
2270 case SCALING_LIST_8x8:
|
|
|
2271 case SCALING_LIST_16x16:
|
|
|
2272 case SCALING_LIST_32x32:
|
|
|
2273 src = (listId < (SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES) ) ? g_quantIntraDefault8x8 : g_quantInterDefault8x8;
|
|
|
2274 break;
|
|
|
2275 default:
|
|
|
2276 assert(0);
|
|
|
2277 src = NULL;
|
|
|
2278 break;
|
|
|
2279 }
|
|
|
2280 return src;
|
|
|
2281 }
|
|
|
2282
|
|
|
2283 /** process of default matrix
|
|
|
2284 * \param sizeId size index
|
|
|
2285 * \param Index of input matrix
|
|
|
2286 */
|
|
|
2287 Void TComScalingList::processDefaultMatrix(UInt sizeId, UInt listId)
|
|
|
2288 {
|
|
|
2289 ::memcpy(getScalingListAddress(sizeId, listId),getScalingListDefaultAddress(sizeId,listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
|
|
|
2290 setScalingListDC(sizeId,listId,SCALING_LIST_DC);
|
|
|
2291 }
|
|
|
2292
|
|
|
2293 /** check DC value of matrix for default matrix signaling
|
|
|
2294 */
|
|
|
2295 Void TComScalingList::checkDcOfMatrix()
|
|
|
2296 {
|
|
|
2297 for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
|
|
|
2298 {
|
|
|
2299 for(UInt listId = 0; listId < SCALING_LIST_NUM; listId++)
|
|
|
2300 {
|
|
|
2301 //check default matrix?
|
|
|
2302 if(getScalingListDC(sizeId,listId) == 0)
|
|
|
2303 {
|
|
|
2304 processDefaultMatrix(sizeId, listId);
|
|
|
2305 }
|
|
|
2306 }
|
|
|
2307 }
|
|
|
2308 }
|
|
|
2309
|
|
|
2310 ParameterSetManager::ParameterSetManager()
|
|
|
2311 : m_vpsMap(MAX_NUM_VPS)
|
|
|
2312 , m_spsMap(MAX_NUM_SPS)
|
|
|
2313 , m_ppsMap(MAX_NUM_PPS)
|
|
|
2314 , m_activeVPSId(-1)
|
|
|
2315 , m_activeSPSId(-1)
|
|
|
2316 , m_activePPSId(-1)
|
|
|
2317 {
|
|
|
2318 }
|
|
|
2319
|
|
|
2320
|
|
|
2321 ParameterSetManager::~ParameterSetManager()
|
|
|
2322 {
|
|
|
2323 }
|
|
|
2324
|
|
|
2325 //! activate a SPS from a active parameter sets SEI message
|
|
|
2326 //! \returns true, if activation is successful
|
|
|
2327 Bool ParameterSetManager::activateSPSWithSEI(Int spsId)
|
|
|
2328 {
|
|
|
2329 TComSPS *sps = m_spsMap.getPS(spsId);
|
|
|
2330 if (sps)
|
|
|
2331 {
|
|
|
2332 Int vpsId = sps->getVPSId();
|
|
|
2333 if (m_vpsMap.getPS(vpsId))
|
|
|
2334 {
|
|
|
2335 m_activeVPSId = vpsId;
|
|
|
2336 m_activeSPSId = spsId;
|
|
|
2337 return true;
|
|
|
2338 }
|
|
|
2339 else
|
|
|
2340 {
|
|
|
2341 printf("Warning: tried to activate SPS using an Active parameter sets SEI message. Referenced VPS does not exist.");
|
|
|
2342 }
|
|
|
2343 }
|
|
|
2344 else
|
|
|
2345 {
|
|
|
2346 printf("Warning: tried to activate non-existing SPS using an Active parameter sets SEI message.");
|
|
|
2347 }
|
|
|
2348 return false;
|
|
|
2349 }
|
|
|
2350
|
|
|
2351 //! activate a PPS and depending on isIDR parameter also SPS and VPS
|
|
|
2352 //! \returns true, if activation is successful
|
|
|
2353 Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP)
|
|
|
2354 {
|
|
|
2355 TComPPS *pps = m_ppsMap.getPS(ppsId);
|
|
|
2356 if (pps)
|
|
|
2357 {
|
|
|
2358 Int spsId = pps->getSPSId();
|
|
|
2359 if (!isIRAP && (spsId != m_activeSPSId))
|
|
|
2360 {
|
|
|
2361 printf("Warning: tried to activate PPS referring to a inactive SPS at non-IDR.");
|
|
|
2362 return false;
|
|
|
2363 }
|
|
|
2364 TComSPS *sps = m_spsMap.getPS(spsId);
|
|
|
2365 if (sps)
|
|
|
2366 {
|
|
|
2367 Int vpsId = sps->getVPSId();
|
|
|
2368 if (!isIRAP && (vpsId != m_activeVPSId))
|
|
|
2369 {
|
|
|
2370 printf("Warning: tried to activate PPS referring to a inactive VPS at non-IDR.");
|
|
|
2371 return false;
|
|
|
2372 }
|
|
|
2373 if (m_vpsMap.getPS(vpsId))
|
|
|
2374 {
|
|
|
2375 m_activePPSId = ppsId;
|
|
|
2376 m_activeVPSId = vpsId;
|
|
|
2377 m_activeSPSId = spsId;
|
|
|
2378 return true;
|
|
|
2379 }
|
|
|
2380 else
|
|
|
2381 {
|
|
|
2382 printf("Warning: tried to activate PPS that refers to a non-existing VPS.");
|
|
|
2383 }
|
|
|
2384 }
|
|
|
2385 else
|
|
|
2386 {
|
|
|
2387 printf("Warning: tried to activate a PPS that refers to a non-existing SPS.");
|
|
|
2388 }
|
|
|
2389 }
|
|
|
2390 else
|
|
|
2391 {
|
|
|
2392 printf("Warning: tried to activate non-existing PPS.");
|
|
|
2393 }
|
|
|
2394 return false;
|
|
|
2395 }
|
|
|
2396
|
|
|
2397 ProfileTierLevel::ProfileTierLevel()
|
|
|
2398 : m_profileSpace (0)
|
|
|
2399 , m_tierFlag (Level::MAIN)
|
|
|
2400 , m_profileIdc (Profile::NONE)
|
|
|
2401 , m_levelIdc (Level::NONE)
|
|
|
2402 , m_progressiveSourceFlag (false)
|
|
|
2403 , m_interlacedSourceFlag (false)
|
|
|
2404 , m_nonPackedConstraintFlag(false)
|
|
|
2405 , m_frameOnlyConstraintFlag(false)
|
|
|
2406 {
|
|
|
2407 ::memset(m_profileCompatibilityFlag, 0, sizeof(m_profileCompatibilityFlag));
|
|
|
2408 }
|
|
|
2409
|
|
|
2410 TComPTL::TComPTL()
|
|
|
2411 {
|
|
|
2412 ::memset(m_subLayerProfilePresentFlag, 0, sizeof(m_subLayerProfilePresentFlag));
|
|
|
2413 ::memset(m_subLayerLevelPresentFlag, 0, sizeof(m_subLayerLevelPresentFlag ));
|
|
|
2414 }
|
|
|
2415
|
|
|
2416
|
|
|
2417 //! \}
|
