00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
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