RingBuffer.h

Go to the documentation of this file.

#if !defined(__RingBuffer_hdr__)
#define __RingBuffer_hdr__
 
#include <cassert>
#include <algorithm>
#include <cmath>
 
template <class T> 
class CRingBuffer
{
public:
    explicit CRingBuffer (int iBufferLengthInSamples) :
        m_iBuffLength(iBufferLengthInSamples),
        m_iReadIdx(0),                          
        m_iWriteIdx(0),
        m_ptBuff(0)
    {
        assert(iBufferLengthInSamples > 0);
 
        m_ptBuff        = new T [m_iBuffLength];
        reset();
    }
 
    virtual ~CRingBuffer ()
    {
        delete [] m_ptBuff;
        m_ptBuff    = 0;
    }
 
    void putPostInc (T tNewValue)
    {
        put(tNewValue);
        incIdx(m_iWriteIdx);
    }
 
    void putPostInc (const T* ptNewBuff, int iLength)
    {
        put(ptNewBuff, iLength);
        incIdx(m_iWriteIdx, iLength);
    }
 
    void put(T tNewValue)
    {
        m_ptBuff[m_iWriteIdx]   = tNewValue;
    }
 
    void put(const T* ptNewBuff, int iLength)
    {
        assert(iLength <= m_iBuffLength && iLength >= 0);
 
        // copy two parts: to the end of buffer and after wrap around
        int iNumValues2End      = std::min(iLength,m_iBuffLength - m_iWriteIdx);
 
        memcpy (&m_ptBuff[m_iWriteIdx], ptNewBuff, sizeof(T)*iNumValues2End);
        if ((iLength - iNumValues2End)>0)
            memcpy (m_ptBuff, &ptNewBuff[iNumValues2End], sizeof(T)*(iLength - iNumValues2End));
    }
    
    T getPostInc ()
    {
        T tValue = get();
        incIdx(m_iReadIdx);
        return tValue;
    }
 
    void getPostInc (T* ptBuff, int iLength)
    {
        get(ptBuff, iLength);
        incIdx(m_iReadIdx, iLength);
    }
 
    T get (float fOffset = 0) const
    {
        if (fOffset == 0)
            return m_ptBuff[m_iReadIdx];
        else
        {
            
            // compute fraction for linear interpolation 
            int     iOffset = static_cast<int>(std::floor(fOffset));
            float   fFrac   = fOffset - iOffset;
            int     iRead   = m_iReadIdx + iOffset;
            while (iRead > m_iBuffLength-1)
                iRead  -= m_iBuffLength;
            while (iRead < 0)
                iRead  += m_iBuffLength;
 
            return (1-fFrac) * m_ptBuff[iRead] +
                       fFrac * m_ptBuff[(iRead+1) % m_iBuffLength];
        }
    }
 
    void get (T* ptBuff, int iLength) const
    {
        assert(iLength <= m_iBuffLength && iLength >= 0);
 
        // copy two parts: to the end of buffer and after wrap around
        int iNumValues2End      = std::min(iLength, m_iBuffLength - m_iReadIdx);
 
        memcpy (ptBuff, &m_ptBuff[m_iReadIdx], sizeof(T)*iNumValues2End);
        if ((iLength - iNumValues2End)>0)
            memcpy (&ptBuff[iNumValues2End], m_ptBuff, sizeof(T)*(iLength - iNumValues2End));
    }
    
    void reset ()
    {
        memset (m_ptBuff, 0, sizeof(T)*m_iBuffLength);
        m_iReadIdx  = 0;
        m_iWriteIdx = 0;
    }
 
    int getWriteIdx () const
    {
        return m_iWriteIdx;
    }
 
    void setWriteIdx (int iNewWriteIdx)
    {
        incIdx(m_iWriteIdx, iNewWriteIdx - m_iWriteIdx);
    }
 
    int getReadIdx () const
    {
        return m_iReadIdx;
    }
 
    void setReadIdx (int iNewReadIdx)
    {
        incIdx(m_iReadIdx, iNewReadIdx - m_iReadIdx);
    }
 
    int getNumValuesInBuffer () const
    {
        return (m_iWriteIdx - m_iReadIdx + m_iBuffLength)%m_iBuffLength;
    }
 
    int getLength () const
    {
        return m_iBuffLength;
    }
private:
    CRingBuffer ();
    CRingBuffer(const CRingBuffer& that);
 
    void incIdx (int &iIdx, int iOffset = 1)
    {
        while ((iIdx + iOffset) < 0)
        {
            // avoid negative buffer indices
            iOffset += m_iBuffLength;   
        }
        iIdx    = (iIdx + iOffset) % m_iBuffLength;
    };
 
    int m_iBuffLength,              
        m_iReadIdx,                 
        m_iWriteIdx;                
 
    T   *m_ptBuff;                  
};
#endif // __RingBuffer_hdr__