00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include "dsp/DSPOp.hh"
00024 #include "dsp/ReBufferT.hh"
00025
00026
00027 #ifndef DSPVECTOR_HH
00028 #define DSPVECTOR_HH
00029
00030 #define DSPV_SHORTER(x) ((Size() <= x.Size()) ? Size() : x.Size())
00031 #define DSPV_SHORTER2(x, y) ((x.Size() <= y.Size()) ? x.Size() : y.Size())
00032
00033
00034 template <class TDSPVector_t> class clDSPVector :
00035 public clReBufferT<TDSPVector_t>
00036 {
00037 long lFFTSize;
00038 clDSPOp DSP;
00039 protected:
00040 TDSPVector_t * GetPtr ()
00041 { return clReBufferT<TDSPVector_t>::GetPtr(); }
00042 public:
00043 long Size ()
00044 { return clReBufferT<TDSPVector_t>::Size(); }
00045 void SetSize (long lNewSize)
00046 { clReBufferT<TDSPVector_t>::SetSize(lNewSize); }
00047
00048 clDSPVector ()
00049 {
00050 lFFTSize = 0;
00051 }
00052 clDSPVector (const clDSPVector &CopySrc)
00053 {
00054 lFFTSize = 0;
00055 *this = CopySrc;
00056 }
00057 clDSPVector (long lNewSize) :
00058 clReBufferT<TDSPVector_t>(lNewSize)
00059 {
00060 lFFTSize = 0;
00061 }
00062 clDSPVector (const TDSPVector_t *fpSrcData, long lSrcCount) :
00063 clReBufferT<TDSPVector_t>(fpSrcData, lSrcCount)
00064 {
00065 lFFTSize = 0;
00066 }
00067 ~clDSPVector () {}
00068 TDSPVector_t * Ptr()
00069 {
00070 return GetPtr();
00071 }
00072
00073 clDSPVector operator+ (const TDSPVector_t &Src)
00074 {
00075 clDSPVector<TDSPVector_t> Temp(*this);
00076 DSP.Add(Temp.Ptr(), Src, Temp.Size());
00077 return Temp;
00078 }
00079 clDSPVector operator+ (clDSPVector &Src)
00080 {
00081 clDSPVector<TDSPVector_t> Temp(*this);
00082 DSP.Add(Temp.Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00083 return Temp;
00084 }
00085 clDSPVector operator- (const TDSPVector_t &Src)
00086 {
00087 clDSPVector<TDSPVector_t> Temp(*this);
00088 DSP.Sub(Temp.Ptr(), Src, Temp.Size());
00089 return Temp;
00090 }
00091 clDSPVector operator- (clDSPVector &Src)
00092 {
00093 clDSPVector<TDSPVector_t> Temp(*this);
00094 DSP.Sub(Temp.Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00095 return Temp;
00096 }
00097 clDSPVector operator* (const TDSPVector_t &Src)
00098 {
00099 clDSPVector<TDSPVector_t> Temp(*this);
00100 DSP.Mul(Temp.Ptr(), Src, Temp.Size());
00101 return Temp;
00102 }
00103 clDSPVector operator* (clDSPVector &Src)
00104 {
00105 clDSPVector<TDSPVector_t> Temp(*this);
00106 DSP.Mul(Temp.Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00107 return Temp;
00108 }
00109 clDSPVector operator/ (const TDSPVector_t &Src)
00110 {
00111 clDSPVector<TDSPVector_t> Temp(*this);
00112 DSP.Div(Temp.Ptr(), Src, Temp.Size());
00113 return Temp;
00114 }
00115 clDSPVector operator/ (clDSPVector &Src)
00116 {
00117 clDSPVector<TDSPVector_t> Temp(*this);
00118 DSP.Div(Temp.Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00119 return Temp;
00120 }
00121 clDSPVector & operator+= (const TDSPVector_t &Src)
00122 {
00123 DSP.Add(Ptr(), Src, Size());
00124 return (*this);
00125 }
00126 clDSPVector & operator+= (clDSPVector &Src)
00127 {
00128 DSP.Add(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00129 return (*this);
00130 }
00131 clDSPVector & operator-= (const TDSPVector_t &Src)
00132 {
00133 DSP.Sub(Ptr(), Src, Size());
00134 return (*this);
00135 }
00136 clDSPVector & operator-= (clDSPVector &Src)
00137 {
00138 DSP.Sub(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00139 return (*this);
00140 }
00141 clDSPVector & operator*= (const TDSPVector_t &Src)
00142 {
00143 DSP.Mul(Ptr(), Src, Size());
00144 return (*this);
00145 }
00146 clDSPVector & operator*= (clDSPVector &Src)
00147 {
00148 DSP.Mul(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00149 return (*this);
00150 }
00151 clDSPVector & operator/= (const TDSPVector_t &Src)
00152 {
00153 DSP.Div(Ptr(), Src, Size());
00154 return (*this);
00155 }
00156 clDSPVector & operator/= (clDSPVector &Src)
00157 {
00158 DSP.Div(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00159 return (*this);
00160 }
00161
00162 clDSPVector & Zero ()
00163 {
00164 DSP.Zero(Ptr(), Size());
00165 return (*this);
00166 }
00167 clDSPVector & Set (const TDSPVector_t &Src)
00168 {
00169 DSP.Set(Ptr(), Src, Size());
00170 return (*this);
00171 }
00172 clDSPVector & Set (const TDSPVector_t *Src, long lSrcCount)
00173 {
00174 SetSize(lSrcCount);
00175 DSP.Set(Ptr(), Src, lSrcCount);
00176 return (*this);
00177 }
00178 clDSPVector & Set (const TDSPVector_t &Src, long lStartIdx,
00179 long lSetCount)
00180 {
00181 DSP.Set(Ptr(), Src, lStartIdx, lSetCount, Size());
00182 return (*this);
00183 }
00184 clDSPVector & Clip (const TDSPVector_t &Src)
00185 {
00186 DSP.Clip(Ptr(), Src, Size());
00187 return (*this);
00188 }
00189 clDSPVector & Clip (const TDSPVector_t &Src1,
00190 const TDSPVector_t &Src2)
00191 {
00192 DSP.Clip(Ptr(), Src1, Src2, Size());
00193 return (*this);
00194 }
00195 clDSPVector & ClipZero ()
00196 {
00197 DSP.ClipZero(Ptr(), Size());
00198 return (*this);
00199 }
00200
00201 clDSPVector & MulC (clDSPVector &Src)
00202 {
00203 DSP.MulC(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00204 return (*this);
00205 }
00206 clDSPVector & MulC (clDSPVector &Src1, clDSPVector &Src2)
00207 {
00208 *this = Src1;
00209 DSP.MulC(Ptr(), Src2.Ptr(), DSPV_SHORTER(Src2));
00210 return (*this);
00211 }
00212 clDSPVector & Div1x ()
00213 {
00214 DSP.Div1x(Ptr(), Size());
00215 return (*this);
00216 }
00217 clDSPVector & MulAdd (TDSPVector_t fMul, TDSPVector_t fAdd)
00218 {
00219 DSP.MulAdd(Ptr(), fMul, fAdd, Size());
00220 }
00221 clDSPVector & Square ()
00222 {
00223 DSP.Square(Ptr(), Size());
00224 return (*this);
00225 }
00226 clDSPVector & Abs ()
00227 {
00228 DSP.Abs(Ptr(), Size());
00229 return (*this);
00230 }
00231 clDSPVector & Sqrt ()
00232 {
00233 DSP.Sqrt(Ptr(), Size());
00234 return (*this);
00235 }
00236 clDSPVector & Negate ()
00237 {
00238 DSP.Negate(Ptr(), Size());
00239 return (*this);
00240 }
00241 clDSPVector & Normalize ()
00242 {
00243 DSP.Normalize(Ptr(), Size());
00244 return (*this);
00245 }
00246 clDSPVector & Reverse ()
00247 {
00248 DSP.Reverse(Ptr(), Size());
00249 return (*this);
00250 }
00251 clDSPVector & Reverse (clDSPVector &Src)
00252 {
00253 SetSize(Src.Size());
00254 DSP.Reverse(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00255 return (*this);
00256 }
00257 clDSPVector & Scale ()
00258 {
00259 DSP.Scale(Ptr(), Size());
00260 return (*this);
00261 }
00262 clDSPVector & Scale (clDSPVector &Src)
00263 {
00264 SetSize(Src.Size());
00265 DSP.Scale(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00266 return (*this);
00267 }
00268 clDSPVector & Scale01 ()
00269 {
00270 DSP.Scale01(Ptr(), Size());
00271 return (*this);
00272 }
00273 clDSPVector & Scale01 (clDSPVector &Src)
00274 {
00275 SetSize(Src.Size());
00276 DSP.Scale01(Ptr(), Src.Ptr(), DSPV_SHOTER(Src));
00277 return (*this);
00278 }
00279 clDSPVector & Sort ()
00280 {
00281 DSP.Sort(Ptr(), Size());
00282 return (*this);
00283 }
00284 clDSPVector & Sort (clDSPVector &Src)
00285 {
00286 *this = Src;
00287 DSP.Sort(Ptr(), Size());
00288 return (*this);
00289 }
00290
00291 TDSPVector_t Sum ()
00292 {
00293 return DSP.Sum(Ptr(), Size());
00294 }
00295 TDSPVector_t Conv (clDSPVector &Src)
00296 {
00297 return DSP.Convolve(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00298 }
00299 clDSPVector & Conv (clDSPVector &Src1, clDSPVector &Src2)
00300 {
00301 SetSize(DSPV_SHORTER2(Src1, Src2));
00302 DSP.Convolve(Ptr(), Src1.Ptr(), Src2.Ptr(),
00303 DSPV_SHORTER2(Src1, Src2));
00304 return (*this);
00305 }
00306 TDSPVector_t Corr (clDSPVector &Src)
00307 {
00308 return DSP.Correlate(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00309 }
00310 clDSPVector & Corr (clDSPVector &Src1, clDSPVector &Src2)
00311 {
00312 SetSize(DSPV_SHORTER2(Src1, Src2));
00313 DSP.Correlate(Ptr(), Src1.Ptr(), Src2.Ptr(),
00314 DSPV_SHORTER2(Src1, Src2));
00315 return (*this);
00316 }
00317 TDSPVector_t AutoCorr ()
00318 {
00319 return DSP.AutoCorrelate(Ptr(), Size());
00320 }
00321 clDSPVector & AutoCorr (clDSPVector &Src)
00322 {
00323 SetSize(Src.Size());
00324 DSP.AutoCorrelate(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00325 }
00326 TDSPVector_t CrossCorr (clDSPVector &Src)
00327 {
00328 return DSP.CrossCorr(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00329 }
00330 TDSPVector_t CrossCorr (clDSPVector &Src, long lDelay)
00331 {
00332 return DSP.DelCrossCorr(Ptr(), Src.Ptr(), lDelay,
00333 DSPV_SHORTER(Src));
00334 }
00335 clDSPVector & CrossCorr (clDSPVector &Src1, clDSPVector &Src2,
00336 long *lpDelays, long lDelayCount)
00337 {
00338 SetSize(lDelayCount);
00339 DSP.DelCrossCorr(Ptr(), Src1.Ptr(), Src2.Ptr(),
00340 DSPV_SHORTER2(Src1, Src2), lpDelays, lDelayCount);
00341 return (*this);
00342 }
00343 TDSPVector_t DotProduct (clDSPVector &Src)
00344 {
00345 return DSP.DotProduct(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00346 }
00347 TDSPVector_t Mean ()
00348 {
00349 return DSP.Mean(Ptr(), Size());
00350 }
00351 TDSPVector_t Median ()
00352 {
00353 return DSP.Median(Ptr(), Size());
00354 }
00355 TDSPVector_t Energy ()
00356 {
00357 return DSP.Energy(Ptr(), Size());
00358 }
00359 TDSPVector_t RMS ()
00360 {
00361 return DSP.RMS(Ptr(), Size());
00362 }
00363 TDSPVector_t PeakLevel ()
00364 {
00365 return DSP.PeakLevel(Ptr(), Size());
00366 }
00367 void MinMax (TDSPVector_t &fMin, TDSPVector_t &fMax)
00368 {
00369 DSP.MinMax(&fMin, &fMax, Ptr(), Size());
00370 }
00371 void StdDev (TDSPVector_t &fStdDev, TDSPVector_t &fMean)
00372 {
00373 DSP.StdDev(&fStdDev, &fMean, Ptr(), Size());
00374 }
00375 void Variance (TDSPVector_t &fVariance, TDSPVector_t &fMean)
00376 {
00377 DSP.Variance(&fVariance, &fMean, Ptr(), Size());
00378 }
00379
00380 clDSPVector & Convert (const unsigned char *ucpSrc,
00381 long lSrcCount)
00382 {
00383 SetSize(lSrcCount);
00384 DSP.Convert(Ptr(), ucpSrc, lSrcCount);
00385 return (*this);
00386 }
00387 clDSPVector & Convert (const signed short *ipSrc, long lSrcCount,
00388 bool b12bit = false)
00389 {
00390 SetSize(lSrcCount);
00391 DSP.Convert(Ptr(), ipSrc, lSrcCount, b12bit);
00392 return (*this);
00393 }
00394 clDSPVector & Convert (const signed int *ipSrc, long lSrcCount,
00395 bool b24bit = false)
00396 {
00397 SetSize(lSrcCount);
00398 DSP.Convert(Ptr(), ipSrc, lSrcCount, b24bit);
00399 return (*this);
00400 }
00401 clDSPVector & Convert (const float *fpSrc, long lSrcCount)
00402 {
00403 SetSize(lSrcCount);
00404 DSP.Convert(Ptr(), fpSrc, lSrcCount);
00405 return (*this);
00406 }
00407 clDSPVector & Convert (const double *dpSrc, long lSrcCount)
00408 {
00409 SetSize(lSrcCount);
00410 DSP.Convert(Ptr(), dpSrc, lSrcCount);
00411 return (*this);
00412 }
00413 void Convert (unsigned char *ucpDest)
00414 {
00415 DSP.Convert(ucpDest, Ptr(), Size());
00416 }
00417 void Convert (signed short *ipDest, bool b12bit = false)
00418 {
00419 DSP.Convert(ipDest, Ptr(), Size(), b12bit);
00420 }
00421 void Convert (signed int *ipDest, bool b24bit = false)
00422 {
00423 DSP.Convert(ipDest, Ptr(), Size(), b24bit);
00424 }
00425 void Convert (float *fpDest)
00426 {
00427 DSP.Convert(fpDest, Ptr(), Size());
00428 }
00429 void Convert (double *dpDest)
00430 {
00431 DSP.Convert(dpDest, Ptr(), Size());
00432 }
00433 clDSPVector & CartToPolar ()
00434 {
00435 DSP.CartToPolar(Ptr(), Size());
00436 return (*this);
00437 }
00438 clDSPVector & CartToPolar (clDSPVector &Cart)
00439 {
00440 SetSize(Cart.Size());
00441 DSP.CartToPolar(Ptr(), Cart.Ptr(), Size());
00442 return (*this);
00443 }
00444 void CartToPolar (clDSPVector<float> &Magn,
00445 clDSPVector<float> &Phase)
00446 {
00447 Magn.SetSize(Size());
00448 Phase.SetSize(Size());
00449 DSP.CartToPolar(Magn.Ptr(), Phase.Ptr(), Ptr(), Size());
00450 }
00451 void CartToPolar (clDSPVector<double> &Magn,
00452 clDSPVector<double> &Phase)
00453 {
00454 Magn.SetSize(Size());
00455 Phase.SetSize(Size());
00456 DSP.CartToPolar(Magn.Ptr(), Phase.Ptr(), Ptr(), Size());
00457 }
00458 clDSPVector & PolarToCart ()
00459 {
00460 DSP.PolarToCart(Ptr(), Size());
00461 return (*this);
00462 }
00463 clDSPVector & PolarToCart (clDSPVector &Polar)
00464 {
00465 SetSize(Polar.Size());
00466 DSP.PolarToCart(Ptr(), Polar.Ptr(), Size());
00467 return (*this);
00468 }
00469 void PolarToCart (clDSPVector<float> &Real,
00470 clDSPVector<float> &Imag)
00471 {
00472 Real.SetSize(Size());
00473 Imag.SetSize(Size());
00474 DSP.PolarToCart(Real.Ptr(), Imag.Ptr(), Ptr(), Size());
00475 }
00476 void PolarToCart (clDSPVector<double> &Real,
00477 clDSPVector<double> &Imag)
00478 {
00479 Real.SetSize(Size());
00480 Imag.SetSize(Size());
00481 DSP.PolarToCart(Real.Ptr(), Imag.Ptr(), Ptr(), Size());
00482 }
00483 clDSPVector & Magnitude (clDSPVector<stSCplx> &Src)
00484 {
00485 SetSize(Src.Size());
00486 DSP.Magnitude(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00487 return (*this);
00488 }
00489 clDSPVector & Magnitude (clDSPVector<stDCplx> &Src)
00490 {
00491 SetSize(Src.Size());
00492 DSP.Magnitude(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00493 return (*this);
00494 }
00495 clDSPVector & Power (clDSPVector<stSCplx> &Src)
00496 {
00497 SetSize(Src.Size());
00498 DSP.Power(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00499 return (*this);
00500 }
00501 clDSPVector & Power (clDSPVector<stDCplx> &Src)
00502 {
00503 SetSize(Src.Size());
00504 DSP.Power(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00505 return (*this);
00506 }
00507 clDSPVector & Phase (clDSPVector<stSCplx> &Src)
00508 {
00509 SetSize(Src.Size());
00510 DSP.Phase(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00511 return (*this);
00512 }
00513 clDSPVector & Phase (clDSPVector<stDCplx> &Src)
00514 {
00515 SetSize(Src.Size());
00516 DSP.Phase(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00517 return (*this);
00518 }
00519 void PowerPhase (clDSPVector<float> &Power,
00520 clDSPVector<float> &Phase)
00521 {
00522 Power.SetSize(Size());
00523 Phase.SetSize(Size());
00524 DSP.PowerPhase(Power.Ptr(), Phase.Ptr(), Ptr(), Size());
00525 }
00526 void PowerPhase (clDSPVector<double> &Power,
00527 clDSPVector<double> &Phase)
00528 {
00529 Power.SetSize(Size());
00530 Phase.SetSize(Size());
00531 DSP.PowerPhase(Power.Ptr(), Phase.Ptr(), Ptr(), Size());
00532 }
00533 clDSPVector & Decimate (long lFactor)
00534 {
00535 DSP.Decimate(Ptr(), Ptr(), lFactor, Size());
00536 return (*this);
00537 }
00538 clDSPVector & Decimate (clDSPVector &Src, long lFactor)
00539 {
00540 SetSize(Src.Size() / lFactor);
00541 DSP.Decimate(Ptr(), Src.Ptr(), lFactor, Src.Size());
00542 return (*this);
00543 }
00544 clDSPVector & DecimateAvg (clDSPVector &Src, long lFactor)
00545 {
00546 SetSize(Src.Size() / lFactor);
00547 DSP.DecimateAvg(Ptr(), Src.Ptr(), lFactor, Src.Size());
00548 return (*this);
00549 }
00550 clDSPVector & Interpolate (clDSPVector &Src, long lFactor)
00551 {
00552 SetSize(Src.Size() * lFactor);
00553 DSP.Interpolate(Ptr(), Src.Ptr(), lFactor, Src.Size());
00554 return (*this);
00555 }
00556 clDSPVector & InterpolateAvg (clDSPVector &Src, long lFactor)
00557 {
00558 SetSize(Src.Size() * lFactor);
00559 DSP.InterpolateAvg(Ptr(), Src.Ptr(), lFactor, Src.Size());
00560 return (*this);
00561 }
00562 clDSPVector & Resample (clDSPVector &Src)
00563 {
00564 DSP.Resample(Ptr(), Size(), Src.Ptr(), Src.Size());
00565 return (*this);
00566 }
00567 clDSPVector & ResampleAvg (clDSPVector &Src)
00568 {
00569 DSP.ResampleAvg(Ptr(), Size(), Src.Ptr(), Src.Size());
00570 return (*this);
00571 }
00572
00573 clDSPVector & WinBartlett (long lWinSize)
00574 {
00575 SetSize(lWinSize);
00576 DSP.WinBartlett(Ptr(), Size());
00577 return (*this);
00578 }
00579 clDSPVector & WinBlackman (long lWinSize)
00580 {
00581 SetSize(lWinSize);
00582 DSP.WinBlackman(Ptr(), Size());
00583 return (*this);
00584 }
00585 clDSPVector & WinBlackman (long lWinSize, TDSPVector_t fAlpha)
00586 {
00587 SetSize(lWinSize);
00588 DSP.WinBlackman(Ptr(), Size(), fAlpha);
00589 return (*this);
00590 }
00591 clDSPVector & WinBlackmanHarris (long lWinSize)
00592 {
00593 SetSize(lWinSize);
00594 DSP.WinBlackmanHarris(Ptr(), Size());
00595 return (*this);
00596 }
00597 clDSPVector & WinCosTapered (long lWinSize)
00598 {
00599 SetSize(lWinSize);
00600 DSP.WinCosTapered(Ptr(), Size());
00601 return (*this);
00602 }
00603 clDSPVector & WinExactBlackman (long lWinSize)
00604 {
00605 SetSize(lWinSize);
00606 DSP.WinExactBlackman(Ptr(), Size());
00607 return (*this);
00608 }
00609 clDSPVector & WinExp (TDSPVector_t fZ, long lWinSize)
00610 {
00611 SetSize(lWinSize);
00612 DSP.WinExp(Ptr(), fZ, Size());
00613 return (*this);
00614 }
00615 clDSPVector & WinFlatTop (long lWinSize)
00616 {
00617 SetSize(lWinSize);
00618 DSP.WinFlatTop(Ptr(), Size());
00619 return (*this);
00620 }
00621 clDSPVector & WinGenericCos (clDSPVector &Coeffs, long lWinSize)
00622 {
00623 SetSize(lWinSize);
00624 DSP.WinGenericCos(Ptr(), Size(),
00625 Coeffs.Ptr(), Coeffs.Size());
00626 return (*this);
00627 }
00628 clDSPVector & WinHamming (long lWinSize)
00629 {
00630 SetSize(lWinSize);
00631 DSP.WinHamming(Ptr(), Size());
00632 return (*this);
00633 }
00634 clDSPVector & WinHanning (long lWinSize)
00635 {
00636 SetSize(lWinSize);
00637 DSP.WinHanning(Ptr(), Size());
00638 return (*this);
00639 }
00640 clDSPVector & WinKaiser (TDSPVector_t fBeta, long lWinSize)
00641 {
00642 SetSize(lWinSize);
00643 DSP.WinKaiser(Ptr(), fBeta, Size());
00644 return (*this);
00645 }
00646 clDSPVector & WinKaiserBessel (TDSPVector_t fAlpha, long lWinSize)
00647 {
00648 SetSize(lWinSize);
00649 DSP.WinKaiserBessel(Ptr(), fAlpha, Size());
00650 return (*this);
00651 }
00652 clDSPVector & WinTukey (long lWinSize)
00653 {
00654 SetSize(lWinSize);
00655 DSP.WinTukey(Ptr(), Size());
00656 return (*this);
00657 }
00658 clDSPVector & WinDolphChebyshev (TDSPVector_t fGamma, long lWinSize)
00659 {
00660 SetSize(lWinSize);
00661 DSP.WinDolphChebyshev(Ptr(), fGamma, Size());
00662 return (*this);
00663 }
00664
00665 clDSPVector & Mix (clDSPVector &Src, long lChCount)
00666 {
00667 SetSize(Src.Size() / lChCount);
00668 DSP.Mix(Ptr(), Src.Ptr(), lChCount, Size());
00669 return (*this);
00670 }
00671 clDSPVector & Extract (clDSPVector &Src, long lCh, long lChCount)
00672 {
00673 SetSize(Src.Size() / lChCount);
00674 DSP.Extract(Ptr(), Src.Ptr(), lCh, lChCount, Src.Size());
00675 return (*this);
00676 }
00677 clDSPVector & Pack (clDSPVector &Src, long lCh, long lChCount)
00678 {
00679 Resize(Src.Size() * lChCount);
00680 DSP.Pack(Ptr(), Src.Ptr(), lCh, lChCount, Src.Size());
00681 return (*this);
00682 }
00684 clDSPVector & FFTWConvert (clDSPVector &Src)
00685 {
00686 DSP.FFTWConvert(Ptr(), Src.Ptr(), Src.Size());
00687 return (*this);
00688 }
00689
00690 void FIRAllocate (clDSPVector &Src)
00691 {
00692 DSP.FIRAllocate(Src.Ptr(), Src.Size());
00693 }
00694 clDSPVector & FIRFilter ()
00695 {
00696 DSP.FIRFilter(Ptr(), Size());
00697 return (*this);
00698 }
00699 clDSPVector & FIRFilter (clDSPVector &Src)
00700 {
00701 SetSize(Src.Size());
00702 DSP.FIRFilter(Ptr(), Src.Ptr(), DSPV_SHORTER(Src));
00703 return (*this);
00704 }
00705 void FIRFree ()
00706 {
00707 DSP.FIRFree();
00708 }
00709
00710 void FFTInitialize (long lWinSize, bool bReal)
00711 {
00712 lFFTSize = lWinSize;
00713 DSP.FFTInitialize(lFFTSize, bReal);
00714 }
00715 clDSPVector & FFT (clDSPVector<float> &Src)
00716 {
00717 SetSize(lFFTSize / 2 + 1);
00718 DSP.FFTo(Ptr(), Src.Ptr());
00719 return (*this);
00720 }
00721 clDSPVector & FFT (clDSPVector<double> &Src)
00722 {
00723 SetSize(lFFTSize / 2 + 1);
00724 DSP.FFTo(Ptr(), Src.Ptr());
00725 return (*this);
00726 }
00727 clDSPVector & FFT (clDSPVector<stSCplx> &Src)
00728 {
00729 SetSize(lFFTSize);
00730 DSP.FFTo(Ptr(), Src.Ptr());
00731 return (*this);
00732 }
00733 clDSPVector & FFT (clDSPVector<stDCplx> &Src)
00734 {
00735 SetSize(lFFTSize);
00736 DSP.FFTo(Ptr(), Src.Ptr());
00737 return (*this);
00738 }
00739 clDSPVector & IFFT (clDSPVector<stSCplx> &Src)
00740 {
00741 SetSize(lFFTSize);
00742 DSP.IFFTo(Ptr(), Src.Ptr());
00743 return (*this);
00744 }
00745 clDSPVector & IFFT (clDSPVector<stDCplx> &Src)
00746 {
00747 SetSize(lFFTSize);
00748 DSP.IFFTo(Ptr(), Src.Ptr());
00749 return (*this);
00750 }
00751 void FFTUninitialize ()
00752 {
00753 DSP.FFTUninitialize();
00754 }
00755
00756 void DCTInitialize (long lWinSize)
00757 {
00758 lFFTSize = lWinSize;
00759 DSP.DCTInitialize(lWinSize);
00760 }
00761 void DCTUninitialize ()
00762 {
00763 DSP.DCTUninitialize();
00764 }
00765 clDSPVector & DCT ()
00766 {
00767 DSP.DCTi(Ptr());
00768 return (*this);
00769 }
00770 clDSPVector & DCT (clDSPVector<float> &Src)
00771 {
00772 SetSize(lFFTSize);
00773 DSP.DCTo(Ptr(), Src.Ptr());
00774 return (*this);
00775 }
00776 clDSPVector & DCT (clDSPVector<double> &Src)
00777 {
00778 SetSize(lFFTSize);
00779 DSP.DCTo(Ptr(), Src.Ptr());
00780 return (*this);
00781 }
00782 clDSPVector & IDCT ()
00783 {
00784 DSP.IDCTi(Ptr());
00785 return (*this);
00786 }
00787 clDSPVector & IDCT (clDSPVector<float> &Src)
00788 {
00789 SetSize(lFFTSize);
00790 DSP.IDCTo(Ptr(), Src.Ptr());
00791 return (*this);
00792 }
00793 clDSPVector & IDCT (clDSPVector<double> &Src)
00794 {
00795 SetSize(lFFTSize);
00796 DSP.IDCTo(Ptr(), Src.Ptr());
00797 return (*this);
00798 }
00799 };
00800
00801
00802 #endif
