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

Filter.cc

Go to the documentation of this file.
00001 /*
00002 
00003     FFT filter
00004     Copyright (C) 1999-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 <stdio.h>
00024 #include <stdlib.h>
00025 #ifdef USE_INTEL_MATH
00026     #include <mathimf.h>
00027 #else
00028     #include <math.h>
00029 #endif
00030 #include <float.h>
00031 
00032 #include "dsp/Filter.hh"
00033 
00034 
00035 void clFilter::InitCoeffsS ()
00036 {
00037     long lCoeffCntr;
00038     stpSCplx spSCCoeffs = CCoeffs;
00039 
00040     for (lCoeffCntr = 0; lCoeffCntr < lSpectPoints; lCoeffCntr++)
00041     {
00042         spSCCoeffs[lCoeffCntr].R = 1.0f;
00043         spSCCoeffs[lCoeffCntr].I = 0.0f;
00044     }
00045     ReadyFilterS();
00046 }
00047 
00048 
00049 void clFilter::InitCoeffsD ()
00050 {
00051     long lCoeffCntr;
00052     stpDCplx spDCCoeffs = CCoeffs;
00053 
00054     for (lCoeffCntr = 0; lCoeffCntr < lSpectPoints; lCoeffCntr++)
00055     {
00056         spDCCoeffs[lCoeffCntr].R = 1.0;
00057         spDCCoeffs[lCoeffCntr].I = 0.0;
00058     }
00059     ReadyFilterD();
00060 }
00061 
00062 
00063 void clFilter::ReadyFilterS ()
00064 {
00065     float *fpCoeffWin = CoeffWin;
00066     float *fpProc = Proc;
00067     stpSCplx spSCCoeffs = CCoeffs;
00068     
00069     fpCoeffWin = CoeffWin;
00070     IFFTo(fpProc, spSCCoeffs);
00071     Mul(fpProc, fpCoeffWin, lFFTSize);
00072     FFTi(spSCCoeffs, fpProc);
00073 }
00074 
00075 
00076 void clFilter::ReadyFilterD ()
00077 {
00078     double *dpCoeffWin = CoeffWin;
00079     double *dpProc = Proc;
00080     stpDCplx spDCCoeffs = CCoeffs;
00081 
00082     dpCoeffWin = CoeffWin;
00083     IFFTo(dpProc, spDCCoeffs);
00084     Mul(dpProc, dpCoeffWin, lFFTSize);
00085     FFTi(spDCCoeffs, dpProc);
00086 }
00087 
00088 
00089 float clFilter::GetKaiserBeta (float fAlpha)
00090 {
00091     if (fAlpha < 21.0f)
00092     {
00093         return 0.0f;
00094     }
00095     else if (fAlpha >= 21.0f && fAlpha <= 50.0f)
00096     {
00097         return (0.5842f * powf(fAlpha - 21.0f, 0.4f) + 
00098             0.07886f * (fAlpha - 21.0f));
00099     }
00100     else
00101     {
00102         return (0.1102f * (fAlpha - 8.7f));
00103     }
00104 }
00105 
00106 
00107 double clFilter::GetKaiserBeta (double dAlpha)
00108 {
00109     if (dAlpha < 21.0)
00110     {
00111         return 0.0;
00112     }
00113     else if (dAlpha >= 21.0 && dAlpha <= 50.0)
00114     {
00115         return (0.5842 * pow(dAlpha - 21.0, 0.4) + 
00116             0.07886 * (dAlpha - 21.0));
00117     }
00118     else
00119     {
00120         return (0.1102 * (dAlpha - 8.7));
00121     }
00122 }
00123 
00124 
00125 clFilter::clFilter ()
00126 {
00127     bInitialized = false;
00128 }
00129 
00130 
00131 clFilter::~clFilter ()
00132 {
00133     if (bInitialized) Uninitialize();
00134 }
00135 
00136 
00137 bool clFilter::Initialize (long lWindowSize, const float *fpFiltCoeffs,
00138     float fOverlap, float fBeta, int iSmoothWindow)
00139 {
00140     float *fpCoeffWin;
00141     float *fpTemp;
00142     double *dpTemp2;
00143     clDSPAlloc Temp;
00144     clDSPAlloc Temp2;
00145 
00146     if (bInitialized) Uninitialize();
00147     bInitialized = true;
00148     lFFTSize = lWindowSize;
00149     lHalfSize = lFFTSize / 2;
00150     lOldSize = (long) ((float) lWindowSize * fOverlap + 0.5f);
00151     lNewSize = lWindowSize - lOldSize;
00152     lSpectPoints = lFFTSize / 2 + 1;
00153     Prev.Size(lOldSize * sizeof(float));
00154     Proc.Size(lFFTSize * sizeof(float));
00155     CCoeffs.Size(lSpectPoints * sizeof(stSCplx));
00156     CProc.Size(lSpectPoints * sizeof(stSCplx));
00157     CoeffWin.Size(lFFTSize * sizeof(float));
00158 
00159     fpTemp = (float *) Temp.Size(lFFTSize * sizeof(float));
00160     dpTemp2 = (double *) Temp2.Size(lFFTSize * sizeof(double));
00161     fpCoeffWin = CoeffWin;
00162     switch (iSmoothWindow)
00163     {
00164         case FILTER_SMOOTH_NONE:
00165             Set(dpTemp2, 1.0, lFFTSize);
00166             break;
00167         case FILTER_SMOOTH_KAISER:
00168             WinKaiser(dpTemp2, (double) fBeta, lFFTSize);
00169             break;
00170         case FILTER_SMOOTH_KAISER_BESSEL:
00171             WinKaiserBessel(dpTemp2, 4.0, lFFTSize);
00172             break;
00173         case FILTER_SMOOTH_DOLPH_CHEBYSHEV:
00174             WinDolphChebyshev(dpTemp2, 1.0 / pow(2.0, 32.0), lFFTSize);
00175             break;
00176     }
00177     Convert(fpTemp, dpTemp2, lFFTSize);
00178     Copy(fpCoeffWin, &fpTemp[lHalfSize], lHalfSize);
00179     Copy(&fpCoeffWin[lHalfSize], fpTemp, lHalfSize);
00180 
00181     FFTInitialize(lFFTSize, true);
00182     if (fpFiltCoeffs != NULL)
00183     {
00184         SetCoeffs(fpFiltCoeffs);
00185     }
00186     else
00187     {
00188         InitCoeffsS();
00189     }
00190     Zero((float *) Prev, lOldSize);
00191 
00192     return true;
00193 }
00194 
00195 
00196 bool clFilter::Initialize (long lWindowSize, const double *dpFiltCoeffs,
00197     double dOverlap, double dBeta, int iSmoothWindow)
00198 {
00199     double *dpTemp;
00200     double *dpCoeffWin;
00201     clDSPAlloc Temp;
00202 
00203     if (bInitialized) Uninitialize();
00204     bInitialized = true;
00205     lFFTSize = lWindowSize;
00206     lHalfSize = lFFTSize / 2;
00207     lOldSize = (long) ((double) lWindowSize * dOverlap + 0.5);
00208     lNewSize = lWindowSize - lOldSize;
00209     lSpectPoints = lFFTSize / 2 + 1;
00210     Prev.Size(lOldSize * sizeof(double));
00211     Proc.Size(lFFTSize * sizeof(double));
00212     CCoeffs.Size(lSpectPoints * sizeof(stDCplx));
00213     CProc.Size(lSpectPoints * sizeof(stDCplx));
00214     CoeffWin.Size(lFFTSize * sizeof(double));
00215 
00216     dpTemp = (double *) Temp.Size(lFFTSize * sizeof(double));
00217     dpCoeffWin = CoeffWin;
00218     switch (iSmoothWindow)
00219     {
00220         case FILTER_SMOOTH_NONE:
00221             Set(dpTemp, 1.0, lFFTSize);
00222             break;
00223         case FILTER_SMOOTH_KAISER:
00224             WinKaiser(dpTemp, dBeta, lFFTSize);
00225             break;
00226         case FILTER_SMOOTH_KAISER_BESSEL:
00227             WinKaiserBessel(dpTemp, 4.0, lFFTSize);
00228             break;
00229         case FILTER_SMOOTH_DOLPH_CHEBYSHEV:
00230             WinDolphChebyshev(dpTemp, 1.0 / pow(2.0, 32.0), lFFTSize);
00231             break;
00232     }
00233     Copy(dpCoeffWin, &dpTemp[lHalfSize], lHalfSize);
00234     Copy(&dpCoeffWin[lHalfSize], dpTemp, lHalfSize);
00235 
00236     FFTInitialize(lFFTSize, true);
00237     if (dpFiltCoeffs != NULL)
00238     {
00239         SetCoeffs(dpFiltCoeffs);
00240     }
00241     else
00242     {
00243         InitCoeffsD();
00244     }
00245     Zero((double *) Prev, lOldSize);
00246 
00247     return true;
00248 }
00249 
00250 
00251 bool clFilter::InitFloat (long lWindowSize)
00252 {
00253     float *fpNoCoeffs = NULL;
00254 
00255     return Initialize(lWindowSize, fpNoCoeffs);
00256 }
00257 
00258 
00259 bool clFilter::InitDouble (long lWindowSize)
00260 {
00261     double *dpNoCoeffs = NULL;
00262 
00263     return Initialize(lWindowSize, dpNoCoeffs);
00264 }
00265 
00266 
00267 bool clFilter::InitializeLP (float fPassBand, float fStopBand,
00268     float fRippleRatio, float fOverlap)
00269 {
00270     long lWindowSize;
00271     long lTwosExp;
00272     float fDeltaOmega;
00273     float fBeta;
00274     float fCorner;
00275     float *fpNullPtr = NULL;
00276     
00277     if (fPassBand >= fStopBand) return false;
00278 
00279     fCorner = (fPassBand + fStopBand) * 0.5f;
00280     fDeltaOmega = fStopBand - fPassBand;
00281     lTwosExp = (long)
00282         (logf((fRippleRatio - 8.0f) / (2.285f * fDeltaOmega)) / 
00283         logf(2.0f) + 0.5f);
00284     lWindowSize = (long) powf(2.0f, lTwosExp);
00285     fBeta = GetKaiserBeta(fRippleRatio);
00286     
00287     if (!Initialize(lWindowSize, fpNullPtr, fOverlap, fBeta, 
00288         FILTER_SMOOTH_KAISER)) return false;
00289     DesignLP(&fCorner);
00290 
00291     return true;
00292 }
00293 
00294 
00295 bool clFilter::InitializeLP (double dPassBand, double dStopBand,
00296     double dRippleRatio, double dOverlap)
00297 {
00298     long lWindowSize;
00299     long lTwosExp;
00300     double dDeltaOmega;
00301     double dBeta;
00302     double dCorner;
00303     double *dpNullPtr = NULL;
00304     
00305     if (dPassBand >= dStopBand) return false;
00306 
00307     dCorner = (dPassBand + dStopBand) * 0.5;
00308     dDeltaOmega = dStopBand - dPassBand;
00309     lTwosExp = (long)
00310         (log((dRippleRatio - 8.0) / (2.285 * dDeltaOmega)) / 
00311         log(2.0) + 0.5);
00312     lWindowSize = (long) pow(2.0, lTwosExp);
00313     dBeta = GetKaiserBeta(dRippleRatio);
00314     
00315     if (!Initialize(lWindowSize, dpNullPtr, dOverlap, dBeta, 
00316         FILTER_SMOOTH_KAISER)) return false;
00317     DesignLP(&dCorner);
00318 
00319     return true;
00320 }
00321 
00322 
00323 bool clFilter::InitializeHP (float fPassBand, float fStopBand,
00324     float fRippleRatio, float fOverlap)
00325 {
00326     long lWindowSize;
00327     long lTwosExp;
00328     float fDeltaOmega;
00329     float fBeta;
00330     float fCorner;
00331     float *fpNullPtr = NULL;
00332     
00333     if (fPassBand <= fStopBand) return false;
00334 
00335     fCorner = (fPassBand + fStopBand) * 0.5f;
00336     fDeltaOmega = fPassBand - fStopBand;
00337     lTwosExp = (long)
00338         (logf((fRippleRatio - 8.0f) / (2.285f * fDeltaOmega)) / 
00339         logf(2.0f) + 0.5f);
00340     lWindowSize = (long) powf(2.0f, lTwosExp);
00341     fBeta = GetKaiserBeta(fRippleRatio);
00342     
00343     if (!Initialize(lWindowSize, fpNullPtr, fOverlap, fBeta, 
00344         FILTER_SMOOTH_KAISER)) return false;
00345     DesignHP(&fCorner);
00346 
00347     return true;
00348 }
00349 
00350 
00351 bool clFilter::InitializeHP (double dPassBand, double dStopBand,
00352     double dRippleRatio, double dOverlap)
00353 {
00354     long lWindowSize;
00355     long lTwosExp;
00356     double dDeltaOmega;
00357     double dBeta;
00358     double dCorner;
00359     double *dpNullPtr = NULL;
00360     
00361     if (dPassBand <= dStopBand) return false;
00362 
00363     dCorner = (dPassBand + dStopBand) * 0.5;
00364     dDeltaOmega = dPassBand - dStopBand;
00365     lTwosExp = (long)
00366         (log((dRippleRatio - 8.0) / (2.285 * dDeltaOmega)) / 
00367         log(2.0) + 0.5);
00368     lWindowSize = (long) pow(2.0, lTwosExp);
00369     dBeta = GetKaiserBeta(dRippleRatio);
00370     
00371     if (!Initialize(lWindowSize, dpNullPtr, dOverlap, dBeta, 
00372         FILTER_SMOOTH_KAISER)) return false;
00373     DesignHP(&dCorner);
00374 
00375     return true;
00376 }
00377 
00378 
00379 void clFilter::Uninitialize ()
00380 {
00381     FFTUninitialize();
00382     CoeffWin.Free();
00383     Prev.Free();
00384     Proc.Free();
00385     CCoeffs.Free();
00386     CProc.Free();
00387     InBuf.Clear();
00388     OutBuf.Clear();
00389 }
00390 
00391 
00392 void clFilter::SetCoeffs (const float *fpFiltCoeffs)
00393 {
00394     long lCoeffCntr;
00395     stpSCplx spSCCoeffs = CCoeffs;
00396 
00397     for (lCoeffCntr = 0; lCoeffCntr < lSpectPoints; lCoeffCntr++)
00398     {
00399         spSCCoeffs[lCoeffCntr].R = fpFiltCoeffs[lCoeffCntr];
00400         spSCCoeffs[lCoeffCntr].I = 0.0f;
00401     }
00402     ReadyFilterS();
00403 }
00404 
00405 
00406 void clFilter::SetCoeffs (const double *dpFiltCoeffs)
00407 {
00408     long lCoeffCntr;
00409     stpDCplx spDCCoeffs = CCoeffs;
00410 
00411     for (lCoeffCntr = 0; lCoeffCntr < lSpectPoints; lCoeffCntr++)
00412     {
00413         spDCCoeffs[lCoeffCntr].R = dpFiltCoeffs[lCoeffCntr];
00414         spDCCoeffs[lCoeffCntr].I = 0.0;
00415     }
00416     ReadyFilterD();
00417 }
00418 
00419 
00420 void clFilter::SetCoeffs (const stpSCplx spSFiltCoeffs, bool bSmooth)
00421 {
00422     stpSCplx spSCCoeffs = CCoeffs;
00423 
00424     Copy(spSCCoeffs, spSFiltCoeffs, lSpectPoints);
00425     if (bSmooth) ReadyFilterS();
00426 }
00427 
00428 
00429 void clFilter::SetCoeffs (const stpDCplx spDFiltCoeffs, bool bSmooth)
00430 {
00431     stpDCplx spDCCoeffs = CCoeffs;
00432 
00433     Copy(spDCCoeffs, spDFiltCoeffs, lSpectPoints);
00434     if (bSmooth) ReadyFilterD();
00435 }
00436 
00437 
00438 void clFilter::GetCoeffs (float *fpFiltCoeffs)
00439 {
00440     long lCoeffCntr;
00441     stpSCplx spSCCoeffs = CCoeffs;
00442 
00443     for (lCoeffCntr = 0; lCoeffCntr < lSpectPoints; lCoeffCntr++)
00444     {
00445         fpFiltCoeffs[lCoeffCntr] = spSCCoeffs[lCoeffCntr].R;
00446     }
00447 }
00448 
00449 
00450 void clFilter::GetCoeffs (double *dpFiltCoeffs)
00451 {
00452     long lCoeffCntr;
00453     stpDCplx spDCCoeffs = CCoeffs;
00454 
00455     for (lCoeffCntr = 0; lCoeffCntr < lSpectPoints; lCoeffCntr++)
00456     {
00457         dpFiltCoeffs[lCoeffCntr] = spDCCoeffs[lCoeffCntr].R;
00458     }
00459 }
00460 
00461 
00462 void clFilter::GetCoeffs (stpSCplx spSFiltCoeffs)
00463 {
00464     stpSCplx spSCCoeffs = CCoeffs;
00465 
00466     Copy(spSFiltCoeffs, spSCCoeffs, lSpectPoints);
00467 }
00468 
00469 
00470 void clFilter::GetCoeffs (stpDCplx spDFiltCoeffs)
00471 {
00472     stpDCplx spDCCoeffs = CCoeffs;
00473 
00474     Copy(spDFiltCoeffs, spDCCoeffs, lSpectPoints);
00475 }
00476 
00477 
00478 long clFilter::GetDelay ()
00479 {
00480     return (lOldSize / 2);
00481 }
00482 
00483 
00484 void clFilter::Put (const float *fpSrcData, long lSrcCount)
00485 {
00486     float *fpPrev = Prev;
00487     float *fpProc = Proc;
00488     stpSCplx spSCCoeffs = CCoeffs;
00489     stpSCplx spSCProc = CProc;
00490 
00491     InBuf.Put(fpSrcData, lSrcCount);
00492     while (InBuf.Get(&fpProc[lOldSize], lNewSize))
00493     {
00494         Copy(fpProc, fpPrev, lOldSize);
00495         Copy(fpPrev, &fpProc[lNewSize], lOldSize);
00496 
00497         FFTi(spSCProc, fpProc);
00498         Mul(spSCProc, spSCCoeffs, lSpectPoints);
00499         IFFTo(fpProc, spSCProc);
00500 
00501         OutBuf.Put(&fpProc[lOldSize >> 1], lNewSize);
00502     }
00503 }
00504 
00505 
00506 void clFilter::Put (const double *dpSrcData, long lSrcCount)
00507 {
00508     double *dpPrev = Prev;
00509     double *dpProc = Proc;
00510     stpDCplx spDCCoeffs = CCoeffs;
00511     stpDCplx spDCProc = CProc;
00512 
00513     InBuf.Put(dpSrcData, lSrcCount);
00514     while (InBuf.Get(&dpProc[lOldSize], lNewSize))
00515     {
00516         Copy(dpProc, dpPrev, lOldSize);
00517         Copy(dpPrev, &dpProc[lNewSize], lOldSize);
00518 
00519         FFTi(spDCProc, dpProc);
00520         Mul(spDCProc, spDCCoeffs, lSpectPoints);
00521         IFFTo(dpProc, spDCProc);
00522 
00523         OutBuf.Put(&dpProc[lOldSize >> 1], lNewSize);
00524     }
00525 }
00526 
00527 
00528 void clFilter::Put (const float *fpSrcData, long lSrcCount, 
00529     const stpSCplx spSCCoeffs)
00530 {
00531     float *fpPrev = Prev;
00532     float *fpProc = Proc;
00533     stpSCplx spSCProc = CProc;
00534 
00535     InBuf.Put(fpSrcData, lSrcCount);
00536     while (InBuf.Get(&fpProc[lOldSize], lNewSize))
00537     {
00538         Copy(fpProc, fpPrev, lOldSize);
00539         Copy(fpPrev, &fpProc[lNewSize], lOldSize);
00540 
00541         FFTi(spSCProc, fpProc);
00542         Mul(spSCProc, spSCCoeffs, lSpectPoints);
00543         IFFTo(fpProc, spSCProc);
00544 
00545         OutBuf.Put(&fpProc[lOldSize >> 1], lNewSize);
00546     }
00547 }
00548 
00549 
00550 void clFilter::Put (const double *dpSrcData, long lSrcCount, 
00551     const stpDCplx spDCCoeffs)
00552 {
00553     double *dpPrev = Prev;
00554     double *dpProc = Proc;
00555     stpDCplx spDCProc = CProc;
00556 
00557     InBuf.Put(dpSrcData, lSrcCount);
00558     while (InBuf.Get(&dpProc[lOldSize], lNewSize))
00559     {
00560         Copy(dpProc, dpPrev, lOldSize);
00561         Copy(dpPrev, &dpProc[lNewSize], lOldSize);
00562 
00563         FFTi(spDCProc, dpProc);
00564         Mul(spDCProc, spDCCoeffs, lSpectPoints);
00565         IFFTo(dpProc, spDCProc);
00566 
00567         OutBuf.Put(&dpProc[lOldSize >> 1], lNewSize);
00568     }
00569 }
00570 
00571 
00572 bool clFilter::Get (float *fpDestData, long lDestCount)
00573 {
00574     return OutBuf.Get(fpDestData, lDestCount);
00575 }
00576 
00577 
00578 bool clFilter::Get (double *dpDestData, long lDestCount)
00579 {
00580     return OutBuf.Get(dpDestData, lDestCount);
00581 }
00582 
00583 
00584 void clFilter::DesignLP (float *fpCorner, bool bDCBlock)
00585 {
00586     long lPassCount;
00587     float *fpCoeffs;
00588     clDSPAlloc Coeffs(lSpectPoints * sizeof(float));
00589 
00590     fpCoeffs = Coeffs;
00591     lPassCount = (long) floor((float) lSpectPoints * (*fpCorner));
00592     *fpCorner = (float) lPassCount / (float) lSpectPoints;
00593     Zero(fpCoeffs, lSpectPoints);
00594     Set(fpCoeffs, 1.0f, lPassCount);
00595     if (bDCBlock) fpCoeffs[0] = 0.0f;
00596     SetCoeffs(fpCoeffs);
00597 }
00598 
00599 
00600 void clFilter::DesignLP (double *dpCorner, bool bDCBlock)
00601 {
00602     long lPassCount;
00603     double *dpCoeffs;
00604     clDSPAlloc Coeffs(lSpectPoints * sizeof(double));
00605 
00606     dpCoeffs = Coeffs;
00607     lPassCount = (long) floor((double) lSpectPoints * (*dpCorner));
00608     *dpCorner = (double) lPassCount / (double) lSpectPoints;
00609     Zero(dpCoeffs, lSpectPoints);
00610     Set(dpCoeffs, 1.0, lPassCount);
00611     if (bDCBlock) dpCoeffs[0] = 0.0;
00612     SetCoeffs(dpCoeffs);
00613 }
00614 
00615 
00616 void clFilter::DesignLP (float *fpCorner, float fSampleRate, bool bDCBlock)
00617 {
00618     float fNyquist;
00619     float fNormCorner;
00620 
00621     fNyquist = fSampleRate / 2.0f;
00622     fNormCorner = (*fpCorner) / fNyquist;
00623     DesignLP(&fNormCorner, bDCBlock);
00624     *fpCorner = fNormCorner * fNyquist;
00625 }
00626 
00627 
00628 void clFilter::DesignLP (double *dpCorner, double dSampleRate, bool bDCBlock)
00629 {
00630     double dNyquist;
00631     double dNormCorner;
00632 
00633     dNyquist = dSampleRate / 2.0;
00634     dNormCorner = (*dpCorner) / dNyquist;
00635     DesignLP(&dNormCorner, bDCBlock);
00636     *dpCorner = dNormCorner * dNyquist;
00637 }
00638 
00639 
00640 void clFilter::DesignHP (float *fpCorner)
00641 {
00642     long lStopCount;
00643     float *fpCoeffs;
00644     clDSPAlloc Coeffs(lSpectPoints * sizeof(float));
00645 
00646     fpCoeffs = Coeffs;
00647     lStopCount = (long) ceil((float) lSpectPoints * (*fpCorner));
00648     *fpCorner = (float) lStopCount / (float) lSpectPoints;
00649     Set(fpCoeffs, 1.0f, lSpectPoints);
00650     Zero(fpCoeffs, lStopCount);
00651     SetCoeffs(fpCoeffs);
00652 }
00653 
00654 
00655 void clFilter::DesignHP (double *dpCorner)
00656 {
00657     long lStopCount;
00658     double *dpCoeffs;
00659     clDSPAlloc Coeffs(lSpectPoints * sizeof(double));
00660 
00661     dpCoeffs = Coeffs;
00662     lStopCount = (long) ceil((double) lSpectPoints * (*dpCorner));
00663     *dpCorner = (double) lStopCount / (double) lSpectPoints;
00664     Set(dpCoeffs, 1.0, lSpectPoints);
00665     Zero(dpCoeffs, lStopCount);
00666     SetCoeffs(dpCoeffs);
00667 }
00668 
00669 
00670 void clFilter::DesignHP (float *fpCorner, float fSampleRate)
00671 {
00672     float fNyquist;
00673     float fNormCorner;
00674 
00675     fNyquist = fSampleRate / 2.0f;
00676     fNormCorner = (*fpCorner) / fNyquist;
00677     DesignHP(&fNormCorner);
00678     *fpCorner = fNormCorner * fNyquist;
00679 }
00680 
00681 
00682 void clFilter::DesignHP (double *dpCorner, double dSampleRate)
00683 {
00684     double dNyquist;
00685     double dNormCorner;
00686 
00687     dNyquist = dSampleRate / 2.0;
00688     dNormCorner = (*dpCorner) / dNyquist;
00689     DesignHP(&dNormCorner);
00690     *dpCorner = dNormCorner * dNyquist;
00691 }
00692 
00693 
00694 void clFilter::DesignBP (float *fpLowCorner, float *fpHighCorner)
00695 {
00696     long lLowIdx;
00697     long lHighIdx;
00698     float *fpCoeffs;
00699     clDSPAlloc Coeffs(lSpectPoints * sizeof(float));
00700 
00701     fpCoeffs = Coeffs;
00702     lLowIdx = (long) ceil((float) lSpectPoints * (*fpLowCorner));
00703     lHighIdx = (long) floor((float) lSpectPoints * (*fpHighCorner));
00704     *fpLowCorner = (float) lLowIdx / (float) lSpectPoints;
00705     *fpHighCorner = (float) lHighIdx / (float) lSpectPoints;
00706     Zero(fpCoeffs, lSpectPoints);
00707     Set(&fpCoeffs[lLowIdx], 1.0f, lHighIdx - lLowIdx);
00708     SetCoeffs(fpCoeffs);
00709 }
00710 
00711 
00712 void clFilter::DesignBP (double *dpLowCorner, double *dpHighCorner)
00713 {
00714     long lLowIdx;
00715     long lHighIdx;
00716     double *dpCoeffs;
00717     clDSPAlloc Coeffs(lSpectPoints * sizeof(double));
00718 
00719     dpCoeffs = Coeffs;
00720     lLowIdx = (long) ceil((double) lSpectPoints * (*dpLowCorner));
00721     lHighIdx = (long) floor((double) lSpectPoints * (*dpHighCorner));
00722     *dpLowCorner = (double) lLowIdx / (double) lSpectPoints;
00723     *dpHighCorner = (double) lHighIdx / (double) lSpectPoints;
00724     Zero(dpCoeffs, lSpectPoints);
00725     Set(&dpCoeffs[lLowIdx], 1.0, lHighIdx - lLowIdx);
00726     SetCoeffs(dpCoeffs);
00727 }
00728 
00729 
00730 void clFilter::DesignBP (float *fpLowCorner, float *fpHighCorner, 
00731     float fSampleRate)
00732 {
00733     float fNyquist;
00734     float fNormLowCorner;
00735     float fNormHighCorner;
00736 
00737     fNyquist = fSampleRate / 2.0f;
00738     fNormLowCorner = (*fpLowCorner) / fNyquist;
00739     fNormHighCorner = (*fpHighCorner) / fNyquist;
00740     DesignBP(&fNormLowCorner, &fNormHighCorner);
00741     *fpLowCorner = fNormLowCorner * fNyquist;
00742     *fpHighCorner = fNormHighCorner * fNyquist;
00743 }
00744 
00745 
00746 void clFilter::DesignBP (double *dpLowCorner, double *dpHighCorner,
00747     double dSampleRate)
00748 {
00749     double dNyquist;
00750     double dNormLowCorner;
00751     double dNormHighCorner;
00752 
00753     dNyquist = dSampleRate / 2.0;
00754     dNormLowCorner = (*dpLowCorner) / dNyquist;
00755     dNormHighCorner = (*dpHighCorner) / dNyquist;
00756     DesignBP(&dNormLowCorner, &dNormHighCorner);
00757     *dpLowCorner = dNormLowCorner * dNyquist;
00758     *dpHighCorner = dNormHighCorner * dNyquist;
00759 }
00760 
00761 
00762 void clFilter::DesignBR (float *fpLowCorner, float *fpHighCorner)
00763 {
00764     long lLowIdx;
00765     long lHighIdx;
00766     float *fpCoeffs;
00767     clDSPAlloc Coeffs(lSpectPoints * sizeof(float));
00768 
00769     fpCoeffs = Coeffs;
00770     lLowIdx = (long) ceil((float) lSpectPoints * (*fpLowCorner));
00771     lHighIdx = (long) floor((float) lSpectPoints * (*fpHighCorner));
00772     *fpLowCorner = (float) lLowIdx / (float) lSpectPoints;
00773     *fpHighCorner = (float) lHighIdx / (float) lSpectPoints;
00774     Set(fpCoeffs, 1.0f, lSpectPoints);
00775     Zero(&fpCoeffs[lLowIdx], lHighIdx - lLowIdx);
00776     SetCoeffs(fpCoeffs);
00777 }
00778 
00779 
00780 void clFilter::DesignBR (double *dpLowCorner, double *dpHighCorner)
00781 {
00782     long lLowIdx;
00783     long lHighIdx;
00784     double *dpCoeffs;
00785     clDSPAlloc Coeffs(lSpectPoints * sizeof(double));
00786 
00787     dpCoeffs = Coeffs;
00788     lLowIdx = (long) ceil((double) lSpectPoints * (*dpLowCorner));
00789     lHighIdx = (long) floor((double) lSpectPoints * (*dpHighCorner));
00790     *dpLowCorner = (double) lLowIdx / (double) lSpectPoints;
00791     *dpHighCorner = (double) lHighIdx / (double) lSpectPoints;
00792     Set(dpCoeffs, 1.0, lSpectPoints);
00793     Zero(&dpCoeffs[lLowIdx], lHighIdx - lLowIdx);
00794     SetCoeffs(dpCoeffs);
00795 }
00796 
00797 
00798 void clFilter::DesignBR (float *fpLowCorner, float *fpHighCorner,
00799     float fSampleRate)
00800 {
00801     float fNyquist;
00802     float fNormLowCorner;
00803     float fNormHighCorner;
00804 
00805     fNyquist = fSampleRate / 2.0f;
00806     fNormLowCorner = (*fpLowCorner) / fNyquist;
00807     fNormHighCorner = (*fpHighCorner) / fNyquist;
00808     DesignBR(&fNormLowCorner, &fNormHighCorner);
00809     *fpLowCorner = fNormLowCorner * fNyquist;
00810     *fpHighCorner = fNormHighCorner * fNyquist;
00811 }
00812 
00813 
00814 void clFilter::DesignBR (double *dpLowCorner, double *dpHighCorner,
00815     double dSampleRate)
00816 {
00817     double dNyquist;
00818     double dNormLowCorner;
00819     double dNormHighCorner;
00820 
00821     dNyquist = dSampleRate / 2.0;
00822     dNormLowCorner = (*dpLowCorner) / dNyquist;
00823     dNormHighCorner = (*dpHighCorner) / dNyquist;
00824     DesignBR(&dNormLowCorner, &dNormHighCorner);
00825     *dpLowCorner = dNormLowCorner * dNyquist;
00826     *dpHighCorner = dNormHighCorner * dNyquist;
00827 }

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