FEAPIExamplePluginZeroCrossings/RingBuffer.h

Go to the documentation of this file.

//     /*! \file RingBuffer.h: \brief interface of the CRingBuffer class. */
//
//        Copyright (c) 2004-2007  
//        zplane.development
//        Flohrer Lerch Schwerdtfeger GbR
//        All rights reserved.
//
//        Redistribution and use in source and binary forms, with or without 
//        modification, are permitted provided that the following conditions 
//        are met:
//
//        *   Redistributions of source code must retain the above copyright 
//            notice, this list of conditions and the following disclaimer. 
//        *   Redistributions in binary form must reproduce the above 
//            copyright notice, this list of conditions and the following 
//            disclaimer in the documentation and/or other materials 
//            provided with the distribution. 
//        *   Neither the name of the FEAPI development team nor the names 
//            of its contributors may be used to endorse or promote products 
//            derived from this software without specific prior written 
//            permission. 
//
//        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
//        "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
//        LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
//        FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
//        COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
//        INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
//        BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
//        LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
//        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
//        LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
//        ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
//        POSSIBILITY OF SUCH DAMAGE.
//

#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__

---