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