ReBufferT.hh

Go to the documentation of this file.

/*

    Template rebuffering class
    Copyright (C) 2001-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 <cmath>
#include <cfloat>
#include <cstring>
#include <typeinfo>

#include <Exception.hh>

#include "dsp/DSPOp.hh"


#ifndef REBUFFERT_HH
    #define REBUFFERT_HH


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


    template <class TReBuffer_t> class clReBufferT
    {
            long lSize;
            long lPutIndex;
            long lGetIndex;
            long lCount;
            clDSPAlloc Buffer;

            inline void CheckSize (long lDataCount)
                {
                    long lTotalSize = (lCount + lDataCount) * 
                        sizeof(TReBuffer_t);
                    if (lTotalSize > Buffer.GetSize())
                    {
                        #ifndef _ISOC9X_SOURCE
                        long lTwosExp = (long) std::ceil(
                            std::log((double) lTotalSize) / 
                            std::log((double) 2));
                        long lNewBufferSize = (long) 
                            std::pow(2.0, (double) lTwosExp);
                        #else
                        long lTwosExp = (long) ceil(log2(lTotalSize));
                        long lNewBufferSize = (long) exp2(lTwosExp);
                        #endif
                        Buffer.Resize(lNewBufferSize);

                        long lTailSize = lSize - lGetIndex;
                        if (lCount > lTailSize)
                        {
                            long lHeadSize = lCount - lTailSize;
                            long lNewSize = 
                                lNewBufferSize / sizeof(TReBuffer_t);
                            unsigned char *cpBuffer = Buffer;
                            unsigned char *cpDest = 
                                cpBuffer + lSize * sizeof(TReBuffer_t);
                            memcpy(cpDest, cpBuffer, 
                                lHeadSize * sizeof(TReBuffer_t));
                            lPutIndex = lSize + lHeadSize;
                            if (lPutIndex >= lNewSize)
                                lPutIndex -= lNewSize;
                        }

                        lSize = lNewBufferSize / sizeof(TReBuffer_t);
                    }
                }
        protected:
            TReBuffer_t * GetPtr ()
                {
                    if (lGetIndex == 0 || lCount == 0)
                        return ((TReBuffer_t *) Buffer);
                    long lTempCount = lCount;
                    clDSPAlloc Temp(lTempCount * sizeof(TReBuffer_t));
                    Get((TReBuffer_t *) Temp, lTempCount);
                    Clear();
                    Put((TReBuffer_t *) Temp, lTempCount);
                    return ((TReBuffer_t *) Buffer);
                }
            void CopyGet (TReBuffer_t *fpDestData, long lDestCount) const
                {
                    long lTailSize = lSize - lGetIndex;
                    const TReBuffer_t *fpBuffer = 
                        (const TReBuffer_t *) Buffer.GetPtr();
                    if (lDestCount > lTailSize)
                    {
                        long lHeadSize = lDestCount - lTailSize;
                        memcpy(fpDestData, &fpBuffer[lGetIndex],
                            lTailSize * sizeof(TReBuffer_t));
                        memcpy(&fpDestData[lTailSize], fpBuffer,
                            lHeadSize * sizeof(TReBuffer_t));
                    }
                    else
                    {
                        memcpy(fpDestData, &fpBuffer[lGetIndex],
                            lDestCount * sizeof(TReBuffer_t));
                    }
                }
        public:
            clReBufferT ()
                {
                    lSize = 0;
                    lPutIndex = 0;
                    lGetIndex = 0;
                    lCount = 0;
                }
            clReBufferT (const clReBufferT &CopySrc)
                {
                    lSize = 0;
                    lPutIndex = 0;
                    lGetIndex = 0;
                    lCount = 0;
                    *this = CopySrc;
                }
            clReBufferT (long lNewSize)
                {
                    lSize = 0;
                    lPutIndex = 0;
                    lGetIndex = 0;
                    lCount = 0;
                    SetSize(lNewSize);
                }
            clReBufferT (const TReBuffer_t *fpSrcData, long lSrcCount)
                {
                    lSize = 0;
                    lPutIndex = 0;
                    lGetIndex = 0;
                    lCount = 0;
                    Put(fpSrcData, lSrcCount);
                }
            ~clReBufferT ()
                { }
            void Put (const TReBuffer_t *fpSrcData, long lSrcCount)
                {
                    CheckSize(lSrcCount);
                    if (lPutIndex >= lSize) lPutIndex = 0;
                    long lTailSpace = lSize - lPutIndex;
                    TReBuffer_t *fpBuffer = Buffer;
                    if (lSrcCount > lTailSpace)
                    {
                        long lHeadSize = lSrcCount - lTailSpace;
                        memcpy(&fpBuffer[lPutIndex], fpSrcData, 
                            lTailSpace * sizeof(TReBuffer_t));
                        memcpy(fpBuffer, &fpSrcData[lTailSpace], 
                            lHeadSize * sizeof(TReBuffer_t));
                        lPutIndex = lHeadSize;
                    }
                    else
                    {
                        memcpy(&fpBuffer[lPutIndex], fpSrcData, 
                            lSrcCount * sizeof(TReBuffer_t));
                        lPutIndex += lSrcCount;
                    }
                    lCount += lSrcCount;
                }
            void Put (clReBufferT &Src)
                {
                    Put(Src.GetPtr(), Src.Size());
                }
            bool Get (TReBuffer_t *fpDestData, long lDestCount)
                {
                    if (lCount < lDestCount)
                        return false;
                    long lTailSize = lSize - lGetIndex;
                    TReBuffer_t *fpBuffer = Buffer;
                    if (lDestCount > lTailSize)
                    {
                        long lHeadSize = lDestCount - lTailSize;
                        memcpy(fpDestData, &fpBuffer[lGetIndex], 
                            lTailSize * sizeof(TReBuffer_t));
                        memcpy(&fpDestData[lTailSize], fpBuffer, 
                            lHeadSize * sizeof(TReBuffer_t));
                        lGetIndex = lHeadSize;
                    }
                    else
                    {
                        memcpy(fpDestData, &fpBuffer[lGetIndex], 
                            lDestCount * sizeof(TReBuffer_t));
                        lGetIndex += lDestCount;
                    }
                    lCount -= lDestCount;
                    return true;
                }
            long GetCount () const
                { 
                    return lCount; 
                }
            long Size () const
                {
                    return lCount;
                }
            void SetSize (long lNewCount)
                {
                    Clear();
                    CheckSize(lNewCount);
                    lCount = lNewCount;
                    lPutIndex = lCount;
                }
            void Resize (long lNewCount)
                {
                    if (lNewCount > lSize)
                        CheckSize(lNewCount - lCount);
                    lCount = lNewCount;
                    lPutIndex = lCount;
                }
            void Clear ()
                {
                    lSize = 0;
                    lPutIndex = 0;
                    lGetIndex = 0;
                    lCount = 0;
                    Buffer.Free();
                }
            clReBufferT & operator= (const clReBufferT &Src)
                {
                    SetSize(Src.Size());
                    Src.CopyGet((TReBuffer_t *) Buffer, Src.Size());
                    lPutIndex = Src.Size();
                    lCount = Src.Size();
                    return (*this);
                }
            TReBuffer_t & operator[] (long lIndex)
                {
                    if (lIndex >= lCount)
                    {
                        throw clXReBufferT(
                            "clReBufferT<>::operator[]: Index >= Size()");
                    }
                    long lBufIdx = lGetIndex + lIndex;
                    if (lBufIdx >= lSize) lBufIdx -= lSize;
                    TReBuffer_t *fpBuffer = Buffer;
                    return fpBuffer[lIndex];
                }
    };


#endif

---