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