Changeset 1319 in SHVCSoftware for branches/SHM-dev/source/Lib/TLibCommon


Ignore:
Timestamp:
21 Jul 2015, 23:31:40 (10 years ago)
Author:
seregin
Message:

port rev 4394

Location:
branches/SHM-dev/source/Lib/TLibCommon
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • branches/SHM-dev/source/Lib/TLibCommon/NAL.h

    r1262 r1319  
    5151  UInt        m_nuhLayerId;  ///< nuh_layer_id
    5252
     53  NALUnit(const NALUnit &src)
     54  :m_nalUnitType (src.m_nalUnitType)
     55  ,m_temporalId  (src.m_temporalId)
     56  ,m_nuhLayerId  (src.m_nuhLayerId)
     57  { }
    5358  /** construct an NALunit structure with given header values. */
    5459  NALUnit(
    … …  
    6166  {}
    6267
    63   /** default constructor - no initialization; must be perfomed by user */
     68  /** default constructor - no initialization; must be performed by user */
    6469  NALUnit() {}
     70
     71  virtual ~NALUnit() { }
    6572
    6673  /** returns true if the NALunit is a slice NALunit */

  • branches/SHM-dev/source/Lib/TLibCommon/TComBitStream.cpp

    r1260 r1319  
    6060}
    6161
    62 TComInputBitstream::TComInputBitstream(std::vector<uint8_t>* buf)
    63 {
    64   m_fifo = buf;
    65   m_fifo_idx = 0;
    66   m_held_bits = 0;
    67   m_num_held_bits = 0;
    68   m_numBitsRead = 0;
    69 }
    70 
    71 TComInputBitstream::~TComInputBitstream()
    72 {
    73 }
     62
     63TComInputBitstream::TComInputBitstream()
     64: m_fifo()
     65, m_emulationPreventionByteLocation()
     66, m_fifo_idx(0)
     67, m_num_held_bits(0)
     68, m_held_bits(0)
     69, m_numBitsRead(0)
     70{ }
     71
     72TComInputBitstream::TComInputBitstream(const TComInputBitstream &src)
     73: m_fifo(src.m_fifo)
     74, m_emulationPreventionByteLocation(src.m_emulationPreventionByteLocation)
     75, m_fifo_idx(src.m_fifo_idx)
     76, m_num_held_bits(src.m_num_held_bits)
     77, m_held_bits(src.m_held_bits)
     78, m_numBitsRead(src.m_numBitsRead)
     79{ }
    7480
    7581// ====================================================================================================================
    7682// Public member functions
    7783// ====================================================================================================================
     84
     85Void TComInputBitstream::resetToStart()
     86{
     87  m_fifo_idx=0;
     88  m_num_held_bits=0;
     89  m_held_bits=0;
     90  m_numBitsRead=0;
     91}
    7892
    7993Char* TComOutputBitstream::getByteStream() const
    … …  
    283297  UInt aligned_word = 0;
    284298  UInt num_bytes_to_load = (uiNumberOfBits - 1) >> 3;
    285   assert(m_fifo_idx + num_bytes_to_load < m_fifo->size());
     299  assert(m_fifo_idx + num_bytes_to_load < m_fifo.size());
    286300
    287301  switch (num_bytes_to_load)
    288302  {
    289   case 3: aligned_word  = (*m_fifo)[m_fifo_idx++] << 24;
    290   case 2: aligned_word |= (*m_fifo)[m_fifo_idx++] << 16;
    291   case 1: aligned_word |= (*m_fifo)[m_fifo_idx++] <<  8;
    292   case 0: aligned_word |= (*m_fifo)[m_fifo_idx++];
     303  case 3: aligned_word  = m_fifo[m_fifo_idx++] << 24;
     304  case 2: aligned_word |= m_fifo[m_fifo_idx++] << 16;
     305  case 1: aligned_word |= m_fifo[m_fifo_idx++] <<  8;
     306  case 0: aligned_word |= m_fifo[m_fifo_idx++];
    293307  }
    294308
    … …  
    351365{
    352366  UInt uiNumBytes = uiNumBits/8;
    353   std::vector<uint8_t>* buf = new std::vector<uint8_t>;
    354   UInt uiByte;
    355   for (UInt ui = 0; ui < uiNumBytes; ui++)
    356   {
    357     read(8, uiByte);
    358     buf->push_back(uiByte);
     367  TComInputBitstream *pResult = new TComInputBitstream;
     368
     369  std::vector<uint8_t> &buf = pResult->getFifo();
     370  buf.reserve((uiNumBits+7)>>3);
     371
     372  if (m_num_held_bits == 0)
     373  {
     374    std::size_t currentOutputBufferSize=buf.size();
     375    const UInt uiNumBytesToReadFromFifo = std::min<UInt>(uiNumBytes, m_fifo.size() - m_fifo_idx);
     376    buf.resize(currentOutputBufferSize+uiNumBytes);
     377    memcpy(&(buf[currentOutputBufferSize]), &(m_fifo[m_fifo_idx]), uiNumBytesToReadFromFifo); m_fifo_idx+=uiNumBytesToReadFromFifo;
     378    if (uiNumBytesToReadFromFifo != uiNumBytes)
     379    {
     380      memset(&(buf[currentOutputBufferSize+uiNumBytesToReadFromFifo]), 0, uiNumBytes - uiNumBytesToReadFromFifo);
     381    }
     382  }
     383  else
     384  {
     385    for (UInt ui = 0; ui < uiNumBytes; ui++)
     386    {
     387      UInt uiByte;
     388      read(8, uiByte);
     389      buf.push_back(uiByte);
     390    }
    359391  }
    360392  if (uiNumBits&0x7)
    361393  {
    362     uiByte = 0;
     394    UInt uiByte = 0;
    363395    read(uiNumBits&0x7, uiByte);
    364396    uiByte <<= 8-(uiNumBits&0x7);
    365     buf->push_back(uiByte);
    366   }
    367   return new TComInputBitstream(buf);
    368 }
    369 
    370 /**
    371  - delete internal fifo
    372  */
    373 Void TComInputBitstream::deleteFifo()
    374 {
    375   delete m_fifo;
    376   m_fifo = NULL;
     397    buf.push_back(uiByte);
     398  }
     399  return pResult;
    377400}
    378401

  • branches/SHM-dev/source/Lib/TLibCommon/TComBitStream.h

    r1262 r1319  
    163163class TComInputBitstream
    164164{
    165   std::vector<uint8_t> *m_fifo; /// FIFO for storage of complete bytes
    166   std::vector<UInt> m_emulationPreventionByteLocation;
    167 
    168165protected:
     166  std::vector<uint8_t> m_fifo; /// FIFO for storage of complete bytes
     167  std::vector<UInt>    m_emulationPreventionByteLocation;
     168
    169169  UInt m_fifo_idx; /// Read index into m_fifo
    170170
    … …  
    175175public:
    176176  /**
    177    * Create a new bitstream reader object that reads from buf.  Ownership
    178    * of buf remains with the callee, although the constructed object
    179    * will hold a reference to buf
    180    */
    181   TComInputBitstream(std::vector<uint8_t>* buf);
    182   ~TComInputBitstream();
     177   * Create a new bitstream reader object that reads from buf.
     178   */
     179  TComInputBitstream();
     180  virtual ~TComInputBitstream() { }
     181  TComInputBitstream(const TComInputBitstream &src);
     182
     183  Void resetToStart();
    183184
    184185  // interface for decoding
    … …  
    187188  Void        readByte        ( UInt &ruiBits )
    188189  {
    189     assert(m_fifo_idx < m_fifo->size());
    190     ruiBits = (*m_fifo)[m_fifo_idx++];
     190    assert(m_fifo_idx < m_fifo.size());
     191    ruiBits = m_fifo[m_fifo_idx++];
    191192  }
    192193
    … …  
    194195  {
    195196    assert(m_fifo_idx > 0);
    196     byte = (*m_fifo)[m_fifo_idx - 1];
     197    byte = m_fifo[m_fifo_idx - 1];
    197198  }
    198199
    … …  
    209210  UInt     readByte() { UInt tmp; readByte( tmp ); return tmp; }
    210211  UInt getNumBitsUntilByteAligned() { return m_num_held_bits & (0x7); }
    211   UInt getNumBitsLeft() { return 8*((UInt)m_fifo->size() - m_fifo_idx) + m_num_held_bits; }
     212  UInt getNumBitsLeft() { return 8*((UInt)m_fifo.size() - m_fifo_idx) + m_num_held_bits; }
    212213  TComInputBitstream *extractSubstream( UInt uiNumBits ); // Read the nominated number of bits, and return as a bitstream.
    213   Void                deleteFifo(); // Delete internal fifo of bitstream.
    214214  UInt  getNumBitsRead() { return m_numBitsRead; }
    215215  UInt readByteAlignment();
    216216
    217   Void      pushEmulationPreventionByteLocation ( UInt pos )                  { m_emulationPreventionByteLocation.push_back( pos ); }
    218   UInt      numEmulationPreventionBytesRead     ()                            { return (UInt) m_emulationPreventionByteLocation.size();    }
    219   std::vector<UInt>  getEmulationPreventionByteLocation  ()                   { return m_emulationPreventionByteLocation;           }
    220   UInt      getEmulationPreventionByteLocation  ( UInt idx )                  { return m_emulationPreventionByteLocation[ idx ];    }
    221   Void      clearEmulationPreventionByteLocation()                            { m_emulationPreventionByteLocation.clear();          }
    222   Void      setEmulationPreventionByteLocation  ( std::vector<UInt> vec )     { m_emulationPreventionByteLocation = vec;            }
    223 
    224   const std::vector<uint8_t> *getFifo() const { return m_fifo; }
     217  Void      pushEmulationPreventionByteLocation ( UInt pos )                         { m_emulationPreventionByteLocation.push_back( pos ); }
     218  UInt      numEmulationPreventionBytesRead     ()                                   { return (UInt) m_emulationPreventionByteLocation.size();    }
     219  const std::vector<UInt> &getEmulationPreventionByteLocation  () const              { return m_emulationPreventionByteLocation;           }
     220  UInt      getEmulationPreventionByteLocation  ( UInt idx )                         { return m_emulationPreventionByteLocation[ idx ];    }
     221  Void      clearEmulationPreventionByteLocation()                                   { m_emulationPreventionByteLocation.clear();          }
     222  Void      setEmulationPreventionByteLocation  ( const std::vector<UInt> &vec )     { m_emulationPreventionByteLocation = vec;            }
     223
     224  const std::vector<uint8_t> &getFifo() const { return m_fifo; }
     225        std::vector<uint8_t> &getFifo()       { return m_fifo; }
    225226};
    226227

  • branches/SHM-dev/source/Lib/TLibCommon/TComSlice.cpp

    r1316 r1319  
    5151ParameterSetMap<TComSPS> ParameterSetManager::m_spsMap(MAX_NUM_SPS);
    5252ParameterSetMap<TComPPS> ParameterSetManager::m_ppsMap(MAX_NUM_PPS);
    53 TComVPS ParameterSetManager::m_activeVPS;
     53Int ParameterSetManager::m_activeVPSId = -1;
    5454#endif
    5555
    … …  
    27902790ParameterSetManager::ParameterSetManager()
    27912791#if SVC_EXTENSION
    2792 : m_activeSPS()
     2792: m_activePPSId(-1)
    27932793#else
    27942794: m_vpsMap(MAX_NUM_VPS)
    27952795, m_spsMap(MAX_NUM_SPS)
    27962796, m_ppsMap(MAX_NUM_PPS)
    2797 , m_activeVPS()
    2798 , m_activeSPS()
    2799 #endif
    2800 {
    2801 #if !SVC_EXTENSION
    2802   m_activeVPS.setVPSId(-1);
    2803 #endif
    2804   m_activeSPS.setSPSId(-1);
     2797, m_activeVPSId(-1)
     2798#endif
     2799, m_activeSPSId(-1)
     2800{
    28052801}
    28062802
    … …  
    28122808//! activate a SPS from a active parameter sets SEI message
    28132809//! \returns true, if activation is successful
    2814 Bool ParameterSetManager::activateSPSWithSEI(Int spsId)
    2815 {
    2816   TComSPS *sps = m_spsMap.getPS(spsId);
    2817   if (sps)
    2818   {
    2819     Int vpsId = sps->getVPSId();
    2820     TComVPS *vps = m_vpsMap.getPS(vpsId);
    2821     if (vps)
    2822     {
    2823       m_activeVPS = *(vps);
    2824       m_activeSPS = *(sps);
    2825       return true;
    2826     }
    2827     else
    2828     {
    2829       printf("Warning: tried to activate SPS using an Active parameter sets SEI message. Referenced VPS does not exist.");
    2830     }
    2831   }
    2832   else
    2833   {
    2834     printf("Warning: tried to activate non-existing SPS using an Active parameter sets SEI message.");
    2835   }
    2836   return false;
    2837 }
     2810//Bool ParameterSetManager::activateSPSWithSEI(Int spsId)
     2811//{
     2812//  TComSPS *sps = m_spsMap.getPS(spsId);
     2813//  if (sps)
     2814//  {
     2815//    Int vpsId = sps->getVPSId();
     2816//    TComVPS *vps = m_vpsMap.getPS(vpsId);
     2817//    if (vps)
     2818//    {
     2819//      m_activeVPS = *(vps);
     2820//      m_activeSPS = *(sps);
     2821//      return true;
     2822//    }
     2823//    else
     2824//    {
     2825//      printf("Warning: tried to activate SPS using an Active parameter sets SEI message. Referenced VPS does not exist.");
     2826//    }
     2827//  }
     2828//  else
     2829//  {
     2830//    printf("Warning: tried to activate non-existing SPS using an Active parameter sets SEI message.");
     2831//  }
     2832//  return false;
     2833//}
    28382834
    28392835//! activate a PPS and depending on isIDR parameter also SPS and VPS
    … …  
    28442840  if (pps)
    28452841  {
     2842#if SVC_EXTENSION
     2843    m_activePPSId = ppsId;
     2844#endif
    28462845    Int spsId = pps->getSPSId();
    2847     if (!isIRAP && (spsId != m_activeSPS.getSPSId() ))
     2846    if (!isIRAP && (spsId != m_activeSPSId ))
    28482847    {
    28492848      printf("Warning: tried to activate PPS referring to a inactive SPS at non-IDR.");
    2850       return false;
    2851     }
    2852     TComSPS *sps = m_spsMap.getPS(spsId);
    2853     if (sps)
    2854     {
    2855       Int vpsId = sps->getVPSId();
    2856       if (!isIRAP && (vpsId != m_activeVPS.getVPSId() ))
    2857       {
    2858         printf("Warning: tried to activate PPS referring to a inactive VPS at non-IDR.");
    2859         return false;
    2860       }
    2861       TComVPS *vps =m_vpsMap.getPS(vpsId);
    2862       if (vps)
    2863       {
    2864         m_activeVPS = *(vps);
    2865         m_activeSPS = *(sps);
    2866 #if SVC_EXTENSION
    2867         m_activePPS = *(pps);
    2868 #endif
    2869         return true;
     2849    }
     2850    else
     2851    {
     2852      TComSPS *sps = m_spsMap.getPS(spsId);
     2853      if (sps)
     2854      {
     2855        Int vpsId = sps->getVPSId();
     2856        if (!isIRAP && (vpsId != m_activeVPSId ))
     2857        {
     2858          printf("Warning: tried to activate PPS referring to a inactive VPS at non-IDR.");
     2859        }
     2860        else
     2861        {
     2862          TComVPS *vps =m_vpsMap.getPS(vpsId);
     2863          if (vps)
     2864          {
     2865            m_activeVPSId = vpsId;
     2866            m_activeSPSId = spsId;
     2867            return true;
     2868          }
     2869          else
     2870          {
     2871            printf("Warning: tried to activate PPS that refers to a non-existing VPS.");
     2872          }
     2873        }
    28702874      }
    28712875      else
    28722876      {
    2873         printf("Warning: tried to activate PPS that refers to a non-existing VPS.");
    2874       }
    2875     }
    2876     else
    2877     {
    2878       printf("Warning: tried to activate a PPS that refers to a non-existing SPS.");
     2877        printf("Warning: tried to activate a PPS that refers to a non-existing SPS.");
     2878      }
    28792879    }
    28802880  }
    … …  
    28832883    printf("Warning: tried to activate non-existing PPS.");
    28842884  }
     2885
     2886  // Failed to activate if reach here.
     2887  m_activeSPSId=-1;
     2888  m_activeVPSId=-1;
    28852889  return false;
    28862890}
    … …  
    29052909}
    29062910
    2907 Void calculateParameterSetChangedFlag(Bool &bChanged, const std::vector<UChar> *pOldData, const std::vector<UChar> *pNewData)
     2911Void calculateParameterSetChangedFlag(Bool &bChanged, const std::vector<UChar> *pOldData, const std::vector<UChar> &newData)
    29082912{
    29092913  if (!bChanged)
    … …  
    29222926      else
    29232927      {
    2924         const UChar *pNewDataArray=&(*pNewData)[0];
     2928        const UChar *pNewDataArray=&(newData)[0];
    29252929        const UChar *pOldDataArray=&(*pOldData)[0];
    29262930        if (memcmp(pOldDataArray, pNewDataArray, pOldData->size()))

  • branches/SHM-dev/source/Lib/TLibCommon/TComSlice.h

    r1316 r1319  
    25022502
    25032503
    2504 Void calculateParameterSetChangedFlag(Bool &bChanged, const std::vector<UChar> *pOldData, const std::vector<UChar> *pNewData);
     2504Void calculateParameterSetChangedFlag(Bool &bChanged, const std::vector<UChar> *pOldData, const std::vector<UChar> &newData);
    25052505
    25062506template <class T> class ParameterSetMap
    … …  
    25282528  }
    25292529
    2530   Void storePS(Int psId, T *ps, const std::vector<UChar> *pNaluData)
     2530  Void storePS(Int psId, T *ps, const std::vector<UChar> &naluData)
    25312531  {
    25322532    assert ( psId < m_maxId );
    … …  
    25362536
    25372537      // work out changed flag
    2538       calculateParameterSetChangedFlag(mapData.bChanged, mapData.pNaluData, pNaluData);
     2538      calculateParameterSetChangedFlag(mapData.bChanged, mapData.pNaluData, naluData);
    25392539      delete m_paramsetMap[psId].pNaluData;
    25402540      delete m_paramsetMap[psId].parameterSet;
    … …  
    25472547      m_paramsetMap[psId].bChanged = false;
    25482548    }
    2549     if (pNaluData)
    2550     {
    2551       m_paramsetMap[psId].pNaluData=new std::vector<UChar>;
    2552       *(m_paramsetMap[psId].pNaluData) = *pNaluData;
    2553     }
    2554     else
    2555     {
    2556       m_paramsetMap[psId].pNaluData=0;
    2557     }
     2549    m_paramsetMap[psId].pNaluData=new std::vector<UChar>;
     2550    *(m_paramsetMap[psId].pNaluData) = naluData;
    25582551  }
    25592552
    … …  
    25782571  T* getPS(Int psId)
    25792572  {
    2580     return ( m_paramsetMap.find(psId) == m_paramsetMap.end() ) ? NULL : m_paramsetMap[psId].parameterSet;
     2573    typename std::map<Int,MapData<T> >::iterator it=m_paramsetMap.find(psId);
     2574    return ( it == m_paramsetMap.end() ) ? NULL : (it)->second.parameterSet;
     2575  }
     2576
     2577  const T* getPS(Int psId) const
     2578  {
     2579    typename std::map<Int,MapData<T> >::const_iterator it=m_paramsetMap.find(psId);
     2580    return ( it == m_paramsetMap.end() ) ? NULL : (it)->second.parameterSet;
    25812581  }
    25822582
    … …  
    25982598
    25992599  //! store sequence parameter set and take ownership of it
    2600   Void           storeVPS(TComVPS *vps, const std::vector<UChar> *pNaluData) { m_vpsMap.storePS( vps->getVPSId(), vps, pNaluData); };
     2600  Void           storeVPS(TComVPS *vps, const std::vector<UChar> &naluData) { m_vpsMap.storePS( vps->getVPSId(), vps, naluData); };
    26012601  //! get pointer to existing video parameter set
    26022602  TComVPS*       getVPS(Int vpsId)                                           { return m_vpsMap.getPS(vpsId); };
    … …  
    26062606
    26072607  //! store sequence parameter set and take ownership of it
    2608   Void           storeSPS(TComSPS *sps, const std::vector<UChar> *pNaluData) { m_spsMap.storePS( sps->getSPSId(), sps, pNaluData); };
     2608  Void           storeSPS(TComSPS *sps, const std::vector<UChar> &naluData) { m_spsMap.storePS( sps->getSPSId(), sps, naluData); };
    26092609  //! get pointer to existing sequence parameter set
    26102610  TComSPS*       getSPS(Int spsId)                                           { return m_spsMap.getPS(spsId); };
    … …  
    26142614
    26152615  //! store picture parameter set and take ownership of it
    2616   Void           storePPS(TComPPS *pps, const std::vector<UChar> *pNaluData) { m_ppsMap.storePS( pps->getPPSId(), pps, pNaluData); };
     2616  Void           storePPS(TComPPS *pps, const std::vector<UChar> &naluData) { m_ppsMap.storePS( pps->getPPSId(), pps, naluData); };
    26172617  //! get pointer to existing picture parameter set
    26182618  TComPPS*       getPPS(Int ppsId)                                           { return m_ppsMap.getPS(ppsId); };
    … …  
    26232623  //! activate a SPS from a active parameter sets SEI message
    26242624  //! \returns true, if activation is successful
    2625   Bool           activateSPSWithSEI(Int SPSId);
     2625  // Bool           activateSPSWithSEI(Int SPSId);
    26262626
    26272627  //! activate a PPS and depending on isIDR parameter also SPS and VPS
    … …  
    26292629  Bool           activatePPS(Int ppsId, Bool isIRAP);
    26302630
    2631   const TComVPS* getActiveVPS()const { return &m_activeVPS; };
    2632   const TComSPS* getActiveSPS()const { return &m_activeSPS; };
     2631  const TComVPS* getActiveVPS()const { return m_vpsMap.getPS(m_activeVPSId); };
     2632  const TComSPS* getActiveSPS()const { return m_spsMap.getPS(m_activeSPSId); };
    26332633
    26342634#if SVC_EXTENSION
    2635   const TComPPS* getActivePPS()const { return &m_activePPS; };
     2635  const TComPPS* getActivePPS()const { return m_ppsMap.getPS(m_activePPSId); };
    26362636#endif
    26372637
    … …  
    26432643  static ParameterSetMap<TComPPS> m_ppsMap;
    26442644
    2645   TComPPS                  m_activePPS;
    2646   static TComVPS           m_activeVPS;
     2645  Int    m_activePPSId;
     2646  static Int m_activeVPSId; // -1 for nothing active;
    26472647#else
    26482648  ParameterSetMap<TComVPS> m_vpsMap;
    … …  
    26502650  ParameterSetMap<TComPPS> m_ppsMap;
    26512651
    2652   TComVPS                  m_activeVPS; // used for SEI message
    2653 #endif
    2654 
    2655   TComSPS                  m_activeSPS; // used for SEI message
     2652  Int m_activeVPSId; // -1 for nothing active
     2653#endif
     2654
     2655  Int m_activeSPSId; // -1 for nothing active
    26562656};
    26572657
Note: See TracChangeset for help on using the changeset viewer.