Ticket #1099: SVN_HEVCSoftware_trunk_ps_shared_ptr.patch

File SVN_HEVCSoftware_trunk_ps_shared_ptr.patch, 63.0 KB (added by jackh, 10 years ago)

  • source/App/TAppEncoder/TAppEncTop.cpp

     
    6767
    6868Void TAppEncTop::xInitLibCfg()
    6969{
    70   TComVPS vps;
     70  std::tr1::shared_ptr<TComVPS> vps=std::tr1::shared_ptr<TComVPS>(new TComVPS());
    7171 
    72   vps.setMaxTLayers                       ( m_maxTempLayer );
     72  vps->setMaxTLayers                       ( m_maxTempLayer );
    7373  if (m_maxTempLayer == 1)
    7474  {
    75     vps.setTemporalNestingFlag(true);
     75    vps->setTemporalNestingFlag(true);
    7676  }
    77   vps.setMaxLayers                        ( 1 );
     77  vps->setMaxLayers                        ( 1 );
    7878  for(Int i = 0; i < MAX_TLAYER; i++)
    7979  {
    80     vps.setNumReorderPics                 ( m_numReorderPics[i], i );
    81     vps.setMaxDecPicBuffering             ( m_maxDecPicBuffering[i], i );
     80    vps->setNumReorderPics                 ( m_numReorderPics[i], i );
     81    vps->setMaxDecPicBuffering             ( m_maxDecPicBuffering[i], i );
    8282  }
    83   m_cTEncTop.setVPS(&vps);
     83  m_cTEncTop.setVPS(vps);
    8484
    8585  m_cTEncTop.setProfile(m_profile);
    8686  m_cTEncTop.setLevel(m_levelTier, m_level);

  • source/Lib/TLibDecoder/TDecSlice.cpp

     
    406406
    407407}
    408408
    409 TComVPS* ParameterSetManagerDecoder::getPrefetchedVPS  (Int vpsId)
     409std::tr1::shared_ptr<TComVPS> ParameterSetManagerDecoder::getPrefetchedVPS  (Int vpsId)
    410410{
    411411  if (m_vpsBuffer.getPS(vpsId) != NULL )
    412412  {
    … …  
    419419}
    420420
    421421
    422 TComSPS* ParameterSetManagerDecoder::getPrefetchedSPS  (Int spsId)
     422std::tr1::shared_ptr<TComSPS> ParameterSetManagerDecoder::getPrefetchedSPS  (Int spsId)
    423423{
    424424  if (m_spsBuffer.getPS(spsId) != NULL )
    425425  {
    … …  
    431431  }
    432432}
    433433
    434 TComPPS* ParameterSetManagerDecoder::getPrefetchedPPS  (Int ppsId)
     434std::tr1::shared_ptr<TComPPS> ParameterSetManagerDecoder::getPrefetchedPPS  (Int ppsId)
    435435{
    436436  if (m_ppsBuffer.getPS(ppsId) != NULL )
    437437  {

  • source/Lib/TLibDecoder/TDecTop.cpp

     
    251251{
    252252  m_parameterSetManagerDecoder.applyPrefetchedPS();
    253253 
    254   TComPPS *pps = m_parameterSetManagerDecoder.getPPS(m_apcSlicePilot->getPPSId());
    255   assert (pps != 0);
     254  std::tr1::shared_ptr<TComPPS> pps = m_parameterSetManagerDecoder.getPPS(m_apcSlicePilot->getPPSId());
     255  assert (pps);
    256256
    257   TComSPS *sps = m_parameterSetManagerDecoder.getSPS(pps->getSPSId());
    258   assert (sps != 0);
     257  std::tr1::shared_ptr<TComSPS> sps = m_parameterSetManagerDecoder.getSPS(pps->getSPSId());
     258  assert (sps);
    259259
    260260  Bool spsChanged=sps!=m_parameterSetManagerDecoder.getActiveSPS();
    261261  if (false == m_parameterSetManagerDecoder.activatePPS(m_apcSlicePilot->getPPSId(),m_apcSlicePilot->isIRAP()))
    … …  
    620620
    621621Void TDecTop::xDecodeVPS()
    622622{
    623   TComVPS* vps = new TComVPS();
     623  std::tr1::shared_ptr<TComVPS> vps = std::tr1::shared_ptr<TComVPS>(new TComVPS());
    624624 
    625625  m_cEntropyDecoder.decodeVPS( vps );
    626626  m_parameterSetManagerDecoder.storePrefetchedVPS(vps); 
     627 
    627628}
    628629
    629630Void TDecTop::xDecodeSPS()
    630631{
    631   TComSPS* sps = new TComSPS();
     632  std::tr1::shared_ptr<TComSPS> sps = std::tr1::shared_ptr<TComSPS>(new TComSPS());
    632633  m_cEntropyDecoder.decodeSPS( sps );
    633634  m_parameterSetManagerDecoder.storePrefetchedSPS(sps);
    634635}
    635636
    636637Void TDecTop::xDecodePPS()
    637638{
    638   TComPPS* pps = new TComPPS();
     639  std::tr1::shared_ptr<TComPPS> pps = std::tr1::shared_ptr<TComPPS>(new TComPPS());
    639640  m_cEntropyDecoder.decodePPS( pps );
    640641  m_parameterSetManagerDecoder.storePrefetchedPPS( pps );
    641642}

  • source/Lib/TLibDecoder/TDecSlice.h

     
    9292public:
    9393  ParameterSetManagerDecoder();
    9494  virtual ~ParameterSetManagerDecoder();
    95   Void     storePrefetchedVPS(TComVPS *vps)  { m_vpsBuffer.storePS( vps->getVPSId(), vps); };
    96   TComVPS* getPrefetchedVPS  (Int vpsId);
    97   Void     storePrefetchedSPS(TComSPS *sps)  { m_spsBuffer.storePS( sps->getSPSId(), sps); };
    98   TComSPS* getPrefetchedSPS  (Int spsId);
    99   Void     storePrefetchedPPS(TComPPS *pps)  { m_ppsBuffer.storePS( pps->getPPSId(), pps); };
    100   TComPPS* getPrefetchedPPS  (Int ppsId);
     95  Void     storePrefetchedVPS(const std::tr1::shared_ptr<TComVPS> &vps)  { m_vpsBuffer.storePS( vps->getVPSId(), vps); };
     96  std::tr1::shared_ptr<TComVPS> getPrefetchedVPS  (Int vpsId);
     97  Void     storePrefetchedSPS(const std::tr1::shared_ptr<TComSPS> &sps)  { m_spsBuffer.storePS( sps->getSPSId(), sps); };
     98  std::tr1::shared_ptr<TComSPS> getPrefetchedSPS  (Int spsId);
     99  Void     storePrefetchedPPS(const std::tr1::shared_ptr<TComPPS> &pps)  { m_ppsBuffer.storePS( pps->getPPSId(), pps); };
     100  std::tr1::shared_ptr<TComPPS> getPrefetchedPPS  (Int ppsId);
    101101  Void     applyPrefetchedPS();
    102102
    103103private:

  • source/Lib/TLibDecoder/TDecEntropy.h

     
    6464  virtual Void  resetEntropy          ( TComSlice* pcSlice )     = 0;
    6565  virtual Void  setBitstream          ( TComInputBitstream* p )  = 0;
    6666
    67   virtual Void  parseVPS                  ( TComVPS* pcVPS )                       = 0;
    68   virtual Void  parseSPS                  ( TComSPS* pcSPS )                                      = 0;
    69   virtual Void  parsePPS                  ( TComPPS* pcPPS )                                      = 0;
     67  virtual Void  parseVPS                  ( const std::tr1::shared_ptr<TComVPS> &pcVPS )                       = 0;
     68  virtual Void  parseSPS                  ( const std::tr1::shared_ptr<TComSPS> &pcSPS )                                      = 0;
     69  virtual Void  parsePPS                  ( const std::tr1::shared_ptr<TComPPS> &pcPPS )                                      = 0;
    7070
    7171  virtual Void parseSliceHeader          ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager)       = 0;
    7272
    … …  
    127127  Void    setEntropyDecoder           ( TDecEntropyIf* p );
    128128  Void    setBitstream                ( TComInputBitstream* p ) { m_pcEntropyDecoderIf->setBitstream(p);                    }
    129129  Void    resetEntropy                ( TComSlice* p)           { m_pcEntropyDecoderIf->resetEntropy(p);                    }
    130   Void    decodeVPS                   ( TComVPS* pcVPS ) { m_pcEntropyDecoderIf->parseVPS(pcVPS); }
    131   Void    decodeSPS                   ( TComSPS* pcSPS     )    { m_pcEntropyDecoderIf->parseSPS(pcSPS);                    }
    132   Void    decodePPS                   ( TComPPS* pcPPS )    { m_pcEntropyDecoderIf->parsePPS(pcPPS);                    }
     130  Void    decodeVPS                   ( const std::tr1::shared_ptr<TComVPS> &pcVPS ) { m_pcEntropyDecoderIf->parseVPS(pcVPS); }
     131  Void    decodeSPS                   ( const std::tr1::shared_ptr<TComSPS> &pcSPS     )    { m_pcEntropyDecoderIf->parseSPS(pcSPS);                    }
     132  Void    decodePPS                   ( const std::tr1::shared_ptr<TComPPS> &pcPPS )    { m_pcEntropyDecoderIf->parsePPS(pcPPS);                    }
    133133  Void    decodeSliceHeader           ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager)  { m_pcEntropyDecoderIf->parseSliceHeader(rpcSlice, parameterSetManager);         }
    134134
    135135  Void    decodeTerminatingBit        ( UInt& ruiIsLast )       { m_pcEntropyDecoderIf->parseTerminatingBit(ruiIsLast);     }

  • source/Lib/TLibDecoder/SEIread.cpp

     
    108108/**
    109109 * unmarshal a single SEI message from bitstream bs
    110110 */
    111 void SEIReader::parseSEImessage(TComInputBitstream* bs, SEIMessages& seis, const NalUnitType nalUnitType, TComSPS *sps)
     111void SEIReader::parseSEImessage(TComInputBitstream* bs, SEIMessages& seis, const NalUnitType nalUnitType, const std::tr1::shared_ptr<TComSPS> &sps)
    112112{
    113113  setBitstream(bs);
    114114
    … …  
    126126  assert(rbspTrailingBits == 0x80);
    127127}
    128128
    129 Void SEIReader::xReadSEImessage(SEIMessages& seis, const NalUnitType nalUnitType, TComSPS *sps)
     129Void SEIReader::xReadSEImessage(SEIMessages& seis, const NalUnitType nalUnitType, const std::tr1::shared_ptr<TComSPS> &sps)
    130130{
    131131#if ENC_DEC_TRACE
    132132  xTraceSEIHeader();
    … …  
    405405  }
    406406}
    407407
    408 Void SEIReader::xParseSEIDecodingUnitInfo(SEIDecodingUnitInfo& sei, UInt /*payloadSize*/, TComSPS *sps)
     408Void SEIReader::xParseSEIDecodingUnitInfo(SEIDecodingUnitInfo& sei, UInt /*payloadSize*/, const std::tr1::shared_ptr<TComSPS> &sps)
    409409{
    410410  UInt val;
    411411  READ_UVLC(val, "decoding_unit_idx");
    … …  
    430430  xParseByteAlign();
    431431}
    432432
    433 Void SEIReader::xParseSEIBufferingPeriod(SEIBufferingPeriod& sei, UInt /*payloadSize*/, TComSPS *sps)
     433Void SEIReader::xParseSEIBufferingPeriod(SEIBufferingPeriod& sei, UInt /*payloadSize*/, const std::tr1::shared_ptr<TComSPS> &sps)
    434434{
    435435  Int i, nalOrVcl;
    436436  UInt code;
    … …  
    476476  }
    477477  xParseByteAlign();
    478478}
    479 Void SEIReader::xParseSEIPictureTiming(SEIPictureTiming& sei, UInt /*payloadSize*/, TComSPS *sps)
     479Void SEIReader::xParseSEIPictureTiming(SEIPictureTiming& sei, UInt /*payloadSize*/, const std::tr1::shared_ptr<TComSPS> &sps)
    480480{
    481481  Int i;
    482482  UInt code;
    … …  
    718718  xParseByteAlign();
    719719}
    720720
    721 Void SEIReader::xParseSEIScalableNesting(SEIScalableNesting& sei, const NalUnitType nalUnitType, UInt payloadSize, TComSPS *sps)
     721Void SEIReader::xParseSEIScalableNesting(SEIScalableNesting& sei, const NalUnitType nalUnitType, UInt payloadSize, const std::tr1::shared_ptr<TComSPS> &sps)
    722722{
    723723  UInt uiCode;
    724724  SEIMessages seis;

  • source/Lib/TLibDecoder/TDecSbac.h

     
    7474
    7575  Void  resetEntropy (TComSlice* pSlice );
    7676  Void  setBitstream              ( TComInputBitstream* p  ) { m_pcBitstream = p; m_pcTDecBinIf->init( p ); }
    77   Void  parseVPS                  ( TComVPS* /*pcVPS*/ ) {}
    78   Void  parseSPS                  ( TComSPS* /*pcSPS*/ ) {}
    79   Void  parsePPS                  ( TComPPS* /*pcPPS*/ ) {}
     77  Void  parseVPS                  ( const std::tr1::shared_ptr<TComVPS> & /*pcVPS*/ ) {}
     78  Void  parseSPS                  ( const std::tr1::shared_ptr<TComSPS> & /*pcSPS*/ ) {}
     79  Void  parsePPS                  ( const std::tr1::shared_ptr<TComPPS> & /*pcPPS*/ ) {}
    8080
    8181  Void  parseSliceHeader          ( TComSlice*& /*rpcSlice*/, ParameterSetManagerDecoder* /*parameterSetManager*/) {}
    8282  Void  parseTerminatingBit       ( UInt& ruiBit );

  • source/Lib/TLibDecoder/SEIread.h

     
    5555public:
    5656  SEIReader() {};
    5757  virtual ~SEIReader() {};
    58   Void parseSEImessage(TComInputBitstream* bs, SEIMessages& seis, const NalUnitType nalUnitType, TComSPS *sps);
     58  Void parseSEImessage(TComInputBitstream* bs, SEIMessages& seis, const NalUnitType nalUnitType, const std::tr1::shared_ptr<TComSPS> &sps);
    5959protected:
    60   Void xReadSEImessage                (SEIMessages& seis, const NalUnitType nalUnitType, TComSPS *sps);
     60  Void xReadSEImessage                (SEIMessages& seis, const NalUnitType nalUnitType, const std::tr1::shared_ptr<TComSPS> &sps);
    6161  Void xParseSEIuserDataUnregistered  (SEIuserDataUnregistered &sei, UInt payloadSize);
    6262  Void xParseSEIActiveParameterSets   (SEIActiveParameterSets  &sei, UInt payloadSize);
    63   Void xParseSEIDecodingUnitInfo      (SEIDecodingUnitInfo& sei, UInt payloadSize, TComSPS *sps);
     63  Void xParseSEIDecodingUnitInfo      (SEIDecodingUnitInfo& sei, UInt payloadSize, const std::tr1::shared_ptr<TComSPS> &sps);
    6464  Void xParseSEIDecodedPictureHash    (SEIDecodedPictureHash& sei, UInt payloadSize);
    65   Void xParseSEIBufferingPeriod       (SEIBufferingPeriod& sei, UInt payloadSize, TComSPS *sps);
    66   Void xParseSEIPictureTiming         (SEIPictureTiming& sei, UInt payloadSize, TComSPS *sps);
     65  Void xParseSEIBufferingPeriod       (SEIBufferingPeriod& sei, UInt payloadSize, const std::tr1::shared_ptr<TComSPS> &sps);
     66  Void xParseSEIPictureTiming         (SEIPictureTiming& sei, UInt payloadSize, const std::tr1::shared_ptr<TComSPS> &sps);
    6767  Void xParseSEIRecoveryPoint         (SEIRecoveryPoint& sei, UInt payloadSize);
    6868  Void xParseSEIFramePacking          (SEIFramePacking& sei, UInt payloadSize);
    6969  Void xParseSEIDisplayOrientation    (SEIDisplayOrientation &sei, UInt payloadSize);
    … …  
    7171  Void xParseSEIGradualDecodingRefreshInfo (SEIGradualDecodingRefreshInfo &sei, UInt payloadSize);
    7272  Void xParseSEIToneMappingInfo       (SEIToneMappingInfo& sei, UInt payloadSize);
    7373  Void xParseSEISOPDescription        (SEISOPDescription &sei, UInt payloadSize);
    74   Void xParseSEIScalableNesting       (SEIScalableNesting& sei, const NalUnitType nalUnitType, UInt payloadSize, TComSPS *sps);
     74  Void xParseSEIScalableNesting       (SEIScalableNesting& sei, const NalUnitType nalUnitType, UInt payloadSize, const std::tr1::shared_ptr<TComSPS> &sps);
    7575  Void xParseByteAlign();
    7676};
    7777

  • source/Lib/TLibDecoder/TDecCAVLC.cpp

     
    4444
    4545#if ENC_DEC_TRACE
    4646
    47 Void  xTraceSPSHeader (TComSPS *pSPS)
     47Void  xTraceSPSHeader (const std::tr1::shared_ptr<TComSPS> &pSPS)
    4848{
    4949  fprintf( g_hTrace, "=========== Sequence Parameter Set ID: %d ===========\n", pSPS->getSPSId() );
    5050}
    5151
    52 Void  xTracePPSHeader (TComPPS *pPPS)
     52Void  xTracePPSHeader (const std::tr1::shared_ptr<TComPPS> &pPPS)
    5353{
    5454  fprintf( g_hTrace, "=========== Picture Parameter Set ID: %d ===========\n", pPPS->getPPSId() );
    5555}
    … …  
    7878// Public member functions
    7979// ====================================================================================================================
    8080
    81 void TDecCavlc::parseShortTermRefPicSet( TComSPS* sps, TComReferencePictureSet* rps, Int idx )
     81void TDecCavlc::parseShortTermRefPicSet( const std::tr1::shared_ptr<TComSPS> &sps, TComReferencePictureSet* rps, Int idx )
    8282{
    8383  UInt code;
    8484  UInt interRPSPred;
    … …  
    174174#endif
    175175}
    176176
    177 Void TDecCavlc::parsePPS(TComPPS* pcPPS)
     177Void TDecCavlc::parsePPS(const std::tr1::shared_ptr<TComPPS> &pcPPS)
    178178{
    179179#if ENC_DEC_TRACE 
    180180  xTracePPSHeader (pcPPS);
    … …  
    314314  }
    315315}
    316316
    317 Void  TDecCavlc::parseVUI(TComVUI* pcVUI, TComSPS *pcSPS)
     317Void  TDecCavlc::parseVUI(TComVUI* pcVUI, const std::tr1::shared_ptr<TComSPS> &pcSPS)
    318318{
    319319#if ENC_DEC_TRACE
    320320  fprintf( g_hTrace, "----------- vui_parameters -----------\n");
    … …  
    481481  }
    482482}
    483483
    484 Void TDecCavlc::parseSPS(TComSPS* pcSPS)
     484Void TDecCavlc::parseSPS(const std::tr1::shared_ptr<TComSPS> &pcSPS)
    485485{
    486486#if ENC_DEC_TRACE 
    487487  xTraceSPSHeader (pcSPS);
    … …  
    648648  }
    649649}
    650650
    651 Void TDecCavlc::parseVPS(TComVPS* pcVPS)
     651Void TDecCavlc::parseVPS(const std::tr1::shared_ptr<TComVPS> &pcVPS)
    652652{
    653653  UInt  uiCode;
    654654 
    … …  
    739739#if ENC_DEC_TRACE
    740740  xTraceSliceHeader(rpcSlice);
    741741#endif
    742   TComPPS* pps = NULL;
    743   TComSPS* sps = NULL;
     742  std::tr1::shared_ptr<TComPPS> pps;
     743  std::tr1::shared_ptr<TComSPS> sps;
    744744
    745745  UInt firstSliceSegmentInPic;
    746746  READ_FLAG( firstSliceSegmentInPic, "first_slice_segment_in_pic_flag" );

  • source/Lib/TLibDecoder/TDecCAVLC.h

     
    6060  virtual ~TDecCavlc();
    6161 
    6262protected:
    63   void  parseShortTermRefPicSet            (TComSPS* pcSPS, TComReferencePictureSet* pcRPS, Int idx);
     63  void  parseShortTermRefPicSet            (const std::tr1::shared_ptr<TComSPS> &pcSPS, TComReferencePictureSet* pcRPS, Int idx);
    6464 
    6565public:
    6666
    … …  
    7070  Void  parseTransformSubdivFlag( UInt& ruiSubdivFlag, UInt uiLog2TransformBlockSize );
    7171  Void  parseQtCbf          ( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth, UInt uiDepth );
    7272  Void  parseQtRootCbf      ( UInt uiAbsPartIdx, UInt& uiQtRootCbf );
    73   Void  parseVPS            ( TComVPS* pcVPS );
    74   Void  parseSPS            ( TComSPS* pcSPS );
    75   Void  parsePPS            ( TComPPS* pcPPS);
    76   Void  parseVUI            ( TComVUI* pcVUI, TComSPS* pcSPS );
     73  Void  parseVPS            ( const std::tr1::shared_ptr<TComVPS> &pcVPS );
     74  Void  parseSPS            ( const std::tr1::shared_ptr<TComSPS> &pcSPS );
     75  Void  parsePPS            ( const std::tr1::shared_ptr<TComPPS> &pcPPS);
     76  Void  parseVUI            ( TComVUI* pcVUI, const std::tr1::shared_ptr<TComSPS> &pcSPS );
    7777  Void  parseSEI            ( SEIMessages& );
    7878  Void  parsePTL            ( TComPTL *rpcPTL, Bool profilePresentFlag, Int maxNumSubLayersMinus1 );
    7979  Void  parseProfileTier    (ProfileTierLevel *ptl);

  • source/Lib/TLibCommon/TComSlice.h

     
    4141#include <cstring>
    4242#include <map>
    4343#include <vector>
     44#ifdef _MSC_VER
     45#include <memory>
     46#else
     47#include <tr1/memory>
     48#endif
    4449#include "CommonDef.h"
    4550#include "TComRom.h"
    4651#include "TComList.h"
    … …  
    916921  Bool        m_bSliceChromaQpFlag;       // slicelevel_chroma_qp_flag
    917922
    918923  // access channel
    919   TComSPS*    m_pcSPS;
     924  std::tr1::shared_ptr<TComSPS>     m_pcSPS;
    920925  UInt        m_uiMaxCuDQPDepth;
    921926  UInt        m_uiMinCuDQPSize;
    922927
    … …  
    981986  Bool      getSliceChromaQpFlag ()         { return  m_bSliceChromaQpFlag; }
    982987  Void      setSliceChromaQpFlag ( Bool b ) { m_bSliceChromaQpFlag = b;     }
    983988
    984   Void      setSPS              ( TComSPS* pcSPS ) { m_pcSPS = pcSPS; }
    985   TComSPS*  getSPS              ()         { return m_pcSPS;          }
     989  Void      setSPS              ( const std::tr1::shared_ptr<TComSPS> &pcSPS ) { m_pcSPS = pcSPS; }
     990  std::tr1::shared_ptr<TComSPS>  getSPS              ()         { return m_pcSPS;          }
    986991  Void      setMaxCuDQPDepth    ( UInt u ) { m_uiMaxCuDQPDepth = u;   }
    987992  UInt      getMaxCuDQPDepth    ()         { return m_uiMaxCuDQPDepth;}
    988993  Void      setMinCuDQPSize     ( UInt u ) { m_uiMinCuDQPSize = u;    }
    … …  
    11511156  Bool        m_bRefenced;
    11521157 
    11531158  // access channel
    1154   TComVPS*    m_pcVPS;
    1155   TComSPS*    m_pcSPS;
    1156   TComPPS*    m_pcPPS;
     1159  std::tr1::shared_ptr<TComVPS>    m_pcVPS;
     1160  std::tr1::shared_ptr<TComSPS>    m_pcSPS;
     1161  std::tr1::shared_ptr<TComPPS>    m_pcPPS;
    11571162  TComPic*    m_pcPic;
    11581163#if ADAPTIVE_QP_SELECTION
    11591164  TComTrQuant* m_pcTrQuant;
    … …  
    12111216  virtual ~TComSlice();
    12121217  Void      initSlice       ();
    12131218
    1214   Void      setVPS          ( TComVPS* pcVPS ) { m_pcVPS = pcVPS; }
    1215   TComVPS*  getVPS          () { return m_pcVPS; }
    1216   Void      setSPS          ( TComSPS* pcSPS ) { m_pcSPS = pcSPS; }
    1217   TComSPS*  getSPS          () { return m_pcSPS; }
     1219  Void      setVPS          ( const std::tr1::shared_ptr<TComVPS> &pcVPS ) { m_pcVPS = pcVPS; }
     1220  std::tr1::shared_ptr<TComVPS>  getVPS          () { return m_pcVPS; }
     1221  Void      setSPS          ( const std::tr1::shared_ptr<TComSPS> &pcSPS ) { m_pcSPS = pcSPS; }
     1222  std::tr1::shared_ptr<TComSPS>  getSPS          () { return m_pcSPS; }
    12181223 
    1219   Void      setPPS          ( TComPPS* pcPPS )         { assert(pcPPS!=NULL); m_pcPPS = pcPPS; m_iPPSId = pcPPS->getPPSId(); }
    1220   TComPPS*  getPPS          () { return m_pcPPS; }
     1224  Void      setPPS          ( const std::tr1::shared_ptr<TComPPS> &pcPPS )         { assert(pcPPS); m_pcPPS = pcPPS; m_iPPSId = pcPPS->getPPSId(); }
     1225  std::tr1::shared_ptr<TComPPS>  getPPS          () { return m_pcPPS; }
    12211226
    12221227#if ADAPTIVE_QP_SELECTION
    12231228  Void          setTrQuant          ( TComTrQuant* pcTrQuant ) { m_pcTrQuant = pcTrQuant; }
    … …  
    14381443  :m_maxId (maxId)
    14391444  {}
    14401445
    1441   ~ParameterSetMap()
     1446  Void storePS(Int psId, const std::tr1::shared_ptr<T> &ps)
    14421447  {
    1443     for (typename std::map<Int,T *>::iterator i = m_paramsetMap.begin(); i!= m_paramsetMap.end(); i++)
    1444     {
    1445       delete (*i).second;
    1446     }
    1447   }
    1448 
    1449   Void storePS(Int psId, T *ps)
    1450   {
    14511448    assert ( psId < m_maxId );
    1452     if ( m_paramsetMap.find(psId) != m_paramsetMap.end() )
    1453     {
    1454       delete m_paramsetMap[psId];
    1455     }
    14561449    m_paramsetMap[psId] = ps;
    14571450  }
    14581451
    14591452  Void mergePSList(ParameterSetMap<T> &rPsList)
    14601453  {
    1461     for (typename std::map<Int,T *>::iterator i = rPsList.m_paramsetMap.begin(); i!= rPsList.m_paramsetMap.end(); i++)
     1454    for (typename std::map<Int,std::tr1::shared_ptr<T> >::iterator i = rPsList.m_paramsetMap.begin(); i!= rPsList.m_paramsetMap.end(); i++)
    14621455    {
    14631456      storePS(i->first, i->second);
    14641457    }
    … …  
    14661459  }
    14671460
    14681461
    1469   T* getPS(Int psId)
     1462  std::tr1::shared_ptr<T> getPS(Int psId)
    14701463  {
    1471     return ( m_paramsetMap.find(psId) == m_paramsetMap.end() ) ? NULL : m_paramsetMap[psId];
     1464    return ( m_paramsetMap.find(psId) == m_paramsetMap.end() ) ? std::tr1::shared_ptr<T>() : m_paramsetMap[psId];
    14721465  }
    14731466
    1474   T* getFirstPS()
     1467  std::tr1::shared_ptr<T> getFirstPS()
    14751468  {
    1476     return (m_paramsetMap.begin() == m_paramsetMap.end() ) ? NULL : m_paramsetMap.begin()->second;
     1469    return (m_paramsetMap.begin() == m_paramsetMap.end() ) ? std::tr1::shared_ptr<T>() : m_paramsetMap.begin()->second;
    14771470  }
    14781471
    14791472private:
    1480   std::map<Int,T *> m_paramsetMap;
     1473  std::map<Int,std::tr1::shared_ptr<T> > m_paramsetMap;
    14811474  Int               m_maxId;
    14821475};
    14831476
    … …  
    14881481  virtual ~ParameterSetManager();
    14891482
    14901483  //! store sequence parameter set and take ownership of it
    1491   Void storeVPS(TComVPS *vps) { m_vpsMap.storePS( vps->getVPSId(), vps); };
     1484  Void storeVPS(const std::tr1::shared_ptr<TComVPS> &vps) { m_vpsMap.storePS( vps->getVPSId(), vps); };
    14921485  //! get pointer to existing video parameter set 
    1493   TComVPS* getVPS(Int vpsId)  { return m_vpsMap.getPS(vpsId); };
    1494   TComVPS* getFirstVPS()      { return m_vpsMap.getFirstPS(); };
     1486  std::tr1::shared_ptr<TComVPS> getVPS(Int vpsId)  { return m_vpsMap.getPS(vpsId); };
     1487  std::tr1::shared_ptr<TComVPS> getFirstVPS()      { return m_vpsMap.getFirstPS(); };
    14951488 
    14961489  //! store sequence parameter set and take ownership of it
    1497   Void storeSPS(TComSPS *sps) { m_spsMap.storePS( sps->getSPSId(), sps); };
     1490  Void storeSPS(const std::tr1::shared_ptr<TComSPS> &sps) { m_spsMap.storePS( sps->getSPSId(), sps); };
    14981491  //! get pointer to existing sequence parameter set 
    1499   TComSPS* getSPS(Int spsId)  { return m_spsMap.getPS(spsId); };
    1500   TComSPS* getFirstSPS()      { return m_spsMap.getFirstPS(); };
     1492  std::tr1::shared_ptr<TComSPS> getSPS(Int spsId)  { return m_spsMap.getPS(spsId); };
     1493  std::tr1::shared_ptr<TComSPS> getFirstSPS()      { return m_spsMap.getFirstPS(); };
    15011494
    15021495  //! store picture parameter set and take ownership of it
    1503   Void storePPS(TComPPS *pps) { m_ppsMap.storePS( pps->getPPSId(), pps); };
     1496  Void storePPS(const std::tr1::shared_ptr<TComPPS> &pps) { m_ppsMap.storePS( pps->getPPSId(), pps); };
    15041497  //! get pointer to existing picture parameter set 
    1505   TComPPS* getPPS(Int ppsId)  { return m_ppsMap.getPS(ppsId); };
    1506   TComPPS* getFirstPPS()      { return m_ppsMap.getFirstPS(); };
     1498  std::tr1::shared_ptr<TComPPS> getPPS(Int ppsId)  { return m_ppsMap.getPS(ppsId); };
     1499  std::tr1::shared_ptr<TComPPS> getFirstPPS()      { return m_ppsMap.getFirstPS(); };
    15071500
    15081501  //! activate a SPS from a active parameter sets SEI message
    15091502  //! \returns true, if activation is successful
    … …  
    15131506  //! \returns true, if activation is successful
    15141507  Bool activatePPS(Int ppsId, Bool isIRAP);
    15151508
    1516   TComVPS* getActiveVPS(){ return m_vpsMap.getPS(m_activeVPSId); };
    1517   TComSPS* getActiveSPS(){ return m_spsMap.getPS(m_activeSPSId); };
    1518   TComPPS* getActivePPS(){ return m_ppsMap.getPS(m_activePPSId); };
     1509  std::tr1::shared_ptr<TComVPS> getActiveVPS(){ return m_vpsMap.getPS(m_activeVPSId); };
     1510  std::tr1::shared_ptr<TComSPS> getActiveSPS(){ return m_spsMap.getPS(m_activeSPSId); };
     1511  std::tr1::shared_ptr<TComPPS> getActivePPS(){ return m_ppsMap.getPS(m_activePPSId); };
    15191512
    15201513protected:
    15211514 

  • source/Lib/TLibCommon/TComWeightPrediction.cpp

     
    273273  assert(iRefIdx0 >= 0 || iRefIdx1 >= 0);
    274274 
    275275  TComSlice*      pcSlice       = pcCU->getSlice();
    276   TComPPS*        pps           = pcCU->getSlice()->getPPS();
     276  std::tr1::shared_ptr<TComPPS>        pps           = pcCU->getSlice()->getPPS();
    277277  Bool            wpBiPred = pps->getWPBiPred();
    278278  wpScalingParam* pwp;
    279279  Bool            bBiDir        = (iRefIdx0>=0 && iRefIdx1>=0);
    … …  
    350350Void TComWeightPrediction::xWeightedPredictionBi( TComDataCU* pcCU, TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, Int iRefIdx0, Int iRefIdx1, UInt uiPartIdx, Int iWidth, Int iHeight, TComYuv* rpcYuvDst )
    351351{
    352352  wpScalingParam  *pwp0, *pwp1;
    353   TComPPS         *pps = pcCU->getSlice()->getPPS();
     353  std::tr1::shared_ptr<TComPPS>         pps = pcCU->getSlice()->getPPS();
    354354  assert( pps->getWPBiPred());
    355355
    356356  getWpScaling(pcCU, iRefIdx0, iRefIdx1, pwp0, pwp1);

  • source/Lib/TLibCommon/TComSlice.cpp

     
    6565, m_iSliceQpDeltaCr               ( 0 )
    6666, m_iDepth                        ( 0 )
    6767, m_bRefenced                     ( false )
    68 , m_pcSPS                         ( NULL )
    69 , m_pcPPS                         ( NULL )
     68, m_pcSPS                         ( )
     69, m_pcPPS                         ( )
    7070, m_pcPic                         ( NULL )
    7171, m_colFromL0Flag                 ( 1 )
    7272, m_colRefIdx                     ( 0 )
    … …  
    13991399, m_useDQP                      (false)
    14001400, m_bConstrainedIntraPred       (false)
    14011401, m_bSliceChromaQpFlag          (false)
    1402 , m_pcSPS                       (NULL)
     1402, m_pcSPS                       ()
    14031403, m_uiMaxCuDQPDepth             (0)
    14041404, m_uiMinCuDQPSize              (0)
    14051405, m_chromaCbQpOffset            (0)
    … …  
    18811881//! \returns true, if activation is successful
    18821882Bool ParameterSetManager::activateSPSWithSEI(Int spsId)
    18831883{
    1884   TComSPS *sps = m_spsMap.getPS(spsId);
     1884  std::tr1::shared_ptr<TComSPS> sps = m_spsMap.getPS(spsId);
    18851885  if (sps)
    18861886  {
    18871887    Int vpsId = sps->getVPSId();
    … …  
    19071907//! \returns true, if activation is successful
    19081908Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP)
    19091909{
    1910   TComPPS *pps = m_ppsMap.getPS(ppsId);
     1910  std::tr1::shared_ptr<TComPPS> pps = m_ppsMap.getPS(ppsId);
    19111911  if (pps)
    19121912  {
    19131913    Int spsId = pps->getSPSId();
    … …  
    19161916      printf("Warning: tried to activate PPS referring to a inactive SPS at non-IRAP.");
    19171917      return false;
    19181918    }
    1919     TComSPS *sps = m_spsMap.getPS(spsId);
     1919    std::tr1::shared_ptr<TComSPS> sps = m_spsMap.getPS(spsId);
    19201920    if (sps)
    19211921    {
    19221922      Int vpsId = sps->getVPSId();

  • source/Lib/TLibEncoder/TEncGOP.h

     
    155155
    156156  Double xCalculateRVM();
    157157
    158   SEIActiveParameterSets* xCreateSEIActiveParameterSets (TComSPS *sps);
     158  SEIActiveParameterSets* xCreateSEIActiveParameterSets (const std::tr1::shared_ptr<TComSPS> &sps);
    159159  SEIFramePacking*        xCreateSEIFramePacking();
    160160  SEIDisplayOrientation*  xCreateSEIDisplayOrientation();
    161161
    162162  SEIToneMappingInfo*     xCreateSEIToneMappingInfo();
    163163
    164   Void xCreateLeadingSEIMessages (/*SEIMessages seiMessages,*/ AccessUnit &accessUnit, TComSPS *sps);
     164  Void xCreateLeadingSEIMessages (/*SEIMessages seiMessages,*/ AccessUnit &accessUnit, const std::tr1::shared_ptr<TComSPS> &sps);
    165165  Int xGetFirstSeiLocation (AccessUnit &accessUnit);
    166166  Void xResetNonNestedSEIPresentFlags()
    167167  {

  • source/Lib/TLibEncoder/TEncCavlc.h

     
    6868  TComSlice*    m_pcSlice;
    6969  UInt          m_uiCoeffCost;
    7070
    71   Void codeShortTermRefPicSet              ( TComSPS* pcSPS, TComReferencePictureSet* pcRPS, Bool calledFromSliceHeader, Int idx );
     71  Void codeShortTermRefPicSet              ( const std::tr1::shared_ptr<TComSPS> &pcSPS, TComReferencePictureSet* pcRPS, Bool calledFromSliceHeader, Int idx );
    7272  Bool findMatchingLTRP ( TComSlice* pcSlice, UInt *ltrpsIndex, Int ltrpPOC, Bool usedFlag );
    7373 
    7474public:
    … …  
    8282  Void  resetCoeffCost        ()                { m_uiCoeffCost = 0;  }
    8383  UInt  getNumberOfWrittenBits()                { return  m_pcBitIf->getNumberOfWrittenBits();  }
    8484  UInt  getCoeffCost          ()                { return  m_uiCoeffCost;  }
    85   Void  codeVPS                 ( TComVPS* pcVPS );
    86   Void  codeVUI                 ( TComVUI *pcVUI, TComSPS* pcSPS );
    87   Void  codeSPS                 ( TComSPS* pcSPS );
    88   Void  codePPS                 ( TComPPS* pcPPS );
     85  Void  codeVPS                 ( const std::tr1::shared_ptr<TComVPS> &pcVPS );
     86  Void  codeVUI                 ( TComVUI *pcVUI, const std::tr1::shared_ptr<TComSPS> &pcSPS );
     87  Void  codeSPS                 ( const std::tr1::shared_ptr<TComSPS> &pcSPS );
     88  Void  codePPS                 ( const std::tr1::shared_ptr<TComPPS> &pcPPS );
    8989  Void  codeSliceHeader         ( TComSlice* pcSlice );
    9090  Void  codePTL                 ( TComPTL* pcPTL, Bool profilePresentFlag, Int maxNumSubLayersMinus1);
    9191  Void  codeProfileTier         ( ProfileTierLevel* ptl );

  • source/Lib/TLibEncoder/TEncEntropy.cpp

     
    8080  m_pcEntropyCoderIf->codeSliceFinish();
    8181}
    8282
    83 Void TEncEntropy::encodePPS( TComPPS* pcPPS )
     83Void TEncEntropy::encodePPS( const std::tr1::shared_ptr<TComPPS> &pcPPS )
    8484{
    8585  m_pcEntropyCoderIf->codePPS( pcPPS );
    8686  return;
    8787}
    8888
    89 Void TEncEntropy::encodeSPS( TComSPS* pcSPS )
     89Void TEncEntropy::encodeSPS( const std::tr1::shared_ptr<TComSPS> &pcSPS )
    9090{
    9191  m_pcEntropyCoderIf->codeSPS( pcSPS );
    9292  return;
    … …  
    101101  m_pcEntropyCoderIf->codeCUTransquantBypassFlag( pcCU, uiAbsPartIdx );
    102102}
    103103
    104 Void TEncEntropy::encodeVPS( TComVPS* pcVPS )
     104Void TEncEntropy::encodeVPS( const std::tr1::shared_ptr<TComVPS> &pcVPS )
    105105{
    106106  m_pcEntropyCoderIf->codeVPS( pcVPS );
    107107  return;

  • source/Lib/TLibEncoder/TEncCfg.h

     
    289289#endif
    290290  Bool      m_TransquantBypassEnableFlag;                     ///< transquant_bypass_enable_flag setting in PPS.
    291291  Bool      m_CUTransquantBypassFlagValue;                    ///< if transquant_bypass_enable_flag, the fixed value to use for the per-CU cu_transquant_bypass_flag.
    292   TComVPS                    m_cVPS;
     292  std::tr1::shared_ptr<TComVPS>                    m_cVPS;
    293293  Bool      m_recalculateQPAccordingToLambda;                 ///< recalculate QP value according to the lambda value
    294294  Int       m_activeParameterSetsSEIEnabled;                  ///< enable active parameter set SEI message
    295295  Bool      m_vuiParametersPresentFlag;                       ///< enable generation of VUI parameters
    … …  
    689689  Void      setTransquantBypassEnableFlag(Bool flag)  { m_TransquantBypassEnableFlag = flag; }
    690690  Bool      getCUTransquantBypassFlagValue()          { return m_CUTransquantBypassFlagValue; }
    691691  Void      setCUTransquantBypassFlagValue(Bool flag) { m_CUTransquantBypassFlagValue = flag; }
    692   Void setVPS(TComVPS *p) { m_cVPS = *p; }
    693   TComVPS *getVPS() { return &m_cVPS; }
     692  Void setVPS(const std::tr1::shared_ptr<TComVPS> &p) { m_cVPS = p; }
     693  std::tr1::shared_ptr<TComVPS> getVPS() { return m_cVPS; }
    694694  Void      setUseRecalculateQPAccordingToLambda ( Bool b ) { m_recalculateQPAccordingToLambda = b;    }
    695695  Bool      getUseRecalculateQPAccordingToLambda ()         { return m_recalculateQPAccordingToLambda; }
    696696

  • source/Lib/TLibEncoder/TEncSlice.h

     
    112112 
    113113  /// preparation of slice encoding (reference marking, QP and lambda)
    114114  Void    initEncSlice        ( TComPic*  pcPic, Int pocLast, Int pocCurr, Int iNumPicRcvd,
    115                                 Int iGOPid,   TComSlice*& rpcSlice, TComSPS* pSPS, TComPPS *pPPS );
     115                                Int iGOPid,   TComSlice*& rpcSlice, const std::tr1::shared_ptr<TComSPS> &pSPS, const std::tr1::shared_ptr<TComPPS> &pPPS );
    116116#if RATE_CONTROL_LAMBDA_DOMAIN
    117117  Void    resetQP             ( TComPic* pic, Int sliceQP, Double lambda );
    118118#else
    119   Void    xLamdaRecalculation ( Int changeQP, Int idGOP, Int depth, SliceType eSliceType, TComSPS* pcSPS, TComSlice* pcSlice);
     119  Void    xLamdaRecalculation ( Int changeQP, Int idGOP, Int depth, SliceType eSliceType, const std::tr1::shared_ptr<TComSPS> &pcSPS, TComSlice* pcSlice);
    120120#endif
    121121  // compress and encode slice
    122122  Void    precompressSlice    ( TComPic*& rpcPic                                );      ///< precompress slice for multi-loop opt.

  • source/Lib/TLibEncoder/TEncSearch.cpp

     
    58975897  }
    58985898
    58995899  TComSlice       *pcSlice  = pcCU->getSlice();
    5900   TComPPS         *pps      = pcCU->getSlice()->getPPS();
     5900  std::tr1::shared_ptr<TComPPS>         pps      = pcCU->getSlice()->getPPS();
    59015901  wpScalingParam  *wp0 , *wp1;
    59025902  m_cDistParam.bApplyWeight = ( pcSlice->getSliceType()==P_SLICE && pps->getUseWP() ) || ( pcSlice->getSliceType()==B_SLICE && pps->getWPBiPred() ) ;
    59035903  if ( !m_cDistParam.bApplyWeight ) return;

  • source/Lib/TLibEncoder/TEncSampleAdaptiveOffset.cpp

     
    10001000{
    10011001  Int x,y;
    10021002  TComDataCU *pTmpCu = m_pcPic->getCU(iAddr);
    1003   TComSPS *pTmpSPS =  m_pcPic->getSlice(0)->getSPS();
     1003  std::tr1::shared_ptr<TComSPS> pTmpSPS =  m_pcPic->getSlice(0)->getSPS();
    10041004
    10051005  Pel* pOrg;
    10061006  Pel* pRec;
    … …  
    12651265{
    12661266  Int addr, yCbCr;
    12671267  Int x,y;
    1268   TComSPS *pTmpSPS =  pcPic->getSlice(0)->getSPS();
     1268  std::tr1::shared_ptr<TComSPS> pTmpSPS =  pcPic->getSlice(0)->getSPS();
    12691269
    12701270  Pel* pOrg;
    12711271  Pel* pRec;

  • source/Lib/TLibEncoder/TEncTop.h

     
    9393  TEncSlice               m_cSliceEncoder;                ///< slice encoder
    9494  TEncCu                  m_cCuEncoder;                   ///< CU encoder
    9595  // SPS
    96   TComSPS                m_cSPS;                         ///< SPS
    97   TComPPS                m_cPPS;                         ///< PPS
     96  std::tr1::shared_ptr<TComSPS> m_cSPS;                         ///< SPS
     97  std::tr1::shared_ptr<TComPPS> m_cPPS;                         ///< PPS
    9898  // RD cost computation
    9999  TComBitCounter          m_cBitCounter;                  ///< bit counter for RD optimization
    100100  TComRdCost              m_cRdCost;                      ///< RD cost computation class
    … …  
    169169  TEncSbac****            getRDSbacCoders       () { return  m_ppppcRDSbacCoders;     }
    170170  TEncSbac*               getRDGoOnSbacCoders   () { return  m_pcRDGoOnSbacCoders;   }
    171171  TEncRateCtrl*           getRateCtrl           () { return &m_cRateCtrl;             }
    172   TComSPS*                getSPS                () { return  &m_cSPS;                 }
    173   TComPPS*                getPPS                () { return  &m_cPPS;                 }
     172  std::tr1::shared_ptr<TComSPS>                getSPS                () { return  m_cSPS;                 }
     173  std::tr1::shared_ptr<TComPPS>                getPPS                () { return  m_cPPS;                 }
    174174  Void selectReferencePictureSet(TComSlice* slice, Int POCCurr, Int GOPid );
    175175  Int getReferencePictureSetIdxForSOP(TComSlice* slice, Int POCCurr, Int GOPid );
    176176  TComScalingList*        getScalingList        () { return  &m_scalingList;         }

  • source/Lib/TLibEncoder/TEncSbac.cpp

     
    239239  m_pcBinIf->start();
    240240}
    241241
    242 Void TEncSbac::codeVPS( TComVPS* pcVPS )
     242Void TEncSbac::codeVPS( const std::tr1::shared_ptr<TComVPS> &pcVPS )
    243243{
    244244  assert (0);
    245245  return;
    246246}
    247247
    248 Void TEncSbac::codeSPS( TComSPS* pcSPS )
     248Void TEncSbac::codeSPS( const std::tr1::shared_ptr<TComSPS> &pcSPS )
    249249{
    250250  assert (0);
    251251  return;
    252252}
    253253
    254 Void TEncSbac::codePPS( TComPPS* pcPPS )
     254Void TEncSbac::codePPS( const std::tr1::shared_ptr<TComPPS> &pcPPS )
    255255{
    256256  assert (0);
    257257  return;

  • source/Lib/TLibEncoder/TEncGOP.cpp

     
    136136
    137137}
    138138
    139 SEIActiveParameterSets* TEncGOP::xCreateSEIActiveParameterSets (TComSPS *sps)
     139SEIActiveParameterSets* TEncGOP::xCreateSEIActiveParameterSets (const std::tr1::shared_ptr<TComSPS> &sps)
    140140{
    141141  SEIActiveParameterSets *seiActiveParameterSets = new SEIActiveParameterSets();
    142142  seiActiveParameterSets->activeVPSId = m_pcCfg->getVPS()->getVPSId();
    … …  
    269269  return seiToneMappingInfo;
    270270}
    271271
    272 Void TEncGOP::xCreateLeadingSEIMessages (/*SEIMessages seiMessages,*/ AccessUnit &accessUnit, TComSPS *sps)
     272Void TEncGOP::xCreateLeadingSEIMessages (/*SEIMessages seiMessages,*/ AccessUnit &accessUnit, const std::tr1::shared_ptr<TComSPS> &sps)
    273273{
    274274  OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
    275275

  • source/Lib/TLibEncoder/SEIwrite.h

     
    4646  SEIWriter() {};
    4747  virtual ~SEIWriter() {};
    4848
    49   void writeSEImessage(TComBitIf& bs, const SEI& sei, TComSPS *sps);
     49  void writeSEImessage(TComBitIf& bs, const SEI& sei, const std::tr1::shared_ptr<TComSPS> &sps);
    5050
    5151protected:
    52   Void xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, TComSPS *sps);
     52  Void xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, const std::tr1::shared_ptr<TComSPS> &sps);
    5353  Void xWriteSEIuserDataUnregistered(const SEIuserDataUnregistered &sei);
    5454  Void xWriteSEIActiveParameterSets(const SEIActiveParameterSets& sei);
    55   Void xWriteSEIDecodingUnitInfo(const SEIDecodingUnitInfo& sei, TComSPS *sps);
     55  Void xWriteSEIDecodingUnitInfo(const SEIDecodingUnitInfo& sei, const std::tr1::shared_ptr<TComSPS> &sps);
    5656  Void xWriteSEIDecodedPictureHash(const SEIDecodedPictureHash& sei);
    57   Void xWriteSEIBufferingPeriod(const SEIBufferingPeriod& sei, TComSPS *sps);
    58   Void xWriteSEIPictureTiming(const SEIPictureTiming& sei, TComSPS *sps);
    59   TComSPS *m_pSPS;
     57  Void xWriteSEIBufferingPeriod(const SEIBufferingPeriod& sei, const std::tr1::shared_ptr<TComSPS> &sps);
     58  Void xWriteSEIPictureTiming(const SEIPictureTiming& sei, const std::tr1::shared_ptr<TComSPS> &sps);
     59  std::tr1::shared_ptr<TComSPS> m_pSPS;
    6060  Void xWriteSEIRecoveryPoint(const SEIRecoveryPoint& sei);
    6161  Void xWriteSEIFramePacking(const SEIFramePacking& sei);
    6262  Void xWriteSEIDisplayOrientation(const SEIDisplayOrientation &sei);
    … …  
    6464  Void xWriteSEIGradualDecodingRefreshInfo(const SEIGradualDecodingRefreshInfo &sei);
    6565  Void xWriteSEIToneMappingInfo(const SEIToneMappingInfo& sei);
    6666  Void xWriteSEISOPDescription(const SEISOPDescription& sei);
    67   Void xWriteSEIScalableNesting(TComBitIf& bs, const SEIScalableNesting& sei, TComSPS *sps);
     67  Void xWriteSEIScalableNesting(TComBitIf& bs, const SEIScalableNesting& sei, const std::tr1::shared_ptr<TComSPS> &sps);
    6868  Void xWriteByteAlign();
    6969};
    7070

  • source/Lib/TLibEncoder/TEncCavlc.cpp

     
    4444
    4545#if ENC_DEC_TRACE
    4646
    47 Void  xTraceSPSHeader (TComSPS *pSPS)
     47Void  xTraceSPSHeader (const std::tr1::shared_ptr<TComSPS> &pSPS)
    4848{
    4949  fprintf( g_hTrace, "=========== Sequence Parameter Set ID: %d ===========\n", pSPS->getSPSId() );
    5050}
    5151
    52 Void  xTracePPSHeader (TComPPS *pPPS)
     52Void  xTracePPSHeader (const std::tr1::shared_ptr<TComPPS> &pPPS)
    5353{
    5454  fprintf( g_hTrace, "=========== Picture Parameter Set ID: %d ===========\n", pPPS->getPPSId() );
    5555}
    … …  
    9696  WRITE_SVLC(iCode, pSymbolName);
    9797}
    9898
    99 Void TEncCavlc::codeShortTermRefPicSet( TComSPS* pcSPS, TComReferencePictureSet* rps, Bool calledFromSliceHeader, Int idx)
     99Void TEncCavlc::codeShortTermRefPicSet( const std::tr1::shared_ptr<TComSPS> &pcSPS, TComReferencePictureSet* rps, Bool calledFromSliceHeader, Int idx)
    100100{
    101101#if PRINT_RPS_INFO
    102102  Int lastBits = getNumberOfWrittenBits();
    … …  
    153153}
    154154
    155155
    156 Void TEncCavlc::codePPS( TComPPS* pcPPS )
     156Void TEncCavlc::codePPS( const std::tr1::shared_ptr<TComPPS> &pcPPS )
    157157{
    158158#if ENC_DEC_TRACE 
    159159  xTracePPSHeader (pcPPS);
    … …  
    233233  WRITE_FLAG( 0, "pps_extension_flag" );
    234234}
    235235
    236 Void TEncCavlc::codeVUI( TComVUI *pcVUI, TComSPS* pcSPS )
     236Void TEncCavlc::codeVUI( TComVUI *pcVUI, const std::tr1::shared_ptr<TComSPS> &pcSPS )
    237237{
    238238#if ENC_DEC_TRACE
    239239  fprintf( g_hTrace, "----------- vui_parameters -----------\n");
    … …  
    392392  }
    393393}
    394394
    395 Void TEncCavlc::codeSPS( TComSPS* pcSPS )
     395Void TEncCavlc::codeSPS( const std::tr1::shared_ptr<TComSPS> &pcSPS )
    396396{
    397397#if ENC_DEC_TRACE 
    398398  xTraceSPSHeader (pcSPS);
    … …  
    507507  WRITE_FLAG( 0, "sps_extension_flag" );
    508508}
    509509
    510 Void TEncCavlc::codeVPS( TComVPS* pcVPS )
     510Void TEncCavlc::codeVPS( const std::tr1::shared_ptr<TComVPS> &pcVPS )
    511511{
    512512  WRITE_CODE( pcVPS->getVPSId(),                    4,        "vps_video_parameter_set_id" );
    513513  WRITE_CODE( 3,                                    2,        "vps_reserved_three_2bits" );

  • source/Lib/TLibEncoder/TEncSlice.cpp

     
    175175 \param pSPS          SPS associated with the slice
    176176 \param pPPS          PPS associated with the slice
    177177 */
    178 Void TEncSlice::initEncSlice( TComPic* pcPic, Int pocLast, Int pocCurr, Int iNumPicRcvd, Int iGOPid, TComSlice*& rpcSlice, TComSPS* pSPS, TComPPS *pPPS )
     178Void TEncSlice::initEncSlice( TComPic* pcPic, Int pocLast, Int pocCurr, Int iNumPicRcvd, Int iGOPid, TComSlice*& rpcSlice, const std::tr1::shared_ptr<TComSPS> &pSPS, const std::tr1::shared_ptr<TComPPS> &pPPS )
    179179{
    180180  Double dQP;
    181181  Double dLambda;
    … …  
    493493/**
    494494 - lambda re-computation based on rate control QP
    495495 */
    496 Void TEncSlice::xLamdaRecalculation(Int changeQP, Int idGOP, Int depth, SliceType eSliceType, TComSPS* pcSPS, TComSlice* pcSlice)
     496Void TEncSlice::xLamdaRecalculation(Int changeQP, Int idGOP, Int depth, SliceType eSliceType, const std::tr1::shared_ptr<TComSPS> &pcSPS, TComSlice* pcSlice)
    497497{
    498498  Int qp;
    499499  Double recalQP= (Double)changeQP;

  • source/Lib/TLibEncoder/TEncTop.cpp

     
    209209  m_cGOPEncoder.        destroy();
    210210  m_cSliceEncoder.      destroy();
    211211  m_cCuEncoder.         destroy();
    212   if (m_cSPS.getUseSAO())
     212  if (m_cSPS->getUseSAO())
    213213  {
    214214    m_cEncSAO.destroy();
    215215    m_cEncSAO.destroyEncBuffer();
    … …  
    279279  xInitSPS();
    280280 
    281281  /* set the VPS profile information */
    282   *m_cVPS.getPTL() = *m_cSPS.getPTL();
    283   m_cVPS.getTimingInfo()->setTimingInfoPresentFlag       ( false );
     282  *m_cVPS->getPTL() = *m_cSPS->getPTL();
     283  m_cVPS->getTimingInfo()->setTimingInfoPresentFlag       ( false );
    284284  // initialize PPS
    285   m_cPPS.setSPS(&m_cSPS);
     285  m_cPPS->setSPS(m_cSPS);
    286286  xInitPPS();
    287287  xInitRPS();
    288288
    … …  
    418418    if ( getUseAdaptiveQP() )
    419419    {
    420420      TEncPic* pcEPic = new TEncPic;
    421       pcEPic->create( m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, m_cPPS.getMaxCuDQPDepth()+1 ,
     421      pcEPic->create( m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, m_cPPS->getMaxCuDQPDepth()+1 ,
    422422                      m_conformanceWindow, m_defaultDisplayWindow, m_numReorderPics);
    423423      rpcPic = pcEPic;
    424424    }
    … …  
    447447
    448448Void TEncTop::xInitSPS()
    449449{
    450   ProfileTierLevel& profileTierLevel = *m_cSPS.getPTL()->getGeneralPTL();
     450  ProfileTierLevel& profileTierLevel = *m_cSPS->getPTL()->getGeneralPTL();
    451451  profileTierLevel.setLevelIdc(m_level);
    452452  profileTierLevel.setTierFlag(m_levelTier);
    453453  profileTierLevel.setProfileIdc(m_profile);
    … …  
    471471  /* XXX: may be a good idea to refactor the above into a function
    472472   * that chooses the actual compatibility based upon options */
    473473
    474   m_cSPS.setPicWidthInLumaSamples         ( m_iSourceWidth      );
    475   m_cSPS.setPicHeightInLumaSamples        ( m_iSourceHeight     );
    476   m_cSPS.setConformanceWindow             ( m_conformanceWindow );
    477   m_cSPS.setMaxCUWidth    ( g_uiMaxCUWidth      );
    478   m_cSPS.setMaxCUHeight   ( g_uiMaxCUHeight     );
    479   m_cSPS.setMaxCUDepth    ( g_uiMaxCUDepth      );
     474  m_cSPS=std::tr1::shared_ptr<TComSPS>(new TComSPS());
     475  m_cSPS->setPicWidthInLumaSamples         ( m_iSourceWidth      );
     476  m_cSPS->setPicHeightInLumaSamples        ( m_iSourceHeight     );
     477  m_cSPS->setConformanceWindow             ( m_conformanceWindow );
     478  m_cSPS->setMaxCUWidth    ( g_uiMaxCUWidth      );
     479  m_cSPS->setMaxCUHeight   ( g_uiMaxCUHeight     );
     480  m_cSPS->setMaxCUDepth    ( g_uiMaxCUDepth      );
    480481
    481   Int minCUSize = m_cSPS.getMaxCUWidth() >> ( m_cSPS.getMaxCUDepth()-g_uiAddCUDepth );
     482  Int minCUSize = m_cSPS->getMaxCUWidth() >> ( m_cSPS->getMaxCUDepth()-g_uiAddCUDepth );
    482483  Int log2MinCUSize = 0;
    483484  while(minCUSize > 1)
    484485  {
    … …  
    486487    log2MinCUSize++;
    487488  }
    488489
    489   m_cSPS.setLog2MinCodingBlockSize(log2MinCUSize);
    490   m_cSPS.setLog2DiffMaxMinCodingBlockSize(m_cSPS.getMaxCUDepth()-g_uiAddCUDepth);
     490  m_cSPS->setLog2MinCodingBlockSize(log2MinCUSize);
     491  m_cSPS->setLog2DiffMaxMinCodingBlockSize(m_cSPS->getMaxCUDepth()-g_uiAddCUDepth);
    491492 
    492   m_cSPS.setPCMLog2MinSize (m_uiPCMLog2MinSize);
    493   m_cSPS.setUsePCM        ( m_usePCM           );
    494   m_cSPS.setPCMLog2MaxSize( m_pcmLog2MaxSize  );
     493  m_cSPS->setPCMLog2MinSize (m_uiPCMLog2MinSize);
     494  m_cSPS->setUsePCM        ( m_usePCM           );
     495  m_cSPS->setPCMLog2MaxSize( m_pcmLog2MaxSize  );
    495496
    496   m_cSPS.setQuadtreeTULog2MaxSize( m_uiQuadtreeTULog2MaxSize );
    497   m_cSPS.setQuadtreeTULog2MinSize( m_uiQuadtreeTULog2MinSize );
    498   m_cSPS.setQuadtreeTUMaxDepthInter( m_uiQuadtreeTUMaxDepthInter    );
    499   m_cSPS.setQuadtreeTUMaxDepthIntra( m_uiQuadtreeTUMaxDepthIntra    );
     497  m_cSPS->setQuadtreeTULog2MaxSize( m_uiQuadtreeTULog2MaxSize );
     498  m_cSPS->setQuadtreeTULog2MinSize( m_uiQuadtreeTULog2MinSize );
     499  m_cSPS->setQuadtreeTUMaxDepthInter( m_uiQuadtreeTUMaxDepthInter    );
     500  m_cSPS->setQuadtreeTUMaxDepthIntra( m_uiQuadtreeTUMaxDepthIntra    );
    500501 
    501   m_cSPS.setTMVPFlagsPresent(false);
    502   m_cSPS.setUseLossless   ( m_useLossless  );
     502  m_cSPS->setTMVPFlagsPresent(false);
     503  m_cSPS->setUseLossless   ( m_useLossless  );
    503504
    504   m_cSPS.setMaxTrSize   ( 1 << m_uiQuadtreeTULog2MaxSize );
     505  m_cSPS->setMaxTrSize   ( 1 << m_uiQuadtreeTULog2MaxSize );
    505506 
    506507  Int i;
    507508 
    508509  for (i = 0; i < g_uiMaxCUDepth-g_uiAddCUDepth; i++ )
    509510  {
    510     m_cSPS.setAMPAcc( i, m_useAMP );
    511     //m_cSPS.setAMPAcc( i, 1 );
     511    m_cSPS->setAMPAcc( i, m_useAMP );
     512    //m_cSPS->setAMPAcc( i, 1 );
    512513  }
    513514
    514   m_cSPS.setUseAMP ( m_useAMP );
     515  m_cSPS->setUseAMP ( m_useAMP );
    515516
    516517  for (i = g_uiMaxCUDepth-g_uiAddCUDepth; i < g_uiMaxCUDepth; i++ )
    517518  {
    518     m_cSPS.setAMPAcc(i, 0);
     519    m_cSPS->setAMPAcc(i, 0);
    519520  }
    520521
    521   m_cSPS.setBitDepthY( g_bitDepthY );
    522   m_cSPS.setBitDepthC( g_bitDepthC );
     522  m_cSPS->setBitDepthY( g_bitDepthY );
     523  m_cSPS->setBitDepthC( g_bitDepthC );
    523524
    524   m_cSPS.setQpBDOffsetY ( 6*(g_bitDepthY - 8) );
    525   m_cSPS.setQpBDOffsetC ( 6*(g_bitDepthC - 8) );
     525  m_cSPS->setQpBDOffsetY ( 6*(g_bitDepthY - 8) );
     526  m_cSPS->setQpBDOffsetC ( 6*(g_bitDepthC - 8) );
    526527
    527   m_cSPS.setUseSAO( m_bUseSAO );
     528  m_cSPS->setUseSAO( m_bUseSAO );
    528529
    529   m_cSPS.setMaxTLayers( m_maxTempLayer );
    530   m_cSPS.setTemporalIdNestingFlag( ( m_maxTempLayer == 1 ) ? true : false );
    531   for ( i = 0; i < m_cSPS.getMaxTLayers(); i++ )
     530  m_cSPS->setMaxTLayers( m_maxTempLayer );
     531  m_cSPS->setTemporalIdNestingFlag( ( m_maxTempLayer == 1 ) ? true : false );
     532  for ( i = 0; i < m_cSPS->getMaxTLayers(); i++ )
    532533  {
    533     m_cSPS.setMaxDecPicBuffering(m_maxDecPicBuffering[i], i);
    534     m_cSPS.setNumReorderPics(m_numReorderPics[i], i);
     534    m_cSPS->setMaxDecPicBuffering(m_maxDecPicBuffering[i], i);
     535    m_cSPS->setNumReorderPics(m_numReorderPics[i], i);
    535536  }
    536   m_cSPS.setPCMBitDepthLuma (g_uiPCMBitDepthLuma);
    537   m_cSPS.setPCMBitDepthChroma (g_uiPCMBitDepthChroma);
    538   m_cSPS.setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag );
     537  m_cSPS->setPCMBitDepthLuma (g_uiPCMBitDepthLuma);
     538  m_cSPS->setPCMBitDepthChroma (g_uiPCMBitDepthChroma);
     539  m_cSPS->setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag );
    539540
    540   m_cSPS.setScalingListFlag ( (m_useScalingListId == 0) ? 0 : 1 );
     541  m_cSPS->setScalingListFlag ( (m_useScalingListId == 0) ? 0 : 1 );
    541542
    542   m_cSPS.setUseStrongIntraSmoothing( m_useStrongIntraSmoothing );
     543  m_cSPS->setUseStrongIntraSmoothing( m_useStrongIntraSmoothing );
    543544
    544   m_cSPS.setVuiParametersPresentFlag(getVuiParametersPresentFlag());
    545   if (m_cSPS.getVuiParametersPresentFlag())
     545  m_cSPS->setVuiParametersPresentFlag(getVuiParametersPresentFlag());
     546  if (m_cSPS->getVuiParametersPresentFlag())
    546547  {
    547     TComVUI* pcVUI = m_cSPS.getVuiParameters();
     548    TComVUI* pcVUI = m_cSPS->getVuiParameters();
    548549    pcVUI->setAspectRatioInfoPresentFlag(getAspectRatioIdc() != -1);
    549550    pcVUI->setAspectRatioIdc(getAspectRatioIdc());
    550551    pcVUI->setSarWidth(getSarWidth());
    … …  
    581582
    582583Void TEncTop::xInitPPS()
    583584{
    584   m_cPPS.setConstrainedIntraPred( m_bUseConstrainedIntraPred );
     585  m_cPPS=std::tr1::shared_ptr<TComPPS>(new TComPPS());
     586  m_cPPS->setConstrainedIntraPred( m_bUseConstrainedIntraPred );
    585587  Bool bUseDQP = (getMaxCuDQPDepth() > 0)? true : false;
    586588
    587   Int lowestQP = - m_cSPS.getQpBDOffsetY();
     589  Int lowestQP = - m_cSPS->getQpBDOffsetY();
    588590
    589591  if(getUseLossless())
    590592  {
    … …  
    610612
    611613  if(bUseDQP)
    612614  {
    613     m_cPPS.setUseDQP(true);
    614     m_cPPS.setMaxCuDQPDepth( m_iMaxCuDQPDepth );
    615     m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
     615    m_cPPS->setUseDQP(true);
     616    m_cPPS->setMaxCuDQPDepth( m_iMaxCuDQPDepth );
     617    m_cPPS->setMinCuDQPSize( m_cPPS->getSPS()->getMaxCUWidth() >> ( m_cPPS->getMaxCuDQPDepth()) );
    616618  }
    617619  else
    618620  {
    619     m_cPPS.setUseDQP(false);
    620     m_cPPS.setMaxCuDQPDepth( 0 );
    621     m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
     621    m_cPPS->setUseDQP(false);
     622    m_cPPS->setMaxCuDQPDepth( 0 );
     623    m_cPPS->setMinCuDQPSize( m_cPPS->getSPS()->getMaxCUWidth() >> ( m_cPPS->getMaxCuDQPDepth()) );
    622624  }
    623625
    624626#if RATE_CONTROL_LAMBDA_DOMAIN
    625627  if ( m_RCEnableRateControl )
    626628  {
    627     m_cPPS.setUseDQP(true);
    628     m_cPPS.setMaxCuDQPDepth( 0 );
    629     m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
     629    m_cPPS->setUseDQP(true);
     630    m_cPPS->setMaxCuDQPDepth( 0 );
     631    m_cPPS->setMinCuDQPSize( m_cPPS->getSPS()->getMaxCUWidth() >> ( m_cPPS->getMaxCuDQPDepth()) );
    630632  }
    631633#endif
    632634
    633   m_cPPS.setChromaCbQpOffset( m_chromaCbQpOffset );
    634   m_cPPS.setChromaCrQpOffset( m_chromaCrQpOffset );
     635  m_cPPS->setChromaCbQpOffset( m_chromaCbQpOffset );
     636  m_cPPS->setChromaCrQpOffset( m_chromaCrQpOffset );
    635637
    636   m_cPPS.setNumSubstreams(m_iWaveFrontSubstreams);
    637   m_cPPS.setEntropyCodingSyncEnabledFlag( m_iWaveFrontSynchro > 0 );
    638   m_cPPS.setTilesEnabledFlag( (m_iNumColumnsMinus1 > 0 || m_iNumRowsMinus1 > 0) );
    639   m_cPPS.setUseWP( m_useWeightedPred );
    640   m_cPPS.setWPBiPred( m_useWeightedBiPred );
    641   m_cPPS.setOutputFlagPresentFlag( false );
    642   m_cPPS.setSignHideFlag(getSignHideFlag());
     638  m_cPPS->setNumSubstreams(m_iWaveFrontSubstreams);
     639  m_cPPS->setEntropyCodingSyncEnabledFlag( m_iWaveFrontSynchro > 0 );
     640  m_cPPS->setTilesEnabledFlag( (m_iNumColumnsMinus1 > 0 || m_iNumRowsMinus1 > 0) );
     641  m_cPPS->setUseWP( m_useWeightedPred );
     642  m_cPPS->setWPBiPred( m_useWeightedBiPred );
     643  m_cPPS->setOutputFlagPresentFlag( false );
     644  m_cPPS->setSignHideFlag(getSignHideFlag());
    643645  if ( getDeblockingFilterMetric() )
    644646  {
    645     m_cPPS.setDeblockingFilterControlPresentFlag (true);
    646     m_cPPS.setDeblockingFilterOverrideEnabledFlag(true);
    647     m_cPPS.setPicDisableDeblockingFilterFlag(false);
    648     m_cPPS.setDeblockingFilterBetaOffsetDiv2(0);
    649     m_cPPS.setDeblockingFilterTcOffsetDiv2(0);
     647    m_cPPS->setDeblockingFilterControlPresentFlag (true);
     648    m_cPPS->setDeblockingFilterOverrideEnabledFlag(true);
     649    m_cPPS->setPicDisableDeblockingFilterFlag(false);
     650    m_cPPS->setDeblockingFilterBetaOffsetDiv2(0);
     651    m_cPPS->setDeblockingFilterTcOffsetDiv2(0);
    650652  }
    651653  else
    652654  {
    653     m_cPPS.setDeblockingFilterControlPresentFlag (m_DeblockingFilterControlPresent );
     655    m_cPPS->setDeblockingFilterControlPresentFlag (m_DeblockingFilterControlPresent );
    654656  }
    655   m_cPPS.setLog2ParallelMergeLevelMinus2   (m_log2ParallelMergeLevelMinus2 );
    656   m_cPPS.setCabacInitPresentFlag(CABAC_INIT_PRESENT_FLAG);
    657   m_cPPS.setLoopFilterAcrossSlicesEnabledFlag( m_bLFCrossSliceBoundaryFlag );
     657  m_cPPS->setLog2ParallelMergeLevelMinus2   (m_log2ParallelMergeLevelMinus2 );
     658  m_cPPS->setCabacInitPresentFlag(CABAC_INIT_PRESENT_FLAG);
     659  m_cPPS->setLoopFilterAcrossSlicesEnabledFlag( m_bLFCrossSliceBoundaryFlag );
    658660  Int histogram[MAX_NUM_REF + 1];
    659661  for( Int i = 0; i <= MAX_NUM_REF; i++ )
    660662  {
    … …  
    676678    }
    677679  }
    678680  assert(bestPos <= 15);
    679   m_cPPS.setNumRefIdxL0DefaultActive(bestPos);
    680   m_cPPS.setNumRefIdxL1DefaultActive(bestPos);
    681   m_cPPS.setTransquantBypassEnableFlag(getTransquantBypassEnableFlag());
    682   m_cPPS.setUseTransformSkip( m_useTransformSkip );
     681  m_cPPS->setNumRefIdxL0DefaultActive(bestPos);
     682  m_cPPS->setNumRefIdxL1DefaultActive(bestPos);
     683  m_cPPS->setTransquantBypassEnableFlag(getTransquantBypassEnableFlag());
     684  m_cPPS->setUseTransformSkip( m_useTransformSkip );
    683685  if (m_sliceSegmentMode)
    684686  {
    685     m_cPPS.setDependentSliceSegmentsEnabledFlag( true );
     687    m_cPPS->setDependentSliceSegmentsEnabledFlag( true );
    686688  }
    687   if( m_cPPS.getDependentSliceSegmentsEnabledFlag() )
     689  if( m_cPPS->getDependentSliceSegmentsEnabledFlag() )
    688690  {
    689     Int NumCtx = m_cPPS.getEntropyCodingSyncEnabledFlag()?2:1;
     691    Int NumCtx = m_cPPS->getEntropyCodingSyncEnabledFlag()?2:1;
    690692    m_cSliceEncoder.initCtxMem( NumCtx );
    691693    for ( UInt st = 0; st < NumCtx; st++ )
    692694    {
    … …  
    703705{
    704706  TComReferencePictureSet*      rps;
    705707 
    706   m_cSPS.createRPSList(getGOPSize()+m_extraRPSs);
    707   TComRPSList* rpsList = m_cSPS.getRPSList();
     708  m_cSPS->createRPSList(getGOPSize()+m_extraRPSs);
     709  TComRPSList* rpsList = m_cSPS->getRPSList();
    708710
    709711  for( Int i = 0; i < getGOPSize()+m_extraRPSs; i++)
    710712  {
    … …  
    940942
    941943Void  TEncTop::xInitPPSforTiles()
    942944{
    943   m_cPPS.setUniformSpacingFlag( m_iUniformSpacingIdr );
    944   m_cPPS.setNumColumnsMinus1( m_iNumColumnsMinus1 );
    945   m_cPPS.setNumRowsMinus1( m_iNumRowsMinus1 );
     945  m_cPPS->setUniformSpacingFlag( m_iUniformSpacingIdr );
     946  m_cPPS->setNumColumnsMinus1( m_iNumColumnsMinus1 );
     947  m_cPPS->setNumRowsMinus1( m_iNumRowsMinus1 );
    946948  if( m_iUniformSpacingIdr == 0 )
    947949  {
    948     m_cPPS.setColumnWidth( m_puiColumnWidth );
    949     m_cPPS.setRowHeight( m_puiRowHeight );
     950    m_cPPS->setColumnWidth( m_puiColumnWidth );
     951    m_cPPS->setRowHeight( m_puiRowHeight );
    950952  }
    951   m_cPPS.setLoopFilterAcrossTilesEnabledFlag( m_loopFilterAcrossTilesEnabledFlag );
     953  m_cPPS->setLoopFilterAcrossTilesEnabledFlag( m_loopFilterAcrossTilesEnabledFlag );
    952954
    953955  // # substreams is "per tile" when tiles are independent.
    954956  if (m_iWaveFrontSynchro
    955957    )
    956958  {
    957     m_cPPS.setNumSubstreams(m_iWaveFrontSubstreams * (m_iNumColumnsMinus1+1));
     959    m_cPPS->setNumSubstreams(m_iWaveFrontSubstreams * (m_iNumColumnsMinus1+1));
    958960  }
    959961}
    960962

  • source/Lib/TLibEncoder/TEncEntropy.h

     
    6767  virtual UInt  getNumberOfWrittenBits()                = 0;
    6868  virtual UInt  getCoeffCost          ()                = 0;
    6969
    70   virtual Void  codeVPS                 ( TComVPS* pcVPS )                                      = 0;
    71   virtual Void  codeSPS                 ( TComSPS* pcSPS )                                      = 0;
    72   virtual Void  codePPS                 ( TComPPS* pcPPS )                                      = 0;
     70  virtual Void  codeVPS                 ( const std::tr1::shared_ptr<TComVPS> &pcVPS )                                      = 0;
     71  virtual Void  codeSPS                 ( const std::tr1::shared_ptr<TComSPS> &pcSPS )                                      = 0;
     72  virtual Void  codePPS                 ( const std::tr1::shared_ptr<TComPPS> &pcPPS )                                      = 0;
    7373  virtual Void  codeSliceHeader         ( TComSlice* pcSlice )                                  = 0;
    7474
    7575  virtual Void  codeTilesWPPEntryPoint  ( TComSlice* pSlice )     = 0;
    … …  
    146146  TEncEntropyIf*      m_pcEntropyCoderIf;
    147147 
    148148public:
    149   Void encodeVPS               ( TComVPS* pcVPS);
     149  Void encodeVPS               ( const std::tr1::shared_ptr<TComVPS> &pcVPS);
    150150  // SPS
    151   Void encodeSPS               ( TComSPS* pcSPS );
    152   Void encodePPS               ( TComPPS* pcPPS );
     151  Void encodeSPS               ( const std::tr1::shared_ptr<TComSPS> &pcSPS );
     152  Void encodePPS               ( const std::tr1::shared_ptr<TComPPS> &pcPPS );
    153153  Void encodeSplitFlag         ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, Bool bRD = false );
    154154  Void encodeCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
    155155  Void encodeSkipFlag          ( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );

  • source/Lib/TLibEncoder/TEncSbac.h

     
    8989  UInt  getNumberOfWrittenBits ()                { return m_pcBinIf->getNumWrittenBits(); }
    9090  //--SBAC RD
    9191
    92   Void  codeVPS                 ( TComVPS* pcVPS );
    93   Void  codeSPS                 ( TComSPS* pcSPS     );
    94   Void  codePPS                 ( TComPPS* pcPPS     );
     92  Void  codeVPS                 ( const std::tr1::shared_ptr<TComVPS> &pcVPS );
     93  Void  codeSPS                 ( const std::tr1::shared_ptr<TComSPS> &pcSPS     );
     94  Void  codePPS                 ( const std::tr1::shared_ptr<TComPPS> &pcPPS     );
    9595  Void  codeSliceHeader         ( TComSlice* pcSlice );
    9696  Void  codeTilesWPPEntryPoint( TComSlice* pSlice );
    9797  Void  codeTerminatingBit      ( UInt uilsLast      );

  • source/Lib/TLibEncoder/SEIwrite.cpp

     
    9999}
    100100#endif
    101101
    102 void SEIWriter::xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, TComSPS *sps)
     102void SEIWriter::xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, const std::tr1::shared_ptr<TComSPS> &sps)
    103103{
    104104  switch (sei.payloadType())
    105105  {
    … …  
    154154 * marshal a single SEI message sei, storing the marshalled representation
    155155 * in bitstream bs.
    156156 */
    157 Void SEIWriter::writeSEImessage(TComBitIf& bs, const SEI& sei, TComSPS *sps)
     157Void SEIWriter::writeSEImessage(TComBitIf& bs, const SEI& sei, const std::tr1::shared_ptr<TComSPS> &sps)
    158158{
    159159  /* calculate how large the payload data is */
    160160  /* TODO: this would be far nicer if it used vectored buffers */
    … …  
    281281  }
    282282}
    283283
    284 Void SEIWriter::xWriteSEIDecodingUnitInfo(const SEIDecodingUnitInfo& sei, TComSPS *sps)
     284Void SEIWriter::xWriteSEIDecodingUnitInfo(const SEIDecodingUnitInfo& sei, const std::tr1::shared_ptr<TComSPS> &sps)
    285285{
    286286  TComVUI *vui = sps->getVuiParameters();
    287287  WRITE_UVLC(sei.m_decodingUnitIdx, "decoding_unit_idx");
    … …  
    297297  xWriteByteAlign();
    298298}
    299299
    300 Void SEIWriter::xWriteSEIBufferingPeriod(const SEIBufferingPeriod& sei, TComSPS *sps)
     300Void SEIWriter::xWriteSEIBufferingPeriod(const SEIBufferingPeriod& sei, const std::tr1::shared_ptr<TComSPS> &sps)
    301301{
    302302  Int i, nalOrVcl;
    303303  TComVUI *vui = sps->getVuiParameters();
    … …  
    334334  }
    335335  xWriteByteAlign();
    336336}
    337 Void SEIWriter::xWriteSEIPictureTiming(const SEIPictureTiming& sei,  TComSPS *sps)
     337Void SEIWriter::xWriteSEIPictureTiming(const SEIPictureTiming& sei,  const std::tr1::shared_ptr<TComSPS> &sps)
    338338{
    339339  Int i;
    340340  TComVUI *vui = sps->getVuiParameters();
    … …  
    536536  xWriteByteAlign();
    537537}
    538538
    539 Void SEIWriter::xWriteSEIScalableNesting(TComBitIf& bs, const SEIScalableNesting& sei, TComSPS *sps)
     539Void SEIWriter::xWriteSEIScalableNesting(TComBitIf& bs, const SEIScalableNesting& sei, const std::tr1::shared_ptr<TComSPS> &sps)
    540540{
    541541  WRITE_FLAG( sei.m_bitStreamSubsetFlag,             "bitstream_subset_flag"         );
    542542  WRITE_FLAG( sei.m_nestingOpFlag,                   "nesting_op_flag      "         );