Main Page | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members

ReBufferT.hh

Go to the documentation of this file.
00001 /*
00002 
00003     Template rebuffering class
00004     Copyright (C) 2001-2002 Jussi Laako
00005 
00006     This program is free software; you can redistribute it and/or modify
00007     it under the terms of the GNU General Public License as published by
00008     the Free Software Foundation; either version 2 of the License, or
00009     (at your option) any later version.
00010 
00011     This program is distributed in the hope that it will be useful,
00012     but WITHOUT ANY WARRANTY; without even the implied warranty of
00013     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014     GNU General Public License for more details.
00015 
00016     You should have received a copy of the GNU General Public License
00017     along with this program; if not, write to the Free Software
00018     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00019 
00020 */
00021 
00022 
00023 #include <cmath>
00024 #include <cfloat>
00025 #include <cstring>
00026 #include <typeinfo>
00027 
00028 #include <Exception.hh>
00029 
00030 #include "dsp/DSPOp.hh"
00031 
00032 
00033 #ifndef REBUFFER3_HH
00034     #define REBUFFER3_HH
00035 
00036 
00042     template <class TReBuffer_t> class clReBufferT
00043     {
00044             long lSize;
00045             long lPutIndex;
00046             long lGetIndex;
00047             long lCount;
00048             clDSPAlloc Buffer;
00049 
00050             inline void CheckSize (long lDataCount)
00051                 {
00052                     long lTotalSize = (lCount + lDataCount) * 
00053                         sizeof(TReBuffer_t);
00054                     if (lTotalSize > Buffer.GetSize())
00055                     {
00056                         #ifndef _ISOC9X_SOURCE
00057                         long lTwosExp = (long) std::ceil(
00058                             std::log((double) lTotalSize) / 
00059                             std::log((double) 2));
00060                         long lNewBufferSize = (long) 
00061                             std::pow(2.0, (double) lTwosExp);
00062                         #else
00063                         long lTwosExp = (long) ceil(log2(lTotalSize));
00064                         long lNewBufferSize = (long) exp2(lTwosExp);
00065                         #endif
00066                         Buffer.Resize(lNewBufferSize);
00067 
00068                         long lTailSize = lSize - lGetIndex;
00069                         if (lCount > lTailSize)
00070                         {
00071                             long lHeadSize = lCount - lTailSize;
00072                             long lNewSize = 
00073                                 lNewBufferSize / sizeof(TReBuffer_t);
00074                             unsigned char *cpBuffer = Buffer;
00075                             unsigned char *cpDest = 
00076                                 cpBuffer + lSize * sizeof(TReBuffer_t);
00077                             memcpy(cpDest, cpBuffer, 
00078                                 lHeadSize * sizeof(TReBuffer_t));
00079                             lPutIndex = lSize + lHeadSize;
00080                             if (lPutIndex >= lNewSize)
00081                                 lPutIndex -= lNewSize;
00082                         }
00083 
00084                         lSize = lNewBufferSize / sizeof(TReBuffer_t);
00085                     }
00086                 }
00087         protected:
00088             TReBuffer_t * GetPtr ()
00089                 {
00090                     if (lGetIndex == 0 || lCount == 0)
00091                         return ((TReBuffer_t *) Buffer);
00092                     long lTempCount = lCount;
00093                     clDSPAlloc Temp(lTempCount * sizeof(TReBuffer_t));
00094                     Get((TReBuffer_t *) Temp, lTempCount);
00095                     Clear();
00096                     Put((TReBuffer_t *) Temp, lTempCount);
00097                     return ((TReBuffer_t *) Buffer);
00098                 }
00099             void CopyGet (TReBuffer_t *fpDestData, long lDestCount) const
00100                 {
00101                     long lTailSize = lSize - lGetIndex;
00102                     const TReBuffer_t *fpBuffer = 
00103                         (const TReBuffer_t *) Buffer.GetPtr();
00104                     if (lDestCount > lTailSize)
00105                     {
00106                         long lHeadSize = lDestCount - lTailSize;
00107                         memcpy(fpDestData, &fpBuffer[lGetIndex],
00108                             lTailSize * sizeof(TReBuffer_t));
00109                         memcpy(&fpDestData[lTailSize], fpBuffer,
00110                             lHeadSize * sizeof(TReBuffer_t));
00111                     }
00112                     else
00113                     {
00114                         memcpy(fpDestData, &fpBuffer[lGetIndex],
00115                             lDestCount * sizeof(TReBuffer_t));
00116                     }
00117                 }
00118         public:
00119             clReBufferT ()
00120                 {
00121                     lSize = 0;
00122                     lPutIndex = 0;
00123                     lGetIndex = 0;
00124                     lCount = 0;
00125                 }
00126             clReBufferT (const clReBufferT &CopySrc)
00127                 {
00128                     lSize = 0;
00129                     lPutIndex = 0;
00130                     lGetIndex = 0;
00131                     lCount = 0;
00132                     *this = CopySrc;
00133                 }
00134             clReBufferT (long lNewSize)
00135                 {
00136                     lSize = 0;
00137                     lPutIndex = 0;
00138                     lGetIndex = 0;
00139                     lCount = 0;
00140                     SetSize(lNewSize);
00141                 }
00142             clReBufferT (const TReBuffer_t *fpSrcData, long lSrcCount)
00143                 {
00144                     lSize = 0;
00145                     lPutIndex = 0;
00146                     lGetIndex = 0;
00147                     lCount = 0;
00148                     Put(fpSrcData, lSrcCount);
00149                 }
00150             ~clReBufferT ()
00151                 { }
00158             void Put (const TReBuffer_t *fpSrcData, long lSrcCount)
00159                 {
00160                     CheckSize(lSrcCount);
00161                     if (lPutIndex >= lSize) lPutIndex = 0;
00162                     long lTailSpace = lSize - lPutIndex;
00163                     TReBuffer_t *fpBuffer = Buffer;
00164                     if (lSrcCount > lTailSpace)
00165                     {
00166                         long lHeadSize = lSrcCount - lTailSpace;
00167                         memcpy(&fpBuffer[lPutIndex], fpSrcData, 
00168                             lTailSpace * sizeof(TReBuffer_t));
00169                         memcpy(fpBuffer, &fpSrcData[lTailSpace], 
00170                             lHeadSize * sizeof(TReBuffer_t));
00171                         lPutIndex = lHeadSize;
00172                     }
00173                     else
00174                     {
00175                         memcpy(&fpBuffer[lPutIndex], fpSrcData, 
00176                             lSrcCount * sizeof(TReBuffer_t));
00177                         lPutIndex += lSrcCount;
00178                     }
00179                     lCount += lSrcCount;
00180                 }
00186             void Put (clReBufferT &Src)
00187                 {
00188                     Put(Src.GetPtr(), Src.Size());
00189                 }
00199             bool Get (TReBuffer_t *fpDestData, long lDestCount)
00200                 {
00201                     if (lCount < lDestCount)
00202                         return false;
00203                     long lTailSize = lSize - lGetIndex;
00204                     TReBuffer_t *fpBuffer = Buffer;
00205                     if (lDestCount > lTailSize)
00206                     {
00207                         long lHeadSize = lDestCount - lTailSize;
00208                         memcpy(fpDestData, &fpBuffer[lGetIndex], 
00209                             lTailSize * sizeof(TReBuffer_t));
00210                         memcpy(&fpDestData[lTailSize], fpBuffer, 
00211                             lHeadSize * sizeof(TReBuffer_t));
00212                         lGetIndex = lHeadSize;
00213                     }
00214                     else
00215                     {
00216                         memcpy(fpDestData, &fpBuffer[lGetIndex], 
00217                             lDestCount * sizeof(TReBuffer_t));
00218                         lGetIndex += lDestCount;
00219                     }
00220                     lCount -= lDestCount;
00221                     return true;
00222                 }
00228             long GetCount () const
00229                 { 
00230                     return lCount; 
00231                 }
00232             long Size () const
00233                 {
00234                     return lCount;
00235                 }
00241             void SetSize (long lNewCount)
00242                 {
00243                     Clear();
00244                     CheckSize(lNewCount);
00245                     lCount = lNewCount;
00246                     lPutIndex = lCount;
00247                 }
00253             void Resize (long lNewCount)
00254                 {
00255                     if (lNewCount > lSize)
00256                         CheckSize(lNewCount - lCount);
00257                     lCount = lNewCount;
00258                     lPutIndex = lCount;
00259                 }
00263             void Clear ()
00264                 {
00265                     lSize = 0;
00266                     lPutIndex = 0;
00267                     lGetIndex = 0;
00268                     lCount = 0;
00269                     Buffer.Free();
00270                 }
00271             clReBufferT & operator= (const clReBufferT &Src)
00272                 {
00273                     SetSize(Src.Size());
00274                     Src.CopyGet((TReBuffer_t *) Buffer, Src.Size());
00275                     lPutIndex = Src.Size();
00276                     lCount = Src.Size();
00277                     return (*this);
00278                 }
00279             TReBuffer_t & operator[] (long lIndex)
00280                 {
00281                     if (lIndex >= lCount)
00282                     {
00283                         throw clException(
00284                             "clReBuffer::operator[]: Index >= Size()");
00285                     }
00286                     long lBufIdx = lGetIndex + lIndex;
00287                     if (lBufIdx >= lSize) lBufIdx -= lSize;
00288                     TReBuffer_t *fpBuffer = Buffer;
00289                     return fpBuffer[lIndex];
00290                 }
00291     };
00292 
00293 
00294 #endif

Generated on Tue Mar 2 19:46:45 2004 for libDSP by doxygen 1.3.6