source: 3DVCSoftware/branches/HTM-11.1-dev0/source/App/TAppDecoder/TAppDecTop.cpp @ 975

Last change on this file since 975 was 975, checked in by tech, 10 years ago

Cleanup part 9.
  • Property svn:eol-style set to native
File size: 35.9 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license. 
5 *
6* Copyright (c) 2010-2014, ITU/ISO/IEC
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 *  * Redistributions of source code must retain the above copyright notice,
13 *    this list of conditions and the following disclaimer.
14 *  * Redistributions in binary form must reproduce the above copyright notice,
15 *    this list of conditions and the following disclaimer in the documentation
16 *    and/or other materials provided with the distribution.
17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18 *    be used to endorse or promote products derived from this software without
19 *    specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31 * THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34/** \file     TAppDecTop.cpp
35    \brief    Decoder application class
36*/
37
38#include <list>
39#include <vector>
40#include <stdio.h>
41#include <fcntl.h>
42#include <assert.h>
43
44#include "TAppDecTop.h"
45#include "TLibDecoder/AnnexBread.h"
46#include "TLibDecoder/NALread.h"
47
48//! \ingroup TAppDecoder
49//! \{
50
51// ====================================================================================================================
52// Constructor / destructor / initialization / destroy
53// ====================================================================================================================
54
55TAppDecTop::TAppDecTop()
56#if !H_MV
57: m_iPOCLastDisplay(-MAX_INT)
58#else
59: m_numDecoders( 0 )
60#endif
61{
62#if H_MV
63  for (Int i = 0; i < MAX_NUM_LAYER_IDS; i++) 
64  {
65    m_layerIdToDecIdx[i] = -1; 
66    m_layerInitilizedFlags[i] = false; 
67  }
68#endif
69#if H_3D
70    m_pScaleOffsetFile  = 0;
71#endif
72
73#if H_MV
74    m_markedForOutput = false; 
75#endif
76
77}
78
79Void TAppDecTop::create()
80{
81}
82
83Void TAppDecTop::destroy()
84{
85  if (m_pchBitstreamFile)
86  {
87    free (m_pchBitstreamFile);
88    m_pchBitstreamFile = NULL;
89  }
90#if H_MV
91  for (Int decIdx = 0; decIdx < m_numDecoders; decIdx++)
92  {
93    if (m_pchReconFiles[decIdx])
94    {
95      free (m_pchReconFiles[decIdx]);
96      m_pchReconFiles[decIdx] = NULL;
97    }
98  }
99#endif
100  if (m_pchReconFile)
101  {
102    free (m_pchReconFile);
103    m_pchReconFile = NULL;
104  }
105#if H_3D
106  if (m_pchScaleOffsetFile)
107  {
108    free (m_pchScaleOffsetFile);
109    m_pchScaleOffsetFile = NULL; 
110  }
111#endif
112}
113
114// ====================================================================================================================
115// Public member functions
116// ====================================================================================================================
117
118/**
119 - create internal class
120 - initialize internal class
121 - until the end of the bitstream, call decoding function in TDecTop class
122 - delete allocated buffers
123 - destroy internal class
124 .
125 */
126Void TAppDecTop::decode()
127{
128  Int                 poc;
129#if H_MV
130  poc = -1; 
131#endif
132  TComList<TComPic*>* pcListPic = NULL;
133
134  ifstream bitstreamFile(m_pchBitstreamFile, ifstream::in | ifstream::binary);
135  if (!bitstreamFile)
136  {
137    fprintf(stderr, "\nfailed to open bitstream file `%s' for reading\n", m_pchBitstreamFile);
138    exit(EXIT_FAILURE);
139  }
140
141#if H_3D
142  if( m_pchScaleOffsetFile ) 
143  { 
144    m_pScaleOffsetFile = ::fopen( m_pchScaleOffsetFile, "wt" ); 
145    AOF( m_pScaleOffsetFile ); 
146  }
147#endif
148  InputByteStream bytestream(bitstreamFile);
149
150  // create & initialize internal classes
151  xCreateDecLib();
152  xInitDecLib  ();
153#if !H_MV
154  m_iPOCLastDisplay += m_iSkipFrame;      // set the last displayed POC correctly for skip forward.
155
156  // main decoder loop
157  Bool openedReconFile = false; // reconstruction file not yet opened. (must be performed after SPS is seen)
158#else
159
160  Int  pocCurrPic        = -MAX_INT;     
161  Int  pocLastPic        = -MAX_INT;   
162
163  Int  layerIdLastPic    = -MAX_INT; 
164  Int  layerIdCurrPic    = 0; 
165
166  Int  decIdxLastPic     = 0; 
167  Int  decIdxCurrPic     = 0; 
168
169  Bool firstSlice        = true; 
170#endif
171  Bool loopFiltered      = false;
172
173  while (!!bitstreamFile)
174  {
175    /* location serves to work around a design fault in the decoder, whereby
176     * the process of reading a new slice that is the first slice of a new frame
177     * requires the TDecTop::decode() method to be called again with the same
178     * nal unit. */
179    streampos location = bitstreamFile.tellg();
180#if H_MV
181#if ENC_DEC_TRACE
182    Int64 symCount = g_nSymbolCounter;
183#endif
184#endif
185    AnnexBStats stats = AnnexBStats();
186    vector<uint8_t> nalUnit;
187    InputNALUnit nalu;
188    byteStreamNALUnit(bytestream, nalUnit, stats);
189
190    // call actual decoding function
191    Bool bNewPicture = false;
192#if H_MV
193    Bool newSliceDiffPoc   = false;
194    Bool newSliceDiffLayer = false;
195    Bool sliceSkippedFlag  = false; 
196    Bool allLayersDecoded  = false;     
197#endif
198    if (nalUnit.empty())
199    {
200      /* this can happen if the following occur:
201       *  - empty input file
202       *  - two back-to-back start_code_prefixes
203       *  - start_code_prefix immediately followed by EOF
204       */
205      fprintf(stderr, "Warning: Attempt to decode an empty NAL unit\n");
206    }
207    else
208    {
209      read(nalu, nalUnit);
210#if H_MV     
211      if( (m_iMaxTemporalLayer >= 0 && nalu.m_temporalId > m_iMaxTemporalLayer) 
212          || !isNaluWithinTargetDecLayerIdSet(&nalu)
213          || nalu.m_layerId > MAX_NUM_LAYER_IDS-1
214          || (nalu.m_nalUnitType == NAL_UNIT_VPS && nalu.m_layerId > 0)           
215          || (nalu.m_nalUnitType == NAL_UNIT_EOB && nalu.m_layerId > 0)   
216          || (nalu.m_nalUnitType == NAL_UNIT_EOS && nalu.m_layerId > 0)   
217         ) 
218      {
219        bNewPicture = false;
220        if ( !bitstreamFile )
221        {
222          decIdxLastPic     = decIdxCurrPic; 
223        }
224      }
225      else
226      { 
227        Int decIdx     = xGetDecoderIdx( nalu.m_layerId , true );     
228        newSliceDiffLayer = nalu.isSlice() && ( nalu.m_layerId != layerIdCurrPic ) && !firstSlice;
229        newSliceDiffPoc   = m_tDecTop[decIdx]->decode(nalu, m_iSkipFrame, m_pocLastDisplay[decIdx], newSliceDiffLayer, sliceSkippedFlag );
230        // decode function only returns true when all of the following conditions are true
231        // - poc in particular layer changes
232        // - nalu does not belong to first slice in layer
233        // - nalu.isSlice() == true     
234
235        if ( nalu.m_nalUnitType == NAL_UNIT_VPS )
236        {
237          m_vps = m_tDecTop[decIdx]->getPrefetchedVPS(); 
238          if ( m_targetDecLayerIdSetFileEmpty )
239          {
240            TComVPS* vps = m_vps; 
241          if ( m_targetOptLayerSetIdx == -1 )
242          {
243            // Not normative! Corresponds to specification by "External Means". (Should be set equal to 0, when no external means available. )
244            m_targetOptLayerSetIdx = vps->getVpsNumLayerSetsMinus1(); 
245          }
246
247          for (Int dI = 0; dI < m_numDecoders; dI++ )
248          {
249            m_tDecTop[decIdx]->setTargetOptLayerSetIdx( m_targetOptLayerSetIdx ); 
250          }
251
252          if ( m_targetOptLayerSetIdx < 0 || m_targetOptLayerSetIdx >= vps->getNumOutputLayerSets() )
253          {
254            fprintf(stderr, "\ntarget output layer set index must be in the range of 0 to %d, inclusive \n", vps->getNumOutputLayerSets() - 1 );           
255            exit(EXIT_FAILURE);
256          }
257          m_targetDecLayerIdSet = vps->getTargetDecLayerIdList( m_targetOptLayerSetIdx ); 
258        }
259      }
260#if H_3D
261        if (nalu.m_nalUnitType == NAL_UNIT_VPS )
262        {                 
263          m_cCamParsCollector.init( m_pScaleOffsetFile, m_tDecTop[decIdx]->getPrefetchedVPS() );
264        }       
265#endif
266        bNewPicture       = ( newSliceDiffLayer || newSliceDiffPoc ) && !sliceSkippedFlag; 
267        if ( nalu.isSlice() && firstSlice && !sliceSkippedFlag )       
268        {
269          layerIdCurrPic = nalu.m_layerId; 
270          pocCurrPic     = m_tDecTop[decIdx]->getCurrPoc(); 
271          decIdxCurrPic  = decIdx; 
272          firstSlice     = false; 
273        }
274
275        if ( bNewPicture || !bitstreamFile )
276        { 
277          layerIdLastPic    = layerIdCurrPic; 
278          layerIdCurrPic    = nalu.m_layerId; 
279          pocLastPic        = pocCurrPic; 
280          pocCurrPic        = m_tDecTop[decIdx]->getCurrPoc(); 
281          decIdxLastPic     = decIdxCurrPic; 
282          decIdxCurrPic     = decIdx; 
283          allLayersDecoded = ( pocCurrPic != pocLastPic );
284        }
285#else
286      if( (m_iMaxTemporalLayer >= 0 && nalu.m_temporalId > m_iMaxTemporalLayer) || !isNaluWithinTargetDecLayerIdSet(&nalu)  )
287      {
288        bNewPicture = false;
289      }
290      else
291      {
292        bNewPicture = m_cTDecTop.decode(nalu, m_iSkipFrame, m_iPOCLastDisplay);
293#endif
294        if (bNewPicture)
295        {
296          bitstreamFile.clear();
297          /* location points to the current nalunit payload[1] due to the
298           * need for the annexB parser to read three extra bytes.
299           * [1] except for the first NAL unit in the file
300           *     (but bNewPicture doesn't happen then) */
301          bitstreamFile.seekg(location-streamoff(3));
302          bytestream.reset();
303#if H_MV_ENC_DEC_TRAC
304#if ENC_DEC_TRACE
305          const Bool resetCounter = false; 
306          if ( resetCounter )
307          {
308            g_nSymbolCounter  = symCount; // Only reset counter SH becomes traced twice
309          }
310          else
311          {
312            g_disableHLSTrace = true;     // Tracing of second parsing of SH is not carried out
313          }     
314#endif
315#endif
316        }
317      }
318    }
319    if (bNewPicture || !bitstreamFile || nalu.m_nalUnitType == NAL_UNIT_EOS )
320    {
321      if (!loopFiltered || bitstreamFile)
322      {
323#if H_MV
324        assert( decIdxLastPic != -1 ); 
325        m_tDecTop[decIdxLastPic]->endPicDecoding(poc, pcListPic, m_targetDecLayerIdSet );
326        xMarkForOutput( allLayersDecoded, poc, layerIdLastPic ); 
327#else
328        m_cTDecTop.executeLoopFilters(poc, pcListPic);
329#endif
330      }
331      loopFiltered = (nalu.m_nalUnitType == NAL_UNIT_EOS);
332    }
333#if !FIX_WRITING_OUTPUT
334#if SETTING_NO_OUT_PIC_PRIOR
335    if (bNewPicture && m_cTDecTop.getIsNoOutputPriorPics())
336    {
337      m_cTDecTop.checkNoOutputPriorPics( pcListPic );
338    }
339#endif
340#endif
341#if H_3D
342    if ( allLayersDecoded || !bitstreamFile )
343    {
344      for( Int dI = 0; dI < m_numDecoders; dI++ )
345      {
346        TComPic* picLastCoded = m_ivPicLists.getPic( m_tDecTop[dI]->getLayerId(), pocLastPic );
347        assert( picLastCoded != NULL );       
348        picLastCoded->compressMotion(1);
349      }
350    }
351#endif
352
353    if( pcListPic )
354    {
355#if H_MV
356      if ( m_pchReconFiles[decIdxLastPic] && !m_reconOpen[decIdxLastPic] )
357#else
358      if ( m_pchReconFile && !openedReconFile  )
359#endif
360      {
361        if (!m_outputBitDepthY) { m_outputBitDepthY = g_bitDepthY; }
362        if (!m_outputBitDepthC) { m_outputBitDepthC = g_bitDepthC; }
363
364#if H_MV
365        m_tVideoIOYuvReconFile[decIdxLastPic]->open( m_pchReconFiles[decIdxLastPic], true, m_outputBitDepthY, m_outputBitDepthC, g_bitDepthY, g_bitDepthC ); // write mode
366        m_reconOpen[decIdxLastPic] = true;
367      }
368#if FIX_WRITING_OUTPUT
369      // write reconstruction to file
370      if( bNewPicture )
371      {
372        // Bumping after picture has been decoded
373#if ENC_DEC_TRACE
374        g_bJustDoIt = true; 
375        writeToTraceFile( "Bumping after decoding \n", g_decTracePicOutput  );         
376        g_bJustDoIt = false; 
377#endif
378        xWriteOutput( pcListPic, decIdxLastPic, nalu.m_temporalId );
379      }
380#if SETTING_NO_OUT_PIC_PRIOR
381      if ( (bNewPicture || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_CRA) && m_tDecTop[decIdxLastPic]->getNoOutputPriorPicsFlag() )
382      {
383        m_tDecTop[decIdxLastPic]->checkNoOutputPriorPics( pcListPic );
384        m_tDecTop[decIdxLastPic]->setNoOutputPriorPicsFlag (false);
385      }
386#endif
387#endif
388      if ( bNewPicture && newSliceDiffPoc && 
389#else
390        m_cTVideoIOYuvReconFile.open( m_pchReconFile, true, m_outputBitDepthY, m_outputBitDepthC, g_bitDepthY, g_bitDepthC ); // write mode
391        openedReconFile  = true;
392      }
393#if FIX_WRITING_OUTPUT
394      // write reconstruction to file
395      if( bNewPicture )
396      {
397        xWriteOutput( pcListPic, nalu.m_temporalId );
398      }
399#if SETTING_NO_OUT_PIC_PRIOR
400      if ( (bNewPicture || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_CRA) && m_cTDecTop.getNoOutputPriorPicsFlag() )
401      {
402        m_cTDecTop.checkNoOutputPriorPics( pcListPic );
403        m_cTDecTop.setNoOutputPriorPicsFlag (false);
404      }
405#endif
406#endif
407      if ( bNewPicture && 
408#endif
409           (   nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR_W_RADL
410            || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR_N_LP
411            || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_BLA_N_LP
412            || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_RADL
413            || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_LP ) )
414      {
415#if H_MV
416        xFlushOutput( pcListPic, decIdxLastPic );
417#else
418        xFlushOutput( pcListPic );
419#endif
420      }
421      if (nalu.m_nalUnitType == NAL_UNIT_EOS)
422      {
423#if H_MV
424#if FIX_OUTPUT_EOS
425        xWriteOutput( pcListPic, decIdxLastPic, nalu.m_temporalId );
426#else
427        xFlushOutput( pcListPic, decIdxLastPic );
428#endif
429#else
430#if FIX_OUTPUT_EOS
431        xWriteOutput( pcListPic, nalu.m_temporalId );
432#else
433        xFlushOutput( pcListPic );
434#endif
435
436#endif
437      }
438      // write reconstruction to file -- for additional bumping as defined in C.5.2.3
439#if H_MV
440      // Above comment seems to be wrong
441#endif
442#if FIX_WRITING_OUTPUT
443      if(!bNewPicture && nalu.m_nalUnitType >= NAL_UNIT_CODED_SLICE_TRAIL_N && nalu.m_nalUnitType <= NAL_UNIT_RESERVED_VCL31)
444#else
445      if(bNewPicture)
446#endif
447      {
448#if H_MV       
449        // Bumping after reference picture set has been applied (here after first vcl nalu.
450#if ENC_DEC_TRACE
451        g_bJustDoIt = true; 
452        writeToTraceFile( "Bumping after reference picture set has been applied \n", g_decTracePicOutput  );         
453        g_bJustDoIt = false; 
454#endif
455
456        xWriteOutput( m_tDecTop[decIdxCurrPic]->getListPic(), decIdxCurrPic, nalu.m_temporalId );
457#else
458        xWriteOutput( pcListPic, nalu.m_temporalId );
459#endif
460      }
461    }
462  }
463#if H_MV
464#if H_3D
465  if( m_cCamParsCollector.isInitialized() )
466  {
467    m_cCamParsCollector.setSlice( 0 );
468  }
469#endif
470  for(UInt decIdx = 0; decIdx < m_numDecoders; decIdx++)
471  {
472    xFlushOutput( m_tDecTop[decIdx]->getListPic(), decIdx );
473  }
474#else 
475  xFlushOutput( pcListPic );
476  // delete buffers
477  m_cTDecTop.deletePicBuffer();
478#endif
479     
480  // destroy internal classes
481  xDestroyDecLib();
482}
483
484// ====================================================================================================================
485// Protected member functions
486// ====================================================================================================================
487
488Void TAppDecTop::xCreateDecLib()
489{
490#if H_MV
491  // initialize global variables
492  initROM(); 
493#if H_3D_DIM_DMM
494  initWedgeLists();
495#endif
496#else
497  // create decoder class
498  m_cTDecTop.create();
499#endif
500}
501
502Void TAppDecTop::xDestroyDecLib()
503{
504#if H_MV
505  // destroy ROM
506  destroyROM();
507
508  for(Int decIdx = 0; decIdx < m_numDecoders ; decIdx++)
509  {
510    if( m_tVideoIOYuvReconFile[decIdx] )
511    {
512      m_tVideoIOYuvReconFile[decIdx]->close();
513      delete m_tVideoIOYuvReconFile[decIdx]; 
514      m_tVideoIOYuvReconFile[decIdx] = NULL ;
515    }
516
517    if( m_tDecTop[decIdx] )
518    {
519      m_tDecTop[decIdx]->deletePicBuffer();
520      m_tDecTop[decIdx]->destroy() ;
521    }
522    delete m_tDecTop[decIdx] ; 
523    m_tDecTop[decIdx] = NULL ;
524  }
525#else
526  if ( m_pchReconFile )
527  {
528    m_cTVideoIOYuvReconFile. close();
529  }
530 
531  // destroy decoder class
532  m_cTDecTop.destroy();
533#endif
534#if H_3D
535  m_cCamParsCollector.uninit();
536  if( m_pScaleOffsetFile ) 
537  { 
538    ::fclose( m_pScaleOffsetFile ); 
539  }
540#endif
541}
542
543Void TAppDecTop::xInitDecLib()
544{
545#if !H_MV
546  // initialize decoder class
547  m_cTDecTop.init();
548  m_cTDecTop.setDecodedPictureHashSEIEnabled(m_decodedPictureHashSEIEnabled);
549#endif
550}
551
552/** \param pcListPic list of pictures to be written to file
553    \todo            DYN_REF_FREE should be revised
554 */
555#if H_MV
556Void TAppDecTop::xWriteOutput( TComList<TComPic*>* pcListPic, Int decIdx, Int tId )
557#else
558Void TAppDecTop::xWriteOutput( TComList<TComPic*>* pcListPic, UInt tId )
559#endif
560{
561
562  if (pcListPic->empty())
563  {
564    return;
565  }
566
567  TComList<TComPic*>::iterator iterPic   = pcListPic->begin();
568  Int numPicsNotYetDisplayed = 0;
569  Int dpbFullness = 0;
570#if H_MV
571  // preliminary fix
572  TComSPS* activeSPS = m_tDecTop[0]->getActiveSPS();
573#else
574  TComSPS* activeSPS = m_cTDecTop.getActiveSPS();
575#endif
576  UInt numReorderPicsHighestTid;
577  UInt maxDecPicBufferingHighestTid;
578  UInt maxNrSublayers = activeSPS->getMaxTLayers();
579
580  if(m_iMaxTemporalLayer == -1 || m_iMaxTemporalLayer >= maxNrSublayers)
581  {
582    numReorderPicsHighestTid = activeSPS->getNumReorderPics(maxNrSublayers-1);
583    maxDecPicBufferingHighestTid =  activeSPS->getMaxDecPicBuffering(maxNrSublayers-1); 
584  }
585  else
586  {
587    numReorderPicsHighestTid = activeSPS->getNumReorderPics(m_iMaxTemporalLayer);
588    maxDecPicBufferingHighestTid = activeSPS->getMaxDecPicBuffering(m_iMaxTemporalLayer); 
589  }
590 
591  while (iterPic != pcListPic->end())
592  {
593    TComPic* pcPic = *(iterPic);
594#if H_MV
595    if(pcPic->getOutputMark() && pcPic->getPOC() > m_pocLastDisplay[decIdx])
596#else
597    if(pcPic->getOutputMark() && pcPic->getPOC() > m_iPOCLastDisplay)
598#endif
599    {
600      numPicsNotYetDisplayed++;
601      dpbFullness++;
602    }
603    else if(pcPic->getSlice( 0 )->isReferenced())
604    {
605      dpbFullness++;
606    }
607    iterPic++;
608  }
609  iterPic   = pcListPic->begin();
610  if (numPicsNotYetDisplayed>2)
611  {
612    iterPic++;
613  }
614 
615  TComPic* pcPic = *(iterPic);
616  if (numPicsNotYetDisplayed>2 && pcPic->isField()) //Field Decoding
617  {
618    TComList<TComPic*>::iterator endPic   = pcListPic->end();
619    endPic--;
620    iterPic   = pcListPic->begin();
621    while (iterPic != endPic)
622    {
623      TComPic* pcPicTop = *(iterPic);
624      iterPic++;
625      TComPic* pcPicBottom = *(iterPic);
626     
627#if H_MV
628      if ( pcPicTop->getOutputMark() && (numPicsNotYetDisplayed >  pcPicTop->getNumReorderPics(tId) && !(pcPicTop->getPOC()%2) && pcPicBottom->getPOC() == pcPicTop->getPOC()+1)
629          && pcPicBottom->getOutputMark() && (numPicsNotYetDisplayed >  pcPicBottom->getNumReorderPics(tId) && (pcPicTop->getPOC() == m_pocLastDisplay[decIdx]+1 || m_pocLastDisplay[decIdx]<0)))
630#else
631      if ( pcPicTop->getOutputMark() && pcPicBottom->getOutputMark() &&
632          (numPicsNotYetDisplayed >  numReorderPicsHighestTid || dpbFullness > maxDecPicBufferingHighestTid) &&
633          (!(pcPicTop->getPOC()%2) && pcPicBottom->getPOC() == pcPicTop->getPOC()+1) &&
634          (pcPicTop->getPOC() == m_iPOCLastDisplay+1 || m_iPOCLastDisplay < 0))
635#endif
636      {
637        // write to file
638        numPicsNotYetDisplayed = numPicsNotYetDisplayed-2;
639#if H_MV
640      if ( m_pchReconFiles[decIdx] )
641#else
642        if ( m_pchReconFile )
643#endif
644        {
645          const Window &conf = pcPicTop->getConformanceWindow();
646          const Window &defDisp = m_respectDefDispWindow ? pcPicTop->getDefDisplayWindow() : Window();
647
648          const Bool isTff = pcPicTop->isTopField();
649#if H_MV
650        assert( conf   .getScaledFlag() );
651        assert( defDisp.getScaledFlag() );
652#if ENC_DEC_TRACE
653        g_bJustDoIt = true; 
654        writeToTraceFile( "OutputPic Poc"   , pcPic->getPOC    (), g_decTracePicOutput  ); 
655        writeToTraceFile( "OutputPic LayerId", pcPic->getLayerId(), g_decTracePicOutput );         
656        g_bJustDoIt = false; 
657#endif
658        m_tVideoIOYuvReconFile[decIdx]->write( pcPicTop->getPicYuvRec(), pcPicBottom->getPicYuvRec(),
659#else
660          m_cTVideoIOYuvReconFile.write( pcPicTop->getPicYuvRec(), pcPicBottom->getPicYuvRec(),
661#endif
662                                        conf.getWindowLeftOffset() + defDisp.getWindowLeftOffset(),
663                                        conf.getWindowRightOffset() + defDisp.getWindowRightOffset(),
664                                        conf.getWindowTopOffset() + defDisp.getWindowTopOffset(),
665                                        conf.getWindowBottomOffset() + defDisp.getWindowBottomOffset(), isTff );
666        }
667       
668        // update POC of display order
669#if H_MV
670        m_pocLastDisplay[decIdx] = pcPic->getPOC();
671#else
672        m_iPOCLastDisplay = pcPicBottom->getPOC();
673#endif
674       
675        // erase non-referenced picture in the reference picture list after display
676        if ( !pcPicTop->getSlice(0)->isReferenced() && pcPicTop->getReconMark() == true )
677        {
678#if !DYN_REF_FREE
679          pcPicTop->setReconMark(false);
680         
681          // mark it should be extended later
682          pcPicTop->getPicYuvRec()->setBorderExtension( false );
683         
684#else
685          pcPicTop->destroy();
686          pcListPic->erase( iterPic );
687          iterPic = pcListPic->begin(); // to the beginning, non-efficient way, have to be revised!
688          continue;
689#endif
690        }
691        if ( !pcPicBottom->getSlice(0)->isReferenced() && pcPicBottom->getReconMark() == true )
692        {
693#if !DYN_REF_FREE
694          pcPicBottom->setReconMark(false);
695         
696          // mark it should be extended later
697          pcPicBottom->getPicYuvRec()->setBorderExtension( false );
698         
699#else
700          pcPicBottom->destroy();
701          pcListPic->erase( iterPic );
702          iterPic = pcListPic->begin(); // to the beginning, non-efficient way, have to be revised!
703          continue;
704#endif
705        }
706        pcPicTop->setOutputMark(false);
707        pcPicBottom->setOutputMark(false);
708      }
709    }
710  }
711  else if (!pcPic->isField()) //Frame Decoding
712  {
713    iterPic = pcListPic->begin();
714    while (iterPic != pcListPic->end())
715    {
716      pcPic = *(iterPic);
717
718#if H_MV
719      if(pcPic->getOutputMark() && pcPic->getPOC() > m_pocLastDisplay[decIdx] &&
720        (numPicsNotYetDisplayed >  numReorderPicsHighestTid || dpbFullness > maxDecPicBufferingHighestTid))
721#else     
722      if(pcPic->getOutputMark() && pcPic->getPOC() > m_iPOCLastDisplay &&
723        (numPicsNotYetDisplayed >  numReorderPicsHighestTid || dpbFullness > maxDecPicBufferingHighestTid))
724#endif
725      {
726        // write to file
727        numPicsNotYetDisplayed--;
728        if(pcPic->getSlice(0)->isReferenced() == false)
729        {
730          dpbFullness--;
731        }
732#if H_MV
733      if ( m_pchReconFiles[decIdx] )
734#else
735        if ( m_pchReconFile )
736#endif
737        {
738          const Window &conf = pcPic->getConformanceWindow();
739          const Window &defDisp = m_respectDefDispWindow ? pcPic->getDefDisplayWindow() : Window();
740#if H_MV
741        assert( conf   .getScaledFlag() );
742        assert( defDisp.getScaledFlag() );
743#if ENC_DEC_TRACE
744        g_bJustDoIt = true; 
745        writeToTraceFile( "OutputPic Poc"   , pcPic->getPOC    (), g_decTracePicOutput  ); 
746        writeToTraceFile( "OutputPic LayerId", pcPic->getLayerId(), g_decTracePicOutput );         
747        g_bJustDoIt = false; 
748#endif
749        m_tVideoIOYuvReconFile[decIdx]->write( pcPic->getPicYuvRec(),
750#else
751          m_cTVideoIOYuvReconFile.write( pcPic->getPicYuvRec(),
752#endif
753                                        conf.getWindowLeftOffset() + defDisp.getWindowLeftOffset(),
754                                        conf.getWindowRightOffset() + defDisp.getWindowRightOffset(),
755                                        conf.getWindowTopOffset() + defDisp.getWindowTopOffset(),
756                                        conf.getWindowBottomOffset() + defDisp.getWindowBottomOffset() );
757        }
758       
759        // update POC of display order
760#if H_MV
761        m_pocLastDisplay[decIdx] = pcPic->getPOC();
762#else
763        m_iPOCLastDisplay = pcPic->getPOC();
764#endif
765       
766        // erase non-referenced picture in the reference picture list after display
767        if ( !pcPic->getSlice(0)->isReferenced() && pcPic->getReconMark() == true )
768        {
769#if !DYN_REF_FREE
770          pcPic->setReconMark(false);
771         
772          // mark it should be extended later
773          pcPic->getPicYuvRec()->setBorderExtension( false );
774         
775#else
776          pcPic->destroy();
777          pcListPic->erase( iterPic );
778          iterPic = pcListPic->begin(); // to the beginning, non-efficient way, have to be revised!
779          continue;
780#endif
781        }
782        pcPic->setOutputMark(false);
783#if H_MV
784        pcPic->setPicOutputFlag(false);
785#endif
786      }
787     
788      iterPic++;
789    }
790  }
791}
792/** \param pcListPic list of pictures to be written to file
793    \todo            DYN_REF_FREE should be revised
794 */
795#if H_MV
796Void TAppDecTop::xFlushOutput( TComList<TComPic*>* pcListPic, Int decIdx )
797#else
798Void TAppDecTop::xFlushOutput( TComList<TComPic*>* pcListPic )
799#endif
800{
801  if(!pcListPic || pcListPic->empty())
802  {
803    return;
804  }
805  TComList<TComPic*>::iterator iterPic   = pcListPic->begin();
806 
807  iterPic   = pcListPic->begin();
808  TComPic* pcPic = *(iterPic);
809 
810  if (pcPic->isField()) //Field Decoding
811  {
812    TComList<TComPic*>::iterator endPic   = pcListPic->end();
813    endPic--;
814    TComPic *pcPicTop, *pcPicBottom = NULL;
815    while (iterPic != endPic)
816    {
817      pcPicTop = *(iterPic);
818      iterPic++;
819      pcPicBottom = *(iterPic);
820     
821      if ( pcPicTop->getOutputMark() && pcPicBottom->getOutputMark() && !(pcPicTop->getPOC()%2) && (pcPicBottom->getPOC() == pcPicTop->getPOC()+1) )
822      {
823        // write to file
824#if H_MV
825      if ( m_pchReconFiles[decIdx] )
826#else
827        if ( m_pchReconFile )
828#endif
829        {
830          const Window &conf = pcPicTop->getConformanceWindow();
831          const Window &defDisp = m_respectDefDispWindow ? pcPicTop->getDefDisplayWindow() : Window();
832          const Bool isTff = pcPicTop->isTopField();
833#if H_MV
834        assert( conf   .getScaledFlag() );
835        assert( defDisp.getScaledFlag() );
836#if ENC_DEC_TRACE
837        g_bJustDoIt = true; 
838        writeToTraceFile( "OutputPic Poc"   , pcPic->getPOC    (), g_decTracePicOutput  ); 
839        writeToTraceFile( "OutputPic LayerId", pcPic->getLayerId(), g_decTracePicOutput );         
840        g_bJustDoIt = false; 
841#endif
842        m_tVideoIOYuvReconFile[decIdx]->write( pcPicTop->getPicYuvRec(), pcPicBottom->getPicYuvRec(),
843#else
844          m_cTVideoIOYuvReconFile.write( pcPicTop->getPicYuvRec(), pcPicBottom->getPicYuvRec(),
845#endif
846                                        conf.getWindowLeftOffset() + defDisp.getWindowLeftOffset(),
847                                        conf.getWindowRightOffset() + defDisp.getWindowRightOffset(),
848                                        conf.getWindowTopOffset() + defDisp.getWindowTopOffset(),
849                                        conf.getWindowBottomOffset() + defDisp.getWindowBottomOffset(), isTff );
850        }
851       
852        // update POC of display order
853#if H_MV
854      m_pocLastDisplay[decIdx] = pcPic->getPOC();
855#else
856      m_iPOCLastDisplay = pcPicBottom->getPOC();
857#endif       
858        // erase non-referenced picture in the reference picture list after display
859        if ( !pcPicTop->getSlice(0)->isReferenced() && pcPicTop->getReconMark() == true )
860        {
861#if !DYN_REF_FREE
862          pcPicTop->setReconMark(false);
863         
864          // mark it should be extended later
865          pcPicTop->getPicYuvRec()->setBorderExtension( false );
866         
867#else
868          pcPicTop->destroy();
869          pcListPic->erase( iterPic );
870          iterPic = pcListPic->begin(); // to the beginning, non-efficient way, have to be revised!
871          continue;
872#endif
873        }
874        if ( !pcPicBottom->getSlice(0)->isReferenced() && pcPicBottom->getReconMark() == true )
875        {
876#if !DYN_REF_FREE
877          pcPicBottom->setReconMark(false);
878         
879          // mark it should be extended later
880          pcPicBottom->getPicYuvRec()->setBorderExtension( false );
881         
882#else
883          pcPicBottom->destroy();
884          pcListPic->erase( iterPic );
885          iterPic = pcListPic->begin(); // to the beginning, non-efficient way, have to be revised!
886          continue;
887#endif
888        }
889        pcPicTop->setOutputMark(false);
890        pcPicBottom->setOutputMark(false);
891       
892#if !DYN_REF_FREE
893        if(pcPicTop)
894        {
895          pcPicTop->destroy();
896          delete pcPicTop;
897          pcPicTop = NULL;
898        }
899#endif
900      }
901    }
902    if(pcPicBottom)
903    {
904      pcPicBottom->destroy();
905      delete pcPicBottom;
906      pcPicBottom = NULL;
907    }
908  }
909  else //Frame decoding
910  {
911    while (iterPic != pcListPic->end())
912    {
913      pcPic = *(iterPic);
914     
915      if ( pcPic->getOutputMark() )
916      {
917        // write to file
918#if H_MV
919      if ( m_pchReconFiles[decIdx] )
920#else
921        if ( m_pchReconFile )
922#endif
923        {
924          const Window &conf = pcPic->getConformanceWindow();
925          const Window &defDisp = m_respectDefDispWindow ? pcPic->getDefDisplayWindow() : Window();
926#if H_MV
927        assert( conf   .getScaledFlag() );
928        assert( defDisp.getScaledFlag() );
929#if ENC_DEC_TRACE
930        g_bJustDoIt = true; 
931        writeToTraceFile( "OutputPic Poc"   , pcPic->getPOC    (), g_decTracePicOutput  ); 
932        writeToTraceFile( "OutputPic LayerId", pcPic->getLayerId(), g_decTracePicOutput );         
933        g_bJustDoIt = false; 
934#endif
935        m_tVideoIOYuvReconFile[decIdx]->write( pcPic->getPicYuvRec(),
936#else
937          m_cTVideoIOYuvReconFile.write( pcPic->getPicYuvRec(),
938#endif
939                                        conf.getWindowLeftOffset() + defDisp.getWindowLeftOffset(),
940                                        conf.getWindowRightOffset() + defDisp.getWindowRightOffset(),
941                                        conf.getWindowTopOffset() + defDisp.getWindowTopOffset(),
942                                        conf.getWindowBottomOffset() + defDisp.getWindowBottomOffset() );
943        }
944       
945        // update POC of display order
946#if H_MV
947      m_pocLastDisplay[decIdx] = pcPic->getPOC();
948#else
949        m_iPOCLastDisplay = pcPic->getPOC();
950#endif
951       
952        // erase non-referenced picture in the reference picture list after display
953        if ( !pcPic->getSlice(0)->isReferenced() && pcPic->getReconMark() == true )
954        {
955#if !DYN_REF_FREE
956          pcPic->setReconMark(false);
957         
958          // mark it should be extended later
959          pcPic->getPicYuvRec()->setBorderExtension( false );
960         
961#else
962          pcPic->destroy();
963          pcListPic->erase( iterPic );
964          iterPic = pcListPic->begin(); // to the beginning, non-efficient way, have to be revised!
965          continue;
966#endif
967        }
968        pcPic->setOutputMark(false);
969#if H_MV
970        pcPic->setPicOutputFlag(false);
971#endif
972      }
973#if !H_MV
974#if !DYN_REF_FREE
975      if(pcPic)
976      {
977        pcPic->destroy();
978        delete pcPic;
979        pcPic = NULL;
980      }
981#endif   
982#endif
983      iterPic++;
984    }
985  }
986#if H_MV
987  m_pocLastDisplay[decIdx] = -MAX_INT;
988#else
989  pcListPic->clear();
990  m_iPOCLastDisplay = -MAX_INT;
991#endif
992}
993
994/** \param nalu Input nalu to check whether its LayerId is within targetDecLayerIdSet
995 */
996Bool TAppDecTop::isNaluWithinTargetDecLayerIdSet( InputNALUnit* nalu )
997{
998  if ( m_targetDecLayerIdSet.size() == 0 ) // By default, the set is empty, meaning all LayerIds are allowed
999  {
1000    return true;
1001  }
1002  for (std::vector<Int>::iterator it = m_targetDecLayerIdSet.begin(); it != m_targetDecLayerIdSet.end(); it++)
1003  {
1004#if H_MV
1005    if ( nalu->m_layerId == (*it) )
1006#else
1007    if ( nalu->m_reservedZero6Bits == (*it) )
1008#endif
1009    {
1010      return true;
1011    }
1012  }
1013  return false;
1014}
1015
1016#if H_MV
1017Int TAppDecTop::xGetDecoderIdx( Int layerId, Bool createFlag /*= false */ )
1018{
1019  Int decIdx = -1; 
1020
1021  if ( layerId > MAX_NUM_LAYER_IDS-1 ) 
1022  {
1023    return decIdx; 
1024  }
1025
1026  if ( m_layerIdToDecIdx[ layerId ] != -1 ) 
1027  {     
1028    decIdx = m_layerIdToDecIdx[ layerId ]; 
1029  }
1030  else
1031  {     
1032    assert ( createFlag ); 
1033    assert( m_numDecoders < MAX_NUM_LAYERS ); 
1034
1035    decIdx = m_numDecoders; 
1036
1037    // Init decoder
1038    m_tDecTop[ decIdx ] =  new TDecTop;
1039    m_tDecTop[ decIdx ]->create();
1040    m_tDecTop[ decIdx ]->init( );
1041    m_tDecTop[ decIdx ]->setLayerId( layerId );
1042    m_tDecTop[ decIdx ]->setDecodedPictureHashSEIEnabled(m_decodedPictureHashSEIEnabled);
1043    m_tDecTop[ decIdx ]->setIvPicLists( &m_ivPicLists ); 
1044    m_tDecTop[ decIdx ]->setLayerInitilizedFlags( m_layerInitilizedFlags );
1045    m_tDecTop[ decIdx ]->setTargetOptLayerSetIdx( m_targetOptLayerSetIdx );   
1046
1047#if H_3D
1048   m_tDecTop[ decIdx ]->setCamParsCollector( &m_cCamParsCollector );
1049#endif
1050
1051    // append pic list of new decoder to PicLists
1052    assert( m_ivPicLists.size() == m_numDecoders );
1053    m_ivPicLists.push_back( m_tDecTop[ decIdx ]->getListPic() );
1054
1055    // create recon file related stuff     
1056    Char* pchTempFilename = NULL;
1057    if ( m_pchReconFile )
1058    {     
1059      Char buffer[4];     
1060      sprintf(buffer,"_%i", layerId );
1061      assert ( m_pchReconFile ); 
1062      xAppendToFileNameEnd( m_pchReconFile , buffer, pchTempFilename );
1063      assert( m_pchReconFiles.size() == m_numDecoders );
1064    }
1065
1066    m_pchReconFiles.push_back( pchTempFilename );   
1067
1068    m_tVideoIOYuvReconFile[ decIdx ] = new TVideoIOYuv;
1069    m_reconOpen           [ decIdx ] = false;
1070
1071    // set others
1072    m_pocLastDisplay      [ decIdx ] = -MAX_INT;
1073    m_layerIdToDecIdx     [ layerId ] = decIdx; 
1074
1075    m_numDecoders++; 
1076  };
1077  return decIdx;
1078
1079}
1080
1081Void TAppDecTop::xMarkForOutput( Bool allLayersDecoded, Int pocLastPic, Int layerIdLastPic )
1082{ 
1083  vector<Int> targetOptLayerIdList = m_vps->getTargetOptLayerIdList( m_targetOptLayerSetIdx );
1084
1085  if (m_vps->getAltOutputLayerFlagVar( m_targetOptLayerSetIdx ) )
1086  {
1087    assert( targetOptLayerIdList.size() == 1 ); 
1088    Int targetLayerId = targetOptLayerIdList[0];     
1089
1090    TComPic* curPic = m_ivPicLists.getPic( layerIdLastPic, pocLastPic );
1091    assert( curPic != NULL );
1092
1093    if ( layerIdLastPic == targetLayerId )
1094    {
1095      if ( curPic->getPicOutputFlag() )
1096      {
1097        curPic->setOutputMark( true );
1098      }
1099      else
1100      {       
1101        xMarkAltOutPic( targetLayerId, pocLastPic ); 
1102      }
1103      m_markedForOutput = true; 
1104    }
1105    else if ( ( layerIdLastPic > targetLayerId || allLayersDecoded ) && !m_markedForOutput )
1106    {
1107      xMarkAltOutPic( targetLayerId, pocLastPic );
1108    }
1109
1110    if ( allLayersDecoded )
1111    {
1112      m_markedForOutput = false; 
1113    }
1114  }
1115  else
1116  { 
1117    for( Int dI = 0; dI < m_numDecoders; dI++ )
1118    {     
1119      Int layerId = m_tDecTop[dI]->getLayerId(); 
1120      TComPic* curPic = m_ivPicLists.getPic( layerId, pocLastPic );
1121      if ( curPic != NULL )
1122      {
1123        if ( curPic->getReconMark() )
1124        {
1125          Bool isTargetOptLayer = std::find(targetOptLayerIdList.begin(), targetOptLayerIdList.end(), layerId) != targetOptLayerIdList.end();
1126          curPic->setOutputMark( isTargetOptLayer ? curPic->getPicOutputFlag() : false ); 
1127        }
1128      }
1129    }
1130  }
1131}
1132
1133Void TAppDecTop::xMarkAltOutPic( Int targetOutputLayer, Int pocLastPic )
1134{
1135  Int optLayerIdxInVps = m_vps->getLayerIdInNuh( targetOutputLayer ); 
1136  Int highestNuhLayerId = -1; 
1137  TComPic* picWithHighestNuhLayerId = NULL; 
1138  for (Int dIdx = 0; dIdx < m_numDecoders; dIdx++)
1139  {
1140    Int curLayerId = m_tDecTop[dIdx]->getLayerId();
1141    Int curLayerIdxInVps = m_vps->getLayerIdInNuh( curLayerId  ); 
1142    if ( m_vps->getInDirectDependencyFlag(optLayerIdxInVps, curLayerIdxInVps ) )
1143    {
1144      TComPic* curPic = m_ivPicLists.getPic( curLayerId, pocLastPic ); 
1145      if (curPic != NULL)
1146      {
1147        if (curPic->getReconMark() && curPic->getPicOutputFlag() )
1148        {
1149          curPic->setOutputMark   ( false ); 
1150          curPic->setPicOutputFlag( false ); 
1151          if ( curLayerId > highestNuhLayerId)
1152          {
1153            highestNuhLayerId = curLayerId ; 
1154            picWithHighestNuhLayerId = curPic; 
1155          }           
1156        }
1157      }
1158    }
1159  }
1160  if ( picWithHighestNuhLayerId != NULL )
1161  {
1162    picWithHighestNuhLayerId->setPicOutputFlag(true); 
1163    picWithHighestNuhLayerId->setOutputMark   (true); 
1164  }
1165}
1166
1167#endif
1168//! \}
Note: See TracBrowser for help on using the repository browser.