RingBuffer.hh

Go to the documentation of this file.

/*

    Lockless ring buffer
    Copyright (C) 2004 Jussi Laako

    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

*/


#include <cstdio>

#include <Exception.hh>

#include "dsp/DSPOp.hh"


#ifndef RINGBUFFER_HH
    #define RINGBUFFER_HH


    class clXRingBuffer : public clException
    {
        public:
            clXRingBuffer (const char *cpErrorMsg) : 
                clException(cpErrorMsg)
                { }
    };


    template <class TRingBuffer_t> class clRingBuffer
    {
            volatile long lSize;
            volatile long lCount;
            volatile long lPutIndex;
            volatile long lGetIndex;
            clDSPAlloc Buffer;
        public:
            clRingBuffer ()
                {
                    lSize = 0;
                    lCount = 0;
                    lPutIndex = 0;
                    lGetIndex = 0;
                }
            clRingBuffer (const clRingBuffer<TRingBuffer_t> &CopySrc)
                {
                    lSize = CopySrc.lSize;
                    lCount = CopySrc.lCount;
                    lPutIndex = CopySrc.lPutIndex;
                    lGetIndex = CopySrc.lGetIndex;
                    Buffer = CopySrc.Buffer;
                }
            clRingBuffer (long lNewSize)
                { SetSize(lNewSize); }
            void SetSize (long lNewSize)
                {
                    Buffer.Size(lNewSize * sizeof(TRingBuffer_t));
                    lSize = lNewSize;
                    lCount = 0;
                    lPutIndex = 0;
                    lGetIndex = 0;
                }
            void Lock ()
                { Buffer.Lock(); }
            void UnLock ()
                { Buffer.UnLock(); }
            long Size () const
                {
                    return lSize;
                }
            long GetCount () const
                {
                    return lCount;
                }
            void Put (const TRingBuffer_t *Src, long lSrcCount)
                {
                    register long lLPutIdx = lPutIndex;
                    register long lLSize = lSize;
                    if (lSrcCount > lLSize)
                        throw clXRingBuffer("clRingBuffer::Put(): lSrcCount > lSize");
                    register long lTailSize = lLSize - lLPutIdx;
                    register long lHeadSize = lSrcCount - lTailSize;
                    TRingBuffer_t *LBuf = Buffer;
                    if (lHeadSize > 0)
                    {
                        clDSPOp::Copy(LBuf + lLPutIdx, Src, lTailSize);
                        clDSPOp::Copy(LBuf, Src + lTailSize, lHeadSize);
                    }
                    else
                    {
                        clDSPOp::Copy(LBuf + lLPutIdx, Src, lSrcCount);
                    }
                    lLPutIdx = (lLPutIdx + lSrcCount) % lLSize;
                    lPutIndex = lLPutIdx;
                    register long lLCount = lCount;
                    lLCount = (lLCount + lSrcCount) % lLSize;
                    lCount = lLCount;
                }
            bool Get (TRingBuffer_t *Dst, long lDstCount)
                {
                    register long lLCount = lCount;
                    if (lLCount < lDstCount)
                        return false;
                    lLCount -= lDstCount;
                    lCount = lLCount;
                    register long lLGetIdx = lGetIndex;
                    register long lLSize = lSize;
                    if (lDstCount > lLSize)
                        throw clXRingBuffer("clRingBuffer::Get(): lDstCount > lSize");
                    register long lTailSize = lLSize - lLGetIdx;
                    register long lHeadSize = lDstCount - lTailSize;
                    register long lNewIdx = (lLGetIdx + lDstCount) % lLSize;
                    lGetIndex = lNewIdx;
                    TRingBuffer_t *LBuf = Buffer;
                    if (lHeadSize > 0)
                    {
                        clDSPOp::Copy(Dst, LBuf + lLGetIdx, lTailSize);
                        clDSPOp::Copy(Dst + lTailSize, LBuf, lHeadSize);
                    }
                    else
                    {
                        clDSPOp::Copy(Dst, LBuf + lLGetIdx, lTailSize);
                    }
                    return true;
                }
    };

#endif

---