FEAPIExamplePluginLoudness/RingBuffer.h

Go to the documentation of this file.

//     /*! \file RingBuffer.h: \brief interface of the CRingBuffer class. */
//
//        Copyright (c) 2004-2006  
//        zplane.development
//        Flohrer Lerch Schwerdtfeger GbR
//        All rights reserved.
//
//    This program is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    This program is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with this program; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//

#if !defined(__RINGBUFFER_HEADER_INCLUDED__)
#define __RINGBUFFER_HEADER_INCLUDED__

#ifdef WIN32
#define INLINE __forceinline
#else
#define INLINE
#endif

static INLINE unsigned int Int2PowTwo (int iValue)
{
    unsigned int    iOrder = 0;

    while (iValue>>iOrder)
        iOrder++;

    if (!(iValue%(1<<(iOrder-1))))
        iOrder--;
    
    return (1<<(iOrder));
}

//********************************************************************
//  @class:             CRingBuffer <template>
//  @author:            Tim Flohrer
//  @notes:             implements a Ringbuffer
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************

template <class T>  class CRingBuffer 
{
    
private:
    
    unsigned int    m_uiReadIndex,
            m_uiWriteIndex,
            m_uiTmpIndex;

    unsigned int    m_uiSize,
            m_uiMask;

    T       *m_ptBuffer;


public:
    static int   CreateInstance  (CRingBuffer*& pCRingBuffer, unsigned int uiLength)
    {
        int  rErr    = 0;
        pCRingBuffer    = 0;
    
        // create instance
        pCRingBuffer    = new CRingBuffer (uiLength);
    
        if (pCRingBuffer == NULL)
            rErr        = -1;
        else if (!pCRingBuffer->m_ptBuffer)
        {
            rErr        = -1;
            delete pCRingBuffer;
            pCRingBuffer= 0;
        }

        return rErr;
    };

    static int   DestroyInstance (CRingBuffer*& pCRingBuffer)
    {
        if (!pCRingBuffer)
            return -1;

        delete pCRingBuffer;
        pCRingBuffer    = 0;

        return 0;
    };

//********************************************************************
//  @method:            CRingBuffer 
//  @parameter:         unsigned int uiNewSize      desired size of the ring buffer
//  @result:            
//  @author:            Tim Flohrer
//  @notes:             constructor of the CRingbuffer class
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************
    CRingBuffer(unsigned int uiNewSize)
    {
//      m_uiSize            =   (unsigned int)pow(2,1+(int)(log(uiNewSize)/log(2)));
        m_uiSize            =   Int2PowTwo(uiNewSize);
        m_uiMask            =   m_uiSize-1;
        m_uiReadIndex       =   0;
        m_uiWriteIndex      =   0;
        m_uiTmpIndex        =   0;
        m_ptBuffer          =   0;
        m_ptBuffer          =   new T[m_uiSize];
        for( unsigned int i=0; i<m_uiSize; m_ptBuffer[i++] = 0);
    }
    

//********************************************************************
//  @method:            ~CRingBuffer
//  @parameter:         
//  @result:            
//  @author:            Tim Flohrer
//  @notes:             destructor
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************
    ~CRingBuffer()
    {
        if (m_ptBuffer)
            delete [] m_ptBuffer;
    }
    
    
//********************************************************************
//  @method:            GetOff
//  @parameter:         int iIndex
//  @result:            T
//  @author:            Tim Flohrer
//  @notes:             gets an item at offset iIndex from the
//                      current read pointer, without modifying 
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************
INLINE T GetOff(int iIndex)
    {       
        return m_ptBuffer[(m_uiReadIndex + iIndex + m_uiSize) & m_uiMask];
    }

INLINE T GetOffW(int iIndex)
    {       
        return m_ptBuffer[(m_uiWriteIndex + iIndex + m_uiSize) & m_uiMask];
    }


//********************************************************************
//  @method:            PutOff
//  @parameter:         T tItem
//                      int iIndex
//  @result:            
//  @author:            Tim Flohrer
//  @notes:             puts an item at offset iIndex from the
//                      current write pointer, without modifying
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************
INLINE void PutOff(T tItem,int iIndex)
    {
        m_ptBuffer[(m_uiWriteIndex + iIndex + m_uiSize) & m_uiMask] =   tItem;
    }
    
//********************************************************************
//  @method:            GetOffMod
//  @parameter:         int iIndex
//  @result:            T
//  @author:            Tim Flohrer
//  @notes:             gets an item at offset iIndex from the
//                      current read pointer, with modifying 
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************
INLINE T GetOffMod(int iIndex)
    {       
        m_uiReadIndex               =   ((m_uiReadIndex + iIndex + m_uiSize) & m_uiMask);
        return m_ptBuffer[ m_uiReadIndex ];
    }
    
    
//********************************************************************
//  @method:            PutOffMod
//  @parameter:         T tItem
//                      int iIndex
//  @result:            
//  @author:            Tim Flohrer
//  @notes:             puts an item at offset iIndex from the
//                      current write pointer, with modifying
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************
INLINE void PutOffMod(T tItem,int iIndex)
    {
        m_uiWriteIndex              =   (m_uiWriteIndex + iIndex + m_uiSize) & m_uiMask;
        m_ptBuffer[m_uiWriteIndex]  =   tItem;
    }
    

//********************************************************************
//  @method:            Get
//  @parameter:         
//  @result:            T
//  @author:            Tim Flohrer
//  @notes:             gets an item at current read pointer
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************  
INLINE T Get()
    {       
        return m_ptBuffer[ m_uiReadIndex ];
    }
    

//********************************************************************
//  @method:            Put
//  @parameter:         T tItem
//  @result:            
//  @author:            Tim Flohrer
//  @notes:             puts an item at current read pointer
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************  
INLINE void Put(T tItem)
    {
        m_ptBuffer[ m_uiWriteIndex ]    =   tItem;
    }
    

//********************************************************************
//  @method:            GetPostInc
//  @parameter:         
//  @result:            T
//  @author:            Tim Flohrer
//  @notes:             gets an item at the current read pointer
//                      and increments the read pointer afterwards
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************
INLINE T GetPostInc()
    {       
        m_uiTmpIndex    = m_uiReadIndex;
        m_uiReadIndex   = (m_uiReadIndex + 1) & m_uiMask; 
        return m_ptBuffer[ m_uiTmpIndex ];
    }

INLINE void GetPostInc (T* ptBuffer, int iNumOfItems)
    {
        if (iNumOfItems <= 0)
            return;
        m_uiTmpIndex    = m_uiReadIndex;
        m_uiReadIndex   = (m_uiReadIndex + iNumOfItems) & m_uiMask; 
        if (m_uiTmpIndex + iNumOfItems <= m_uiSize)
        {
            memcpy (ptBuffer, &m_ptBuffer[ m_uiTmpIndex ], sizeof(T) * iNumOfItems);
            return;
        }
        else
        {
            ZASSERT (m_uiSize - m_uiTmpIndex <= 0);
            ZASSERT (iNumOfItems - m_uiSize + m_uiTmpIndex <= 0);
            memcpy (ptBuffer, &m_ptBuffer[ m_uiTmpIndex ], sizeof(T) * (m_uiSize - m_uiTmpIndex));
            memcpy (&ptBuffer[m_uiSize - m_uiTmpIndex], m_ptBuffer, sizeof(T) * (iNumOfItems - m_uiSize + m_uiTmpIndex));
            return;
        }
    }
INLINE void GetOffPostInc(T* ptBuffer, int iNumOfItems, int iIndex)
    {       
        if (iNumOfItems <= 0)
            return;
        m_uiTmpIndex    = ((m_uiReadIndex + iIndex + m_uiSize) & m_uiMask);
        m_uiReadIndex   = (m_uiReadIndex + iNumOfItems) & m_uiMask; 
        if (m_uiTmpIndex + iNumOfItems <= m_uiSize)
        {
            memcpy (ptBuffer, &m_ptBuffer[ m_uiTmpIndex ], sizeof(T) * iNumOfItems);
            return;
        }
        else
        {
            ZASSERT (m_uiSize - m_uiTmpIndex <= 0);
            ZASSERT (iNumOfItems - m_uiSize + m_uiTmpIndex <= 0);
            memcpy (ptBuffer, &m_ptBuffer[ m_uiTmpIndex ], sizeof(T) * (m_uiSize - m_uiTmpIndex));
            memcpy (&ptBuffer[m_uiSize - m_uiTmpIndex], m_ptBuffer, sizeof(T) * (iNumOfItems - m_uiSize + m_uiTmpIndex));
            return;
        }
    }
INLINE void GetOff(T* ptBuffer, int iNumOfItems, int iIndex)
    {       
        if (iNumOfItems <= 0)
            return;
        m_uiTmpIndex    = ((m_uiReadIndex + iIndex + m_uiSize) & m_uiMask);
        if (m_uiTmpIndex + iNumOfItems <= m_uiSize)
        {
            memcpy (ptBuffer, &m_ptBuffer[ m_uiTmpIndex ], sizeof(T) * iNumOfItems);
            return;
        }
        else
        {
            ZASSERT (m_uiSize - m_uiTmpIndex <= 0);
            ZASSERT (iNumOfItems - m_uiSize + m_uiTmpIndex <= 0);
            memcpy (ptBuffer, &m_ptBuffer[ m_uiTmpIndex ], sizeof(T) * (m_uiSize - m_uiTmpIndex));
            memcpy (&ptBuffer[m_uiSize - m_uiTmpIndex], m_ptBuffer, sizeof(T) * (iNumOfItems - m_uiSize + m_uiTmpIndex));
            return;
        }
    }
INLINE void GetOffW(T* ptBuffer, int iNumOfItems, int iIndex)
    {       
        if (iNumOfItems <= 0)
            return;
        m_uiTmpIndex    = ((m_uiWriteIndex + iIndex + m_uiSize) & m_uiMask);
        if (m_uiTmpIndex + iNumOfItems <= m_uiSize)
        {
            memcpy (ptBuffer, &m_ptBuffer[ m_uiTmpIndex ], sizeof(T) * iNumOfItems);
            return;
        }
        else
        {
            ZASSERT (m_uiSize - m_uiTmpIndex <= 0);
            ZASSERT (iNumOfItems - m_uiSize + m_uiTmpIndex <= 0);
            memcpy (ptBuffer, &m_ptBuffer[ m_uiTmpIndex ], sizeof(T) * (m_uiSize - m_uiTmpIndex));
            memcpy (&ptBuffer[m_uiSize - m_uiTmpIndex], m_ptBuffer, sizeof(T) * (iNumOfItems - m_uiSize + m_uiTmpIndex));
            return;
        }
    }
    
//********************************************************************
//  @method:            PutPostInc
//  @parameter:         T tItem
//  @result:            
//  @author:            Tim Flohrer
//  @notes:             puts an item at the current read pointer
//                      and increments the write pointer afterwards
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************
INLINE void PutPostInc(T tItem)
    {
        m_uiTmpIndex    = m_uiWriteIndex;
        m_uiWriteIndex = (m_uiWriteIndex + 1) & m_uiMask;
        m_ptBuffer[ m_uiTmpIndex ]  =   tItem;
    }


INLINE void PutPostInc(const T *ptItem, int iNumOfItems)
    {
        if (iNumOfItems <= 0)
            return;
        m_uiTmpIndex    = m_uiWriteIndex;
        m_uiWriteIndex = (m_uiWriteIndex + iNumOfItems) & m_uiMask;
        if (m_uiTmpIndex + iNumOfItems <= m_uiSize)
        {
            memcpy (&m_ptBuffer[ m_uiTmpIndex ], ptItem, sizeof(T) * iNumOfItems);
            return;
        }
        else
        {
            ZASSERT (m_uiSize - m_uiTmpIndex <= 0);
            ZASSERT (iNumOfItems - m_uiSize + m_uiTmpIndex <= 0);
            memcpy (&m_ptBuffer[ m_uiTmpIndex ], ptItem, sizeof(T) * (m_uiSize - m_uiTmpIndex));
            memcpy (m_ptBuffer, &ptItem[m_uiSize - m_uiTmpIndex], sizeof(T) * (iNumOfItems - m_uiSize + m_uiTmpIndex));
            return;
        }
}
    

//********************************************************************
//  @method:            GetPreInc
//  @parameter:         
//  @result:            T
//  @author:            Tim Flohrer
//  @notes:             increments the read pointer and 
//                      gets an item at the current read pointer
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************
INLINE T GetPreInc()
    {       
        m_uiReadIndex = (m_uiReadIndex + 1) & m_uiMask;
        return m_ptBuffer[ m_uiReadIndex ];
    }
    

//********************************************************************
//  @method:            PutPreInc
//  @parameter:         T tItem
//  @result:            
//  @author:            Tim Flohrer
//  @notes:             increments the write pointer and 
//                      puts an item at the current write pointer
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************
INLINE void PutPreInc(T tItem)
    {
        m_uiWriteIndex = (m_uiWriteIndex + 1) & m_uiMask;
        m_ptBuffer[ m_uiWriteIndex ]    =   tItem;
    }
    

//********************************************************************
//  @method:            GetPostDec
//  @parameter:         
//  @result:            T
//  @author:            Tim Flohrer
//  @notes:             gets an item at the current read pointer
//                      and Decrements the read pointer afterwards
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************
INLINE T GetPostDec()
    {   
        m_uiTmpIndex    = m_uiReadIndex;
        m_uiReadIndex   = (m_uiReadIndex - 1 + m_uiSize) & m_uiMask;
        return m_ptBuffer[ m_uiTmpIndex ];
    }
    
//********************************************************************
//  @method:            PutPostDec
//  @parameter:         T tItem
//  @result:            
//  @author:            Tim Flohrer
//  @notes:             puts an item at the current read pointer
//                      and Decrements the write pointer afterwards
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************
INLINE void PutPostDec(T tItem)
    {
        m_uiTmpIndex    = m_uiWriteIndex;
        m_uiWriteIndex  = (m_uiWriteIndex - 1 + m_uiSize) & m_uiMask;       
        m_ptBuffer[ m_uiTmpIndex ]  =   tItem;
    }
    

//********************************************************************
//  @method:            GetPreDec
//  @parameter:         
//  @result:            T
//  @author:            Tim Flohrer
//  @notes:             Decrements the read pointer and 
//                      gets an item at the current read pointer
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************
INLINE T GetPreDec()
    {       
        m_uiReadIndex = (m_uiReadIndex - 1 + m_uiSize) & m_uiMask;
        return m_ptBuffer[ m_uiReadIndex ];
    }
    


//********************************************************************
//  @method:            PutPreDec
//  @parameter:         T tItem
//  @result:            
//  @author:            Tim Flohrer
//  @notes:             Decrements the write pointer and 
//                      puts an item at the current write pointer
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************
INLINE void PutPreDec(T tItem)
    {
        m_uiWriteIndex = (m_uiWriteIndex - 1 + m_uiSize) & m_uiMask;
        m_ptBuffer[ m_uiWriteIndex ]    =   tItem;
    }
    

//********************************************************************
//  @method:            GetReadPos
//  @parameter:         
//  @result:            int
//  @author:            Tim Flohrer
//  @notes:             returns current read pointer position
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************
INLINE int  GetReadPos()
    {
        return m_uiReadIndex;
    }
    
    
//********************************************************************
//  @method:            GetWritePos
//  @parameter:         
//  @result:            int
//  @author:            Tim Flohrer
//  @notes:             returns current write pointer position
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************
INLINE int  GetWritePos()
    {
        return m_uiWriteIndex;
    }
    
    
//********************************************************************
//  @method:            SetReadPos
//  @parameter:         int iIndex
//  @result:            
//  @author:            Tim Flohrer
//  @notes:             sets the read pointer
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************
INLINE void SetReadPos(int iIndex)
    {
        m_uiReadIndex   = (iIndex + m_uiSize) & m_uiMask; 
    }
    

//********************************************************************
//  @method:            SetWritePos
//  @parameter:         int iIndex  
//  @result:            
//  @author:            Tim Flohrer
//  @notes:             sets the write pointer
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************  
INLINE void SetWritePos(int iIndex)
    {
        m_uiWriteIndex  = (iIndex + m_uiSize) & m_uiMask;
    }
    
    

//********************************************************************
//  @method:            GetSamplesInBuffer
//  @parameter:         
//  @result:            
//  @author:            Tim Flohrer
//  @notes:             returns number of samples in buffer
//                      i.e. the difference between the read and write pointer  
//  @creation date:     18.7.2001
//  @last modified:     
//********************************************************************
INLINE int  GetSamplesInBuffer()
    {
        int iCount = m_uiWriteIndex - m_uiReadIndex;
        
        return (iCount < 0 ? m_uiSize + iCount : iCount);
    }   

INLINE void   Reset()
    {
        m_uiReadIndex   =   0;
        m_uiWriteIndex  =   0;
        m_uiTmpIndex    =   0;
        for( unsigned int i=0; i<m_uiSize; m_ptBuffer[i++] = 0);
    }

};

#endif //   __RINGBUFFER_HEADER_INCLUDED__

---