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

DSPVector.hh

Go to the documentation of this file.
00001 /*
00002 
00003     Templatized DSP vector operations
00004     Copyright (C) 2001-2003 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 "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

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