source: 3DVCSoftware/trunk/source/Lib/TLibDecoder/TDecTop.cpp @ 608

Last change on this file since 608 was 608, checked in by tech, 11 years ago

Merged DEV-2.0-dev0@604.

  • Property svn:eol-style set to native
File size: 41.8 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license. 
5 *
6 * Copyright (c) 2010-2013, ITU/ISO/IEC
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 *  * Redistributions of source code must retain the above copyright notice,
13 *    this list of conditions and the following disclaimer.
14 *  * Redistributions in binary form must reproduce the above copyright notice,
15 *    this list of conditions and the following disclaimer in the documentation
16 *    and/or other materials provided with the distribution.
17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18 *    be used to endorse or promote products derived from this software without
19 *    specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31 * THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34/** \file     TDecTop.cpp
35    \brief    decoder class
36*/
37
38#include "NALread.h"
39#include "TDecTop.h"
40
41#if H_MV
42ParameterSetManagerDecoder TDecTop::m_parameterSetManagerDecoder;
43#endif
44//! \ingroup TLibDecoder
45//! \{
46
47#if H_3D
48CamParsCollector::CamParsCollector()
49: m_bInitialized( false )
50{
51  m_aaiCodedOffset         = new Int* [ MAX_NUM_LAYERS ];
52  m_aaiCodedScale          = new Int* [ MAX_NUM_LAYERS ];
53  m_aiViewId               = new Int  [ MAX_NUM_LAYERS ];
54
55  m_bViewReceived          = new Bool [ MAX_NUM_LAYERS ];
56  for( UInt uiId = 0; uiId < MAX_NUM_LAYERS; uiId++ )
57  {
58    m_aaiCodedOffset      [ uiId ] = new Int [ MAX_NUM_LAYERS ];
59    m_aaiCodedScale       [ uiId ] = new Int [ MAX_NUM_LAYERS ];
60  }
61
62  xCreateLUTs( (UInt)MAX_NUM_LAYERS, (UInt)MAX_NUM_LAYERS, m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
63  m_iLog2Precision   = LOG2_DISP_PREC_LUT;
64  m_uiBitDepthForLUT = 8; // fixed
65}
66
67CamParsCollector::~CamParsCollector()
68{
69  for( UInt uiId = 0; uiId < MAX_NUM_LAYERS; uiId++ )
70  {
71    delete [] m_aaiCodedOffset      [ uiId ];
72    delete [] m_aaiCodedScale       [ uiId ];
73  }
74  delete [] m_aaiCodedOffset;
75  delete [] m_aaiCodedScale;
76  delete [] m_aiViewId; 
77  delete [] m_bViewReceived;
78
79  xDeleteArray( m_adBaseViewShiftLUT, MAX_NUM_LAYERS, MAX_NUM_LAYERS, 2 );
80  xDeleteArray( m_aiBaseViewShiftLUT, MAX_NUM_LAYERS, MAX_NUM_LAYERS, 2 );
81}
82
83Void
84CamParsCollector::init( FILE* pCodedScaleOffsetFile )
85{
86  m_bInitialized            = true;
87  m_pCodedScaleOffsetFile   = pCodedScaleOffsetFile;
88  m_uiCamParsCodedPrecision = 0;
89  m_bCamParsVaryOverTime    = false;
90  m_iLastViewIndex             = -1;
91  m_iLastPOC                = -1;
92  m_uiMaxViewIndex             = 0;
93}
94
95Void
96CamParsCollector::xCreateLUTs( UInt uiNumberSourceViews, UInt uiNumberTargetViews, Double****& radLUT, Int****& raiLUT)
97{
98
99  uiNumberSourceViews = std::max( (UInt) 1, uiNumberSourceViews );
100  uiNumberTargetViews = std::max( (UInt) 1, uiNumberTargetViews );
101
102  radLUT         = new Double***[ uiNumberSourceViews ];
103  raiLUT         = new Int   ***[ uiNumberSourceViews ];
104
105  for( UInt uiSourceView = 0; uiSourceView < uiNumberSourceViews; uiSourceView++ )
106  {
107    radLUT        [ uiSourceView ] = new Double**[ uiNumberTargetViews ];
108    raiLUT        [ uiSourceView ] = new Int   **[ uiNumberTargetViews ];
109
110    for( UInt uiTargetView = 0; uiTargetView < uiNumberTargetViews; uiTargetView++ )
111    {
112      radLUT        [ uiSourceView ][ uiTargetView ]      = new Double*[ 2 ];
113      radLUT        [ uiSourceView ][ uiTargetView ][ 0 ] = new Double [ 257 ];
114      radLUT        [ uiSourceView ][ uiTargetView ][ 1 ] = new Double [ 257 ];
115
116      raiLUT        [ uiSourceView ][ uiTargetView ]      = new Int*   [ 2 ];
117      raiLUT        [ uiSourceView ][ uiTargetView ][ 0 ] = new Int    [ 257 ];
118      raiLUT        [ uiSourceView ][ uiTargetView ][ 1 ] = new Int    [ 257 ];
119    }
120  }
121}
122
123Void
124  CamParsCollector::xInitLUTs( UInt uiSourceView, UInt uiTargetView, Int iScale, Int iOffset, Double****& radLUT, Int****& raiLUT)
125{
126  Int     iLog2DivLuma   = m_uiBitDepthForLUT + m_uiCamParsCodedPrecision + 1 - m_iLog2Precision;   AOF( iLog2DivLuma > 0 );
127  Int     iLog2DivChroma = iLog2DivLuma + 1;
128
129  iOffset <<= m_uiBitDepthForLUT;
130
131  Double dScale  = (Double) iScale  / (( Double ) ( 1 << iLog2DivLuma ));
132  Double dOffset = (Double) iOffset / (( Double ) ( 1 << iLog2DivLuma ));
133
134  // offsets including rounding offsets
135  Int64 iOffsetLuma   = iOffset + ( ( 1 << iLog2DivLuma   ) >> 1 );
136  Int64 iOffsetChroma = iOffset + ( ( 1 << iLog2DivChroma ) >> 1 );
137
138
139  for( UInt uiDepthValue = 0; uiDepthValue < 256; uiDepthValue++ )
140  {
141
142    // real-valued look-up tables
143    Double  dShiftLuma      = ( (Double)uiDepthValue * dScale + dOffset ) * Double( 1 << m_iLog2Precision );
144    Double  dShiftChroma    = dShiftLuma / 2;
145    radLUT[ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ] = dShiftLuma;
146    radLUT[ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ] = dShiftChroma;
147
148    // integer-valued look-up tables
149    Int64   iTempScale      = (Int64)uiDepthValue * iScale;
150    Int64   iShiftLuma      = ( iTempScale + iOffsetLuma   ) >> iLog2DivLuma;
151    Int64   iShiftChroma    = ( iTempScale + iOffsetChroma ) >> iLog2DivChroma;
152    raiLUT[ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ] = (Int)iShiftLuma;
153    raiLUT[ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ] = (Int)iShiftChroma;
154  }
155
156  radLUT[ uiSourceView ][ uiTargetView ][ 0 ][ 256 ] = radLUT[ uiSourceView ][ uiTargetView ][ 0 ][ 255 ];
157  radLUT[ uiSourceView ][ uiTargetView ][ 1 ][ 256 ] = radLUT[ uiSourceView ][ uiTargetView ][ 1 ][ 255 ];
158  raiLUT[ uiSourceView ][ uiTargetView ][ 0 ][ 256 ] = raiLUT[ uiSourceView ][ uiTargetView ][ 0 ][ 255 ];
159  raiLUT[ uiSourceView ][ uiTargetView ][ 1 ][ 256 ] = raiLUT[ uiSourceView ][ uiTargetView ][ 1 ][ 255 ];
160}
161
162Void
163CamParsCollector::uninit()
164{
165  m_bInitialized = false;
166}
167
168Void
169CamParsCollector::setSlice( TComSlice* pcSlice )
170{
171
172  if( pcSlice == 0 )
173  {
174    AOF( xIsComplete() );
175    if( m_bCamParsVaryOverTime || m_iLastPOC == 0 )
176    {
177      xOutput( m_iLastPOC );
178    }
179    return;
180  }
181 
182  if ( pcSlice->getIsDepth())
183  {
184    return;
185  }
186
187  Bool  bFirstAU          = ( pcSlice->getPOC()     == 0 );
188  Bool  bFirstSliceInAU   = ( pcSlice->getPOC()     != Int ( m_iLastPOC ) );
189  Bool  bFirstSliceInView = ( pcSlice->getViewIndex()  != UInt( m_iLastViewIndex ) || bFirstSliceInAU );
190
191  AOT(  bFirstSliceInAU  &&   pcSlice->getViewIndex()  != 0 );
192  AOT( !bFirstSliceInAU  &&   pcSlice->getViewIndex()   < UInt( m_iLastViewIndex ) );
193 
194  AOT( !bFirstSliceInAU  &&   pcSlice->getViewIndex()   > UInt( m_iLastViewIndex + 1 ) );
195 
196  AOT( !bFirstAU         &&   pcSlice->getViewIndex()   > m_uiMaxViewIndex );
197
198  if ( !bFirstSliceInView )
199  {
200    if( m_bCamParsVaryOverTime ) // check consistency of slice parameters here
201    {
202      UInt uiViewIndex = pcSlice->getViewIndex();
203      for( UInt uiBaseViewIndex = 0; uiBaseViewIndex < uiViewIndex; uiBaseViewIndex++ )
204      {
205        AOF( m_aaiCodedScale [ uiBaseViewIndex ][ uiViewIndex ] == pcSlice->getCodedScale    () [ uiBaseViewIndex ] );
206        AOF( m_aaiCodedOffset[ uiBaseViewIndex ][ uiViewIndex ] == pcSlice->getCodedOffset   () [ uiBaseViewIndex ] );
207        AOF( m_aaiCodedScale [ uiViewIndex ][ uiBaseViewIndex ] == pcSlice->getInvCodedScale () [ uiBaseViewIndex ] );
208        AOF( m_aaiCodedOffset[ uiViewIndex ][ uiBaseViewIndex ] == pcSlice->getInvCodedOffset() [ uiBaseViewIndex ] );
209      }
210    }
211    return;
212  }
213
214  if( bFirstSliceInAU )
215  {
216    if( !bFirstAU )
217    {
218      AOF( xIsComplete() );
219      xOutput( m_iLastPOC );
220    }
221    ::memset( m_bViewReceived, false, MAX_NUM_LAYERS * sizeof( Bool ) );
222  }
223
224  UInt uiViewIndex                       = pcSlice->getViewIndex();
225  m_bViewReceived[ uiViewIndex ]         = true;
226  if( bFirstAU )
227  {
228    m_uiMaxViewIndex                     = std::max( m_uiMaxViewIndex, uiViewIndex );
229    m_aiViewId[ uiViewIndex ]            = pcSlice->getViewId();
230    if( uiViewIndex == 1 )
231    {
232      m_uiCamParsCodedPrecision       = pcSlice->getSPS()->getCamParPrecision     ();
233      m_bCamParsVaryOverTime          = pcSlice->getSPS()->hasCamParInSliceHeader ();
234    }
235    else if( uiViewIndex > 1 )
236    {
237      AOF( m_uiCamParsCodedPrecision == pcSlice->getSPS()->getCamParPrecision     () );
238      AOF( m_bCamParsVaryOverTime    == pcSlice->getSPS()->hasCamParInSliceHeader () );
239    }
240    for( UInt uiBaseIndex = 0; uiBaseIndex < uiViewIndex; uiBaseIndex++ )
241    {
242      if( m_bCamParsVaryOverTime )
243      {
244        m_aaiCodedScale [ uiBaseIndex ][ uiViewIndex ]  = pcSlice->getCodedScale    () [ uiBaseIndex ];
245        m_aaiCodedOffset[ uiBaseIndex ][ uiViewIndex ]  = pcSlice->getCodedOffset   () [ uiBaseIndex ];
246        m_aaiCodedScale [ uiViewIndex ][ uiBaseIndex ]  = pcSlice->getInvCodedScale () [ uiBaseIndex ];
247        m_aaiCodedOffset[ uiViewIndex ][ uiBaseIndex ]  = pcSlice->getInvCodedOffset() [ uiBaseIndex ];
248        xInitLUTs( uiBaseIndex, uiViewIndex, m_aaiCodedScale[ uiBaseIndex ][ uiViewIndex ], m_aaiCodedOffset[ uiBaseIndex ][ uiViewIndex ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT);
249        xInitLUTs( uiViewIndex, uiBaseIndex, m_aaiCodedScale[ uiViewIndex ][ uiBaseIndex ], m_aaiCodedOffset[ uiViewIndex ][ uiBaseIndex ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT);
250      }
251      else
252      {
253        m_aaiCodedScale [ uiBaseIndex ][ uiViewIndex ]  = pcSlice->getSPS()->getCodedScale    () [ uiBaseIndex ];
254        m_aaiCodedOffset[ uiBaseIndex ][ uiViewIndex ]  = pcSlice->getSPS()->getCodedOffset   () [ uiBaseIndex ];
255        m_aaiCodedScale [ uiViewIndex ][ uiBaseIndex ]  = pcSlice->getSPS()->getInvCodedScale () [ uiBaseIndex ];
256        m_aaiCodedOffset[ uiViewIndex ][ uiBaseIndex ]  = pcSlice->getSPS()->getInvCodedOffset() [ uiBaseIndex ];
257        xInitLUTs( uiBaseIndex, uiViewIndex, m_aaiCodedScale[ uiBaseIndex ][ uiViewIndex ], m_aaiCodedOffset[ uiBaseIndex ][ uiViewIndex ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
258        xInitLUTs( uiViewIndex, uiBaseIndex, m_aaiCodedScale[ uiViewIndex ][ uiBaseIndex ], m_aaiCodedOffset[ uiViewIndex ][ uiBaseIndex ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
259      }
260    }
261  }
262  else
263  {
264    AOF( m_aiViewId[ uiViewIndex ] == pcSlice->getViewId() );
265    if( m_bCamParsVaryOverTime )
266    {
267      for( UInt uiBaseIndex = 0; uiBaseIndex < uiViewIndex; uiBaseIndex++ )
268      {
269        m_aaiCodedScale [ uiBaseIndex ][ uiViewIndex ]  = pcSlice->getCodedScale    () [ uiBaseIndex ];
270        m_aaiCodedOffset[ uiBaseIndex ][ uiViewIndex ]  = pcSlice->getCodedOffset   () [ uiBaseIndex ];
271        m_aaiCodedScale [ uiViewIndex ][ uiBaseIndex ]  = pcSlice->getInvCodedScale () [ uiBaseIndex ];
272        m_aaiCodedOffset[ uiViewIndex ][ uiBaseIndex ]  = pcSlice->getInvCodedOffset() [ uiBaseIndex ];
273
274        xInitLUTs( uiBaseIndex, uiViewIndex, m_aaiCodedScale[ uiBaseIndex ][ uiViewIndex ], m_aaiCodedOffset[ uiBaseIndex ][ uiViewIndex ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
275        xInitLUTs( uiViewIndex, uiBaseIndex, m_aaiCodedScale[ uiViewIndex ][ uiBaseIndex ], m_aaiCodedOffset[ uiViewIndex ][ uiBaseIndex ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
276      }
277    }
278  }
279 
280  m_iLastViewIndex = (Int)pcSlice->getViewIndex(); 
281  m_iLastPOC       = (Int)pcSlice->getPOC();
282}
283
284Bool
285CamParsCollector::xIsComplete()
286{
287  for( UInt uiView = 0; uiView <= m_uiMaxViewIndex; uiView++ )
288  {
289    if( m_bViewReceived[ uiView ] == 0 )
290    {
291      return false;
292    }
293  }
294  return true;
295}
296
297Void
298CamParsCollector::xOutput( Int iPOC )
299{
300  if( m_pCodedScaleOffsetFile )
301  {
302    if( iPOC == 0 )
303    {
304      fprintf( m_pCodedScaleOffsetFile, "#  ViewIndex       ViewId\n" );
305      fprintf( m_pCodedScaleOffsetFile, "#----------- ------------\n" );
306      for( UInt uiViewIndex = 0; uiViewIndex <= m_uiMaxViewIndex; uiViewIndex++ )
307      {
308        fprintf( m_pCodedScaleOffsetFile, "%12d %12d\n", uiViewIndex, m_aiViewId[ uiViewIndex ] );
309      }
310      fprintf( m_pCodedScaleOffsetFile, "\n\n");
311      fprintf( m_pCodedScaleOffsetFile, "# StartFrame     EndFrame   TargetView     BaseView   CodedScale  CodedOffset    Precision\n" );
312      fprintf( m_pCodedScaleOffsetFile, "#----------- ------------ ------------ ------------ ------------ ------------ ------------\n" );
313    }
314    if( iPOC == 0 || m_bCamParsVaryOverTime )
315    {
316      Int iS = iPOC;
317      Int iE = ( m_bCamParsVaryOverTime ? iPOC : ~( 1 << 31 ) );
318      for( UInt uiViewIndex = 0; uiViewIndex <= m_uiMaxViewIndex; uiViewIndex++ )
319      {
320        for( UInt uiBaseIndex = 0; uiBaseIndex <= m_uiMaxViewIndex; uiBaseIndex++ )
321        {
322          if( uiViewIndex != uiBaseIndex )
323          {
324            fprintf( m_pCodedScaleOffsetFile, "%12d %12d %12d %12d %12d %12d %12d\n",
325              iS, iE, uiViewIndex, uiBaseIndex, m_aaiCodedScale[ uiBaseIndex ][ uiViewIndex ], m_aaiCodedOffset[ uiBaseIndex ][ uiViewIndex ], m_uiCamParsCodedPrecision );
326          }
327        }
328      }
329    }
330  }
331}
332#endif
333TDecTop::TDecTop()
334{
335  m_pcPic = 0;
336  m_iMaxRefPicNum = 0;
337#if ENC_DEC_TRACE
338#if H_MV
339  if ( g_hTrace == NULL )
340  {
341#endif
342  g_hTrace = fopen( "TraceDec.txt", "wb" );
343  g_bJustDoIt = g_bEncDecTraceDisable;
344  g_nSymbolCounter = 0;
345#if H_MV
346  }
347#endif
348#endif
349  m_pocCRA = 0;
350  m_prevRAPisBLA = false;
351  m_pocRandomAccess = MAX_INT; 
352  m_prevPOC                = MAX_INT;
353  m_bFirstSliceInPicture    = true;
354  m_bFirstSliceInSequence   = true;
355#if H_MV
356  m_layerId = 0;
357  m_viewId = 0;
358#if H_3D
359  m_viewIndex = 0; 
360  m_isDepth = false;
361  m_pcCamParsCollector = 0;
362#endif
363#endif
364}
365
366TDecTop::~TDecTop()
367{
368#if ENC_DEC_TRACE
369  fclose( g_hTrace );
370#endif
371}
372
373Void TDecTop::create()
374{
375  m_cGopDecoder.create();
376  m_apcSlicePilot = new TComSlice;
377  m_uiSliceIdx = 0;
378}
379
380Void TDecTop::destroy()
381{
382  m_cGopDecoder.destroy();
383 
384  delete m_apcSlicePilot;
385  m_apcSlicePilot = NULL;
386 
387  m_cSliceDecoder.destroy();
388}
389
390Void TDecTop::init()
391{
392  // initialize ROM
393#if !H_MV
394  initROM();
395#endif
396  m_cGopDecoder.init( &m_cEntropyDecoder, &m_cSbacDecoder, &m_cBinCABAC, &m_cCavlcDecoder, &m_cSliceDecoder, &m_cLoopFilter, &m_cSAO );
397  m_cSliceDecoder.init( &m_cEntropyDecoder, &m_cCuDecoder );
398  m_cEntropyDecoder.init(&m_cPrediction);
399}
400
401Void TDecTop::deletePicBuffer ( )
402{
403  TComList<TComPic*>::iterator  iterPic   = m_cListPic.begin();
404  Int iSize = Int( m_cListPic.size() );
405 
406  for (Int i = 0; i < iSize; i++ )
407  {
408    TComPic* pcPic = *(iterPic++);
409#if H_MV
410    if( pcPic )
411    {
412#endif
413    pcPic->destroy();
414   
415    delete pcPic;
416    pcPic = NULL;
417#if H_MV
418    }
419#endif
420  }
421 
422  m_cSAO.destroy();
423 
424  m_cLoopFilter.        destroy();
425 
426#if !H_MV
427  // destroy ROM
428  destroyROM();
429#endif
430}
431
432Void TDecTop::xGetNewPicBuffer ( TComSlice* pcSlice, TComPic*& rpcPic )
433{
434  Int  numReorderPics[MAX_TLAYER];
435  Window &conformanceWindow = pcSlice->getSPS()->getConformanceWindow();
436  Window defaultDisplayWindow = pcSlice->getSPS()->getVuiParametersPresentFlag() ? pcSlice->getSPS()->getVuiParameters()->getDefaultDisplayWindow() : Window();
437
438  for( Int temporalLayer=0; temporalLayer < MAX_TLAYER; temporalLayer++) 
439  {
440    numReorderPics[temporalLayer] = pcSlice->getSPS()->getNumReorderPics(temporalLayer);
441  }
442
443  m_iMaxRefPicNum = pcSlice->getSPS()->getMaxDecPicBuffering(pcSlice->getTLayer());     // m_uiMaxDecPicBuffering has the space for the picture currently being decoded
444  if (m_cListPic.size() < (UInt)m_iMaxRefPicNum)
445  {
446    rpcPic = new TComPic();
447   
448    rpcPic->create ( pcSlice->getSPS()->getPicWidthInLumaSamples(), pcSlice->getSPS()->getPicHeightInLumaSamples(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, 
449                     conformanceWindow, defaultDisplayWindow, numReorderPics, true);
450    rpcPic->getPicSym()->allocSaoParam(&m_cSAO);
451    m_cListPic.pushBack( rpcPic );
452   
453    return;
454  }
455 
456  Bool bBufferIsAvailable = false;
457  TComList<TComPic*>::iterator  iterPic   = m_cListPic.begin();
458  while (iterPic != m_cListPic.end())
459  {
460    rpcPic = *(iterPic++);
461    if ( rpcPic->getReconMark() == false && rpcPic->getOutputMark() == false)
462    {
463      rpcPic->setOutputMark(false);
464      bBufferIsAvailable = true;
465      break;
466    }
467
468    if ( rpcPic->getSlice( 0 )->isReferenced() == false  && rpcPic->getOutputMark() == false)
469    {
470      rpcPic->setOutputMark(false);
471      rpcPic->setReconMark( false );
472      rpcPic->getPicYuvRec()->setBorderExtension( false );
473      bBufferIsAvailable = true;
474      break;
475    }
476  }
477 
478  if ( !bBufferIsAvailable )
479  {
480    //There is no room for this picture, either because of faulty encoder or dropped NAL. Extend the buffer.
481    m_iMaxRefPicNum++;
482    rpcPic = new TComPic();
483    m_cListPic.pushBack( rpcPic );
484  }
485  rpcPic->destroy();
486  rpcPic->create ( pcSlice->getSPS()->getPicWidthInLumaSamples(), pcSlice->getSPS()->getPicHeightInLumaSamples(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth,
487                   conformanceWindow, defaultDisplayWindow, numReorderPics, true);
488  rpcPic->getPicSym()->allocSaoParam(&m_cSAO);
489}
490
491#if H_MV
492Void TDecTop::endPicDecoding(Int& poc, TComList<TComPic*>*& rpcListPic, std::vector<Int>& targetDecLayerIdSet )
493#else
494Void TDecTop::executeLoopFilters(Int& poc, TComList<TComPic*>*& rpcListPic)
495#endif
496{
497  if (!m_pcPic)
498  {
499    /* nothing to deblock */
500    return;
501  }
502 
503  TComPic*&   pcPic         = m_pcPic;
504
505  // Execute Deblock + Cleanup
506
507  m_cGopDecoder.filterPicture(pcPic);
508
509  TComSlice::sortPicList( m_cListPic ); // sorting for application output
510  poc                 = pcPic->getSlice(m_uiSliceIdx-1)->getPOC();
511  rpcListPic          = &m_cListPic; 
512  m_cCuDecoder.destroy();       
513#if H_MV
514  TComSlice::markIvRefPicsAsShortTerm( m_refPicSetInterLayer ); 
515  TComSlice::markCurrPic( pcPic ); 
516  TComSlice::markIvRefPicsAsUnused   ( m_ivPicLists, targetDecLayerIdSet, m_parameterSetManagerDecoder.getActiveVPS(), m_layerId, poc ); 
517#endif
518  m_bFirstSliceInPicture  = true;
519
520  return;
521}
522
523Void TDecTop::xCreateLostPicture(Int iLostPoc) 
524{
525  printf("\ninserting lost poc : %d\n",iLostPoc);
526  TComSlice cFillSlice;
527  cFillSlice.setSPS( m_parameterSetManagerDecoder.getFirstSPS() );
528  cFillSlice.setPPS( m_parameterSetManagerDecoder.getFirstPPS() );
529  cFillSlice.initSlice();
530  TComPic *cFillPic;
531  xGetNewPicBuffer(&cFillSlice,cFillPic);
532  cFillPic->getSlice(0)->setSPS( m_parameterSetManagerDecoder.getFirstSPS() );
533  cFillPic->getSlice(0)->setPPS( m_parameterSetManagerDecoder.getFirstPPS() );
534  cFillPic->getSlice(0)->initSlice();
535 
536  TComList<TComPic*>::iterator iterPic = m_cListPic.begin();
537  Int closestPoc = 1000000;
538  while ( iterPic != m_cListPic.end())
539  {
540    TComPic * rpcPic = *(iterPic++);
541    if(abs(rpcPic->getPicSym()->getSlice(0)->getPOC() -iLostPoc)<closestPoc&&abs(rpcPic->getPicSym()->getSlice(0)->getPOC() -iLostPoc)!=0&&rpcPic->getPicSym()->getSlice(0)->getPOC()!=m_apcSlicePilot->getPOC())
542    {
543      closestPoc=abs(rpcPic->getPicSym()->getSlice(0)->getPOC() -iLostPoc);
544    }
545  }
546  iterPic = m_cListPic.begin();
547  while ( iterPic != m_cListPic.end())
548  {
549    TComPic *rpcPic = *(iterPic++);
550    if(abs(rpcPic->getPicSym()->getSlice(0)->getPOC() -iLostPoc)==closestPoc&&rpcPic->getPicSym()->getSlice(0)->getPOC()!=m_apcSlicePilot->getPOC())
551    {
552      printf("copying picture %d to %d (%d)\n",rpcPic->getPicSym()->getSlice(0)->getPOC() ,iLostPoc,m_apcSlicePilot->getPOC());
553      rpcPic->getPicYuvRec()->copyToPic(cFillPic->getPicYuvRec());
554      break;
555    }
556  }
557  cFillPic->setCurrSliceIdx(0);
558  for(Int i=0; i<cFillPic->getNumCUsInFrame(); i++) 
559  {
560    cFillPic->getCU(i)->initCU(cFillPic,i);
561  }
562  cFillPic->getSlice(0)->setReferenced(true);
563  cFillPic->getSlice(0)->setPOC(iLostPoc);
564  cFillPic->setReconMark(true);
565  cFillPic->setOutputMark(true);
566  if(m_pocRandomAccess == MAX_INT)
567  {
568    m_pocRandomAccess = iLostPoc;
569  }
570}
571
572
573Void TDecTop::xActivateParameterSets()
574{
575  m_parameterSetManagerDecoder.applyPrefetchedPS();
576 
577  TComPPS *pps = m_parameterSetManagerDecoder.getPPS(m_apcSlicePilot->getPPSId());
578  assert (pps != 0);
579
580  TComSPS *sps = m_parameterSetManagerDecoder.getSPS(pps->getSPSId());
581  assert (sps != 0);
582
583  if (false == m_parameterSetManagerDecoder.activatePPS(m_apcSlicePilot->getPPSId(),m_apcSlicePilot->isIRAP()))
584  {
585    printf ("Parameter set activation failed!");
586    assert (0);
587  }
588
589  if( pps->getDependentSliceSegmentsEnabledFlag() )
590  {
591    Int NumCtx = pps->getEntropyCodingSyncEnabledFlag()?2:1;
592
593    if (m_cSliceDecoder.getCtxMemSize() != NumCtx)
594    {
595      m_cSliceDecoder.initCtxMem(NumCtx);
596      for ( UInt st = 0; st < NumCtx; st++ )
597      {
598        TDecSbac* ctx = NULL;
599        ctx = new TDecSbac;
600        ctx->init( &m_cBinCABAC );
601        m_cSliceDecoder.setCtxMem( ctx, st );
602      }
603    }
604  }
605
606  m_apcSlicePilot->setPPS(pps);
607  m_apcSlicePilot->setSPS(sps);
608#if H_MV
609  m_apcSlicePilot->setVPS( m_parameterSetManagerDecoder.getActiveVPS() );
610#endif
611  pps->setSPS(sps);
612  pps->setNumSubstreams(pps->getEntropyCodingSyncEnabledFlag() ? ((sps->getPicHeightInLumaSamples() + sps->getMaxCUHeight() - 1) / sps->getMaxCUHeight()) * (pps->getNumColumnsMinus1() + 1) : 1);
613  pps->setMinCuDQPSize( sps->getMaxCUWidth() >> ( pps->getMaxCuDQPDepth()) );
614
615  g_bitDepthY     = sps->getBitDepthY();
616  g_bitDepthC     = sps->getBitDepthC();
617  g_uiMaxCUWidth  = sps->getMaxCUWidth();
618  g_uiMaxCUHeight = sps->getMaxCUHeight();
619  g_uiMaxCUDepth  = sps->getMaxCUDepth();
620  g_uiAddCUDepth  = max (0, sps->getLog2MinCodingBlockSize() - (Int)sps->getQuadtreeTULog2MinSize() );
621
622  for (Int i = 0; i < sps->getLog2DiffMaxMinCodingBlockSize(); i++)
623  {
624    sps->setAMPAcc( i, sps->getUseAMP() );
625  }
626
627  for (Int i = sps->getLog2DiffMaxMinCodingBlockSize(); i < sps->getMaxCUDepth(); i++)
628  {
629    sps->setAMPAcc( i, 0 );
630  }
631
632  m_cSAO.destroy();
633  m_cSAO.create( sps->getPicWidthInLumaSamples(), sps->getPicHeightInLumaSamples(), sps->getMaxCUWidth(), sps->getMaxCUHeight() );
634  m_cLoopFilter.create( sps->getMaxCUDepth() );
635}
636
637#if H_MV
638Bool TDecTop::xDecodeSlice(InputNALUnit &nalu, Int &iSkipFrame, Int iPOCLastDisplay, Bool newLayerFlag )
639{
640  assert( nalu.m_layerId == m_layerId ); 
641
642#else
643Bool TDecTop::xDecodeSlice(InputNALUnit &nalu, Int &iSkipFrame, Int iPOCLastDisplay )
644{
645#endif
646  TComPic*&   pcPic         = m_pcPic;
647  m_apcSlicePilot->initSlice();
648
649  if (m_bFirstSliceInPicture)
650  {
651    m_uiSliceIdx     = 0;
652  }
653  m_apcSlicePilot->setSliceIdx(m_uiSliceIdx);
654  if (!m_bFirstSliceInPicture)
655  {
656    m_apcSlicePilot->copySliceInfo( pcPic->getPicSym()->getSlice(m_uiSliceIdx-1) );
657  }
658
659  m_apcSlicePilot->setNalUnitType(nalu.m_nalUnitType);
660  Bool nonReferenceFlag = (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_TRAIL_N ||
661                           m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N   ||
662                           m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_STSA_N  ||
663                           m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N  ||
664                           m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N);
665  m_apcSlicePilot->setTemporalLayerNonReferenceFlag(nonReferenceFlag);
666 
667  m_apcSlicePilot->setReferenced(true); // Putting this as true ensures that picture is referenced the first time it is in an RPS
668  m_apcSlicePilot->setTLayerInfo(nalu.m_temporalId);
669
670#if H_MV
671  m_apcSlicePilot->setRefPicSetInterLayer( & m_refPicSetInterLayer ); 
672  m_apcSlicePilot->setLayerId( nalu.m_layerId );
673#endif
674  m_cEntropyDecoder.decodeSliceHeader (m_apcSlicePilot, &m_parameterSetManagerDecoder);
675
676#if H_MV 
677  TComVPS* vps     = m_apcSlicePilot->getVPS();
678  Int layerIdInVps = vps->getLayerIdInVps( nalu.m_layerId ); 
679  setViewId   ( vps->getViewId   ( layerIdInVps )      ); 
680#if H_3D
681  setViewIndex( vps->getViewIndex( layerIdInVps )      ); 
682  setIsDepth  ( vps->getDepthId  ( layerIdInVps ) == 1 ); 
683  m_ivPicLists->setVPS( vps ); 
684#endif
685#endif
686    // Skip pictures due to random access
687    if (isRandomAccessSkipPicture(iSkipFrame, iPOCLastDisplay))
688    {
689      return false;
690    }
691    // Skip TFD pictures associated with BLA/BLANT pictures
692    if (isSkipPictureForBLA(iPOCLastDisplay))
693    {
694      return false;
695    }
696
697  //we should only get a different poc for a new picture (with CTU address==0)
698  if (m_apcSlicePilot->isNextSlice() && m_apcSlicePilot->getPOC()!=m_prevPOC && !m_bFirstSliceInSequence && (!m_apcSlicePilot->getSliceCurStartCUAddr()==0))
699  {
700    printf ("Warning, the first slice of a picture might have been lost!\n");
701  }
702  // exit when a new picture is found
703  if (m_apcSlicePilot->isNextSlice() && (m_apcSlicePilot->getSliceCurStartCUAddr() == 0 && !m_bFirstSliceInPicture) && !m_bFirstSliceInSequence )
704  {
705    if (m_prevPOC >= m_pocRandomAccess)
706    {
707      m_prevPOC = m_apcSlicePilot->getPOC();
708      return true;
709    }
710    m_prevPOC = m_apcSlicePilot->getPOC();
711  }
712#if H_MV
713  if ( newLayerFlag )
714  {
715    return false; 
716  }
717#if ENC_DEC_TRACE
718#if H_MV_ENC_DEC_TRAC
719  // parse remainder of SH
720   g_disableHLSTrace = false; 
721#endif
722#endif
723#endif
724  // actual decoding starts here
725  xActivateParameterSets();
726
727  if (m_apcSlicePilot->isNextSlice()) 
728  {
729    m_prevPOC = m_apcSlicePilot->getPOC();
730  }
731  m_bFirstSliceInSequence = false;
732  //detect lost reference picture and insert copy of earlier frame.
733  Int lostPoc;
734  while((lostPoc=m_apcSlicePilot->checkThatAllRefPicsAreAvailable(m_cListPic, m_apcSlicePilot->getRPS(), true, m_pocRandomAccess)) > 0)
735  {
736    xCreateLostPicture(lostPoc-1);
737  }
738  if (m_bFirstSliceInPicture)
739  {
740    // Buffer initialize for prediction.
741    m_cPrediction.initTempBuff();
742    m_apcSlicePilot->applyReferencePictureSet(m_cListPic, m_apcSlicePilot->getRPS());
743#if H_MV
744    m_apcSlicePilot->createAndApplyIvReferencePictureSet( m_ivPicLists, m_refPicSetInterLayer ); 
745#endif
746    //  Get a new picture buffer
747    xGetNewPicBuffer (m_apcSlicePilot, pcPic);
748
749    // transfer any SEI messages that have been received to the picture
750    pcPic->setSEIs(m_SEIs);
751    m_SEIs.clear();
752
753    // Recursive structure
754    m_cCuDecoder.create ( g_uiMaxCUDepth, g_uiMaxCUWidth, g_uiMaxCUHeight );
755    m_cCuDecoder.init   ( &m_cEntropyDecoder, &m_cTrQuant, &m_cPrediction );
756    m_cTrQuant.init     ( g_uiMaxCUWidth, g_uiMaxCUHeight, m_apcSlicePilot->getSPS()->getMaxTrSize());
757
758    m_cSliceDecoder.create();
759  }
760  else
761  {
762    // Check if any new SEI has arrived
763    if(!m_SEIs.empty())
764    {
765      // Currently only decoding Unit SEI message occurring between VCL NALUs copied
766      SEIMessages &picSEI = pcPic->getSEIs();
767      SEIMessages decodingUnitInfos = extractSeisByType (m_SEIs, SEI::DECODING_UNIT_INFO);
768      picSEI.insert(picSEI.end(), decodingUnitInfos.begin(), decodingUnitInfos.end());
769      deleteSEIs(m_SEIs);
770    }
771  }
772 
773  //  Set picture slice pointer
774  TComSlice*  pcSlice = m_apcSlicePilot;
775  Bool bNextSlice     = pcSlice->isNextSlice();
776
777  UInt uiCummulativeTileWidth;
778  UInt uiCummulativeTileHeight;
779  UInt i, j, p;
780
781  //set NumColumnsMins1 and NumRowsMinus1
782  pcPic->getPicSym()->setNumColumnsMinus1( pcSlice->getPPS()->getNumColumnsMinus1() );
783  pcPic->getPicSym()->setNumRowsMinus1( pcSlice->getPPS()->getNumRowsMinus1() );
784
785  //create the TComTileArray
786  pcPic->getPicSym()->xCreateTComTileArray();
787
788  if( pcSlice->getPPS()->getUniformSpacingFlag() )
789  {
790    //set the width for each tile
791    for(j=0; j < pcPic->getPicSym()->getNumRowsMinus1()+1; j++)
792    {
793      for(p=0; p < pcPic->getPicSym()->getNumColumnsMinus1()+1; p++)
794      {
795        pcPic->getPicSym()->getTComTile( j * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + p )->
796          setTileWidth( (p+1)*pcPic->getPicSym()->getFrameWidthInCU()/(pcPic->getPicSym()->getNumColumnsMinus1()+1) 
797          - (p*pcPic->getPicSym()->getFrameWidthInCU())/(pcPic->getPicSym()->getNumColumnsMinus1()+1) );
798      }
799    }
800
801    //set the height for each tile
802    for(j=0; j < pcPic->getPicSym()->getNumColumnsMinus1()+1; j++)
803    {
804      for(p=0; p < pcPic->getPicSym()->getNumRowsMinus1()+1; p++)
805      {
806        pcPic->getPicSym()->getTComTile( p * (pcPic->getPicSym()->getNumColumnsMinus1()+1) + j )->
807          setTileHeight( (p+1)*pcPic->getPicSym()->getFrameHeightInCU()/(pcPic->getPicSym()->getNumRowsMinus1()+1) 
808          - (p*pcPic->getPicSym()->getFrameHeightInCU())/(pcPic->getPicSym()->getNumRowsMinus1()+1) );   
809      }
810    }
811  }
812  else
813  {
814    //set the width for each tile
815    for(j=0; j < pcSlice->getPPS()->getNumRowsMinus1()+1; j++)
816    {
817      uiCummulativeTileWidth = 0;
818      for(i=0; i < pcSlice->getPPS()->getNumColumnsMinus1(); i++)
819      {
820        pcPic->getPicSym()->getTComTile(j * (pcSlice->getPPS()->getNumColumnsMinus1()+1) + i)->setTileWidth( pcSlice->getPPS()->getColumnWidth(i) );
821        uiCummulativeTileWidth += pcSlice->getPPS()->getColumnWidth(i);
822      }
823      pcPic->getPicSym()->getTComTile(j * (pcSlice->getPPS()->getNumColumnsMinus1()+1) + i)->setTileWidth( pcPic->getPicSym()->getFrameWidthInCU()-uiCummulativeTileWidth );
824    }
825
826    //set the height for each tile
827    for(j=0; j < pcSlice->getPPS()->getNumColumnsMinus1()+1; j++)
828    {
829      uiCummulativeTileHeight = 0;
830      for(i=0; i < pcSlice->getPPS()->getNumRowsMinus1(); i++)
831      { 
832        pcPic->getPicSym()->getTComTile(i * (pcSlice->getPPS()->getNumColumnsMinus1()+1) + j)->setTileHeight( pcSlice->getPPS()->getRowHeight(i) );
833        uiCummulativeTileHeight += pcSlice->getPPS()->getRowHeight(i);
834      }
835      pcPic->getPicSym()->getTComTile(i * (pcSlice->getPPS()->getNumColumnsMinus1()+1) + j)->setTileHeight( pcPic->getPicSym()->getFrameHeightInCU()-uiCummulativeTileHeight );
836    }
837  }
838
839  pcPic->getPicSym()->xInitTiles();
840
841  //generate the Coding Order Map and Inverse Coding Order Map
842  UInt uiEncCUAddr;
843  for(i=0, uiEncCUAddr=0; i<pcPic->getPicSym()->getNumberOfCUsInFrame(); i++, uiEncCUAddr = pcPic->getPicSym()->xCalculateNxtCUAddr(uiEncCUAddr))
844  {
845    pcPic->getPicSym()->setCUOrderMap(i, uiEncCUAddr);
846    pcPic->getPicSym()->setInverseCUOrderMap(uiEncCUAddr, i);
847  }
848  pcPic->getPicSym()->setCUOrderMap(pcPic->getPicSym()->getNumberOfCUsInFrame(), pcPic->getPicSym()->getNumberOfCUsInFrame());
849  pcPic->getPicSym()->setInverseCUOrderMap(pcPic->getPicSym()->getNumberOfCUsInFrame(), pcPic->getPicSym()->getNumberOfCUsInFrame());
850
851  //convert the start and end CU addresses of the slice and dependent slice into encoding order
852  pcSlice->setSliceSegmentCurStartCUAddr( pcPic->getPicSym()->getPicSCUEncOrder(pcSlice->getSliceSegmentCurStartCUAddr()) );
853  pcSlice->setSliceSegmentCurEndCUAddr( pcPic->getPicSym()->getPicSCUEncOrder(pcSlice->getSliceSegmentCurEndCUAddr()) );
854  if(pcSlice->isNextSlice())
855  {
856    pcSlice->setSliceCurStartCUAddr(pcPic->getPicSym()->getPicSCUEncOrder(pcSlice->getSliceCurStartCUAddr()));
857    pcSlice->setSliceCurEndCUAddr(pcPic->getPicSym()->getPicSCUEncOrder(pcSlice->getSliceCurEndCUAddr()));
858  }
859
860  if (m_bFirstSliceInPicture) 
861  {
862    if(pcPic->getNumAllocatedSlice() != 1)
863    {
864      pcPic->clearSliceBuffer();
865    }
866  }
867  else
868  {
869    pcPic->allocateNewSlice();
870  }
871  assert(pcPic->getNumAllocatedSlice() == (m_uiSliceIdx + 1));
872  m_apcSlicePilot = pcPic->getPicSym()->getSlice(m_uiSliceIdx); 
873  pcPic->getPicSym()->setSlice(pcSlice, m_uiSliceIdx);
874
875  pcPic->setTLayer(nalu.m_temporalId);
876
877#if H_MV
878  pcPic->setLayerId( nalu.m_layerId );
879  pcPic->setViewId ( getViewId() );
880#if H_3D
881  pcPic->setViewIndex( getViewIndex() );
882  pcPic->setIsDepth  ( getIsDepth  () );
883#endif
884#endif
885  if (bNextSlice)
886  {
887    pcSlice->checkCRA(pcSlice->getRPS(), m_pocCRA, m_prevRAPisBLA, m_cListPic );
888    // Set reference list
889#if H_MV   
890    pcSlice->setRefPicList( m_cListPic, m_refPicSetInterLayer, true );   
891#if H_3D_ARP
892    pcSlice->setARPStepNum();
893    if( pcSlice->getARPStepNum() > 1 )
894    {
895      for(Int iLayerId = 0; iLayerId < nalu.m_layerId; iLayerId ++ )
896      {
897        Int  iViewIdx =   pcSlice->getVPS()->getViewIndex(iLayerId);
898        Bool bIsDepth = ( pcSlice->getVPS()->getDepthId  ( iLayerId ) == 1 );
899        if( iViewIdx<getViewIndex() && !bIsDepth )
900        {
901          pcSlice->setBaseViewRefPicList( m_ivPicLists->getPicList( iLayerId ), iViewIdx );
902        }
903      }
904    }
905#endif
906#else
907#if FIX1071
908    pcSlice->setRefPicList( m_cListPic, true );
909#else
910    pcSlice->setRefPicList( m_cListPic );
911#endif
912
913#endif
914
915#if H_3D
916    pcSlice->setIvPicLists( m_ivPicLists );         
917#if H_3D_IV_MERGE   
918    assert( !getIsDepth() || ( pcSlice->getTexturePic() != 0 ) );
919#endif   
920#endif
921    // For generalized B
922    // note: maybe not existed case (always L0 is copied to L1 if L1 is empty)
923    if (pcSlice->isInterB() && pcSlice->getNumRefIdx(REF_PIC_LIST_1) == 0)
924    {
925      Int iNumRefIdx = pcSlice->getNumRefIdx(REF_PIC_LIST_0);
926      pcSlice->setNumRefIdx        ( REF_PIC_LIST_1, iNumRefIdx );
927
928      for (Int iRefIdx = 0; iRefIdx < iNumRefIdx; iRefIdx++)
929      {
930        pcSlice->setRefPic(pcSlice->getRefPic(REF_PIC_LIST_0, iRefIdx), REF_PIC_LIST_1, iRefIdx);
931      }
932    }
933    if (!pcSlice->isIntra())
934    {
935      Bool bLowDelay = true;
936      Int  iCurrPOC  = pcSlice->getPOC();
937      Int iRefIdx = 0;
938
939      for (iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_0) && bLowDelay; iRefIdx++)
940      {
941        if ( pcSlice->getRefPic(REF_PIC_LIST_0, iRefIdx)->getPOC() > iCurrPOC )
942        {
943          bLowDelay = false;
944        }
945      }
946      if (pcSlice->isInterB())
947      {
948        for (iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(REF_PIC_LIST_1) && bLowDelay; iRefIdx++)
949        {
950          if ( pcSlice->getRefPic(REF_PIC_LIST_1, iRefIdx)->getPOC() > iCurrPOC )
951          {
952            bLowDelay = false;
953          }
954        }       
955      }
956
957      pcSlice->setCheckLDC(bLowDelay);           
958    }
959
960    //---------------
961    pcSlice->setRefPOCList();
962#if  H_3D_TMVP
963    if(pcSlice->getLayerId())
964      pcSlice->generateAlterRefforTMVP();
965#endif
966  }
967
968  pcPic->setCurrSliceIdx(m_uiSliceIdx);
969  if(pcSlice->getSPS()->getScalingListFlag())
970  {
971    pcSlice->setScalingList ( pcSlice->getSPS()->getScalingList()  );
972    if(pcSlice->getPPS()->getScalingListPresentFlag())
973    {
974      pcSlice->setScalingList ( pcSlice->getPPS()->getScalingList()  );
975    }
976    pcSlice->getScalingList()->setUseTransformSkip(pcSlice->getPPS()->getUseTransformSkip());
977    if(!pcSlice->getPPS()->getScalingListPresentFlag() && !pcSlice->getSPS()->getScalingListPresentFlag())
978    {
979      pcSlice->setDefaultScalingList();
980    }
981    m_cTrQuant.setScalingListDec(pcSlice->getScalingList());
982    m_cTrQuant.setUseScalingList(true);
983  }
984  else
985  {
986    m_cTrQuant.setFlatScalingList();
987    m_cTrQuant.setUseScalingList(false);
988  }
989
990  //  Decode a picture
991  m_cGopDecoder.decompressSlice(nalu.m_Bitstream, pcPic);
992#if H_3D
993  if( m_pcCamParsCollector )
994  {
995    m_pcCamParsCollector->setSlice( pcSlice );
996  }
997#endif
998  m_bFirstSliceInPicture = false;
999  m_uiSliceIdx++;
1000
1001  return false;
1002}
1003
1004Void TDecTop::xDecodeVPS()
1005{
1006  TComVPS* vps = new TComVPS();
1007 
1008  m_cEntropyDecoder.decodeVPS( vps );
1009  m_parameterSetManagerDecoder.storePrefetchedVPS(vps); 
1010}
1011
1012Void TDecTop::xDecodeSPS()
1013{
1014  TComSPS* sps = new TComSPS();
1015#if H_MV
1016  sps->setLayerId( getLayerId() ); 
1017#endif
1018#if H_3D
1019  // Preliminary fix. assuming that all sps refer to the same SPS.
1020  // Parsing dependency should be resolved!
1021  TComVPS* vps = m_parameterSetManagerDecoder.getPrefetchedVPS( 0 ); 
1022  assert( vps != 0 ); 
1023  Int layerIdInVPS = vps->getLayerIdInVps( m_layerId ); 
1024  m_cEntropyDecoder.decodeSPS( sps, vps->getViewIndex( layerIdInVPS ), ( vps->getDepthId( layerIdInVPS ) == 1 ) );
1025#else
1026  m_cEntropyDecoder.decodeSPS( sps );
1027#endif
1028  m_parameterSetManagerDecoder.storePrefetchedSPS(sps);
1029}
1030
1031Void TDecTop::xDecodePPS()
1032{
1033  TComPPS* pps = new TComPPS();
1034  m_cEntropyDecoder.decodePPS( pps );
1035  m_parameterSetManagerDecoder.storePrefetchedPPS( pps );
1036}
1037
1038Void TDecTop::xDecodeSEI( TComInputBitstream* bs, const NalUnitType nalUnitType )
1039{
1040  if(nalUnitType == NAL_UNIT_SUFFIX_SEI)
1041  {
1042    m_seiReader.parseSEImessage( bs, m_pcPic->getSEIs(), nalUnitType, m_parameterSetManagerDecoder.getActiveSPS() );
1043  }
1044  else
1045  {
1046    m_seiReader.parseSEImessage( bs, m_SEIs, nalUnitType, m_parameterSetManagerDecoder.getActiveSPS() );
1047    SEIMessages activeParamSets = getSeisByType(m_SEIs, SEI::ACTIVE_PARAMETER_SETS);
1048    if (activeParamSets.size()>0)
1049    {
1050      SEIActiveParameterSets *seiAps = (SEIActiveParameterSets*)(*activeParamSets.begin());
1051      m_parameterSetManagerDecoder.applyPrefetchedPS();
1052      assert(seiAps->activeSeqParamSetId.size()>0);
1053      if (! m_parameterSetManagerDecoder.activateSPSWithSEI(seiAps->activeSeqParamSetId[0] ))
1054      {
1055        printf ("Warning SPS activation with Active parameter set SEI failed");
1056      }
1057    }
1058  }
1059}
1060
1061#if H_MV
1062Bool TDecTop::decode(InputNALUnit& nalu, Int& iSkipFrame, Int& iPOCLastDisplay, Bool newLayerFlag)
1063#else
1064Bool TDecTop::decode(InputNALUnit& nalu, Int& iSkipFrame, Int& iPOCLastDisplay)
1065#endif
1066{
1067  // Initialize entropy decoder
1068  m_cEntropyDecoder.setEntropyDecoder (&m_cCavlcDecoder);
1069  m_cEntropyDecoder.setBitstream      (nalu.m_Bitstream);
1070
1071  switch (nalu.m_nalUnitType)
1072  {
1073    case NAL_UNIT_VPS:
1074      xDecodeVPS();
1075      return false;
1076     
1077    case NAL_UNIT_SPS:
1078      xDecodeSPS();
1079      return false;
1080
1081    case NAL_UNIT_PPS:
1082      xDecodePPS();
1083      return false;
1084     
1085    case NAL_UNIT_PREFIX_SEI:
1086    case NAL_UNIT_SUFFIX_SEI:
1087      xDecodeSEI( nalu.m_Bitstream, nalu.m_nalUnitType );
1088      return false;
1089
1090    case NAL_UNIT_CODED_SLICE_TRAIL_R:
1091    case NAL_UNIT_CODED_SLICE_TRAIL_N:
1092    case NAL_UNIT_CODED_SLICE_TLA_R:
1093    case NAL_UNIT_CODED_SLICE_TSA_N:
1094    case NAL_UNIT_CODED_SLICE_STSA_R:
1095    case NAL_UNIT_CODED_SLICE_STSA_N:
1096    case NAL_UNIT_CODED_SLICE_BLA_W_LP:
1097    case NAL_UNIT_CODED_SLICE_BLA_W_RADL:
1098    case NAL_UNIT_CODED_SLICE_BLA_N_LP:
1099    case NAL_UNIT_CODED_SLICE_IDR_W_RADL:
1100    case NAL_UNIT_CODED_SLICE_IDR_N_LP:
1101    case NAL_UNIT_CODED_SLICE_CRA:
1102    case NAL_UNIT_CODED_SLICE_RADL_N:
1103    case NAL_UNIT_CODED_SLICE_RADL_R:
1104    case NAL_UNIT_CODED_SLICE_RASL_N:
1105    case NAL_UNIT_CODED_SLICE_RASL_R:
1106#if H_MV
1107      return xDecodeSlice(nalu, iSkipFrame, iPOCLastDisplay, newLayerFlag);
1108#else
1109      return xDecodeSlice(nalu, iSkipFrame, iPOCLastDisplay);
1110#endif
1111      break;
1112    default:
1113      assert (1);
1114  }
1115
1116  return false;
1117}
1118
1119/** Function for checking if picture should be skipped because of association with a previous BLA picture
1120 * \param iPOCLastDisplay POC of last picture displayed
1121 * \returns true if the picture should be skipped
1122 * This function skips all TFD pictures that follow a BLA picture
1123 * in decoding order and precede it in output order.
1124 */
1125Bool TDecTop::isSkipPictureForBLA(Int& iPOCLastDisplay)
1126{
1127  if (m_prevRAPisBLA && m_apcSlicePilot->getPOC() < m_pocCRA && (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_R || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N))
1128  {
1129    iPOCLastDisplay++;
1130    return true;
1131  }
1132  return false;
1133}
1134
1135/** Function for checking if picture should be skipped because of random access
1136 * \param iSkipFrame skip frame counter
1137 * \param iPOCLastDisplay POC of last picture displayed
1138 * \returns true if the picture shold be skipped in the random access.
1139 * This function checks the skipping of pictures in the case of -s option random access.
1140 * All pictures prior to the random access point indicated by the counter iSkipFrame are skipped.
1141 * It also checks the type of Nal unit type at the random access point.
1142 * If the random access point is CRA/CRANT/BLA/BLANT, TFD pictures with POC less than the POC of the random access point are skipped.
1143 * If the random access point is IDR all pictures after the random access point are decoded.
1144 * If the random access point is none of the above, a warning is issues, and decoding of pictures with POC
1145 * equal to or greater than the random access point POC is attempted. For non IDR/CRA/BLA random
1146 * access point there is no guarantee that the decoder will not crash.
1147 */
1148Bool TDecTop::isRandomAccessSkipPicture(Int& iSkipFrame,  Int& iPOCLastDisplay)
1149{
1150  if (iSkipFrame) 
1151  {
1152    iSkipFrame--;   // decrement the counter
1153    return true;
1154  }
1155  else if (m_pocRandomAccess == MAX_INT) // start of random access point, m_pocRandomAccess has not been set yet.
1156  {
1157    if (   m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA
1158        || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
1159        || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
1160        || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL )
1161    {
1162      // set the POC random access since we need to skip the reordered pictures in the case of CRA/CRANT/BLA/BLANT.
1163      m_pocRandomAccess = m_apcSlicePilot->getPOC();
1164    }
1165    else if ( m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP )
1166    {
1167      m_pocRandomAccess = -MAX_INT; // no need to skip the reordered pictures in IDR, they are decodable.
1168    }
1169    else 
1170    {
1171      static Bool warningMessage = false;
1172      if(!warningMessage)
1173      {
1174        printf("\nWarning: this is not a valid random access point and the data is discarded until the first CRA picture");
1175        warningMessage = true;
1176      }
1177      return true;
1178    }
1179  }
1180  // skip the reordered pictures, if necessary
1181  else if (m_apcSlicePilot->getPOC() < m_pocRandomAccess && (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_R || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N))
1182  {
1183    iPOCLastDisplay++;
1184    return true;
1185  }
1186  // if we reach here, then the picture is not skipped.
1187  return false; 
1188}
1189
1190#if H_MV
1191TComPic* TDecTop::getPic( Int poc )
1192{
1193  xGetPic( m_layerId, poc ); 
1194  TComList<TComPic*>* listPic = getListPic();
1195  TComPic* pcPic = NULL;
1196  for(TComList<TComPic*>::iterator it=listPic->begin(); it!=listPic->end(); it++)
1197  {
1198    if( (*it)->getPOC() == poc )
1199    {
1200      pcPic = *it ;
1201      break ;
1202    }
1203  }
1204  return pcPic;
1205}
1206
1207TComPic* TDecTop::xGetPic( Int layerId, Int poc )
1208{ 
1209  return m_ivPicLists->getPic( layerId, poc ) ;
1210}
1211
1212#endif
1213//! \}
Note: See TracBrowser for help on using the repository browser.