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.h"
00024 #include "dsp/DSPOp.hh"
00025 #include "dsp/IIRCascade.hh"
00026 #include "dsp/FFTDecimator.hh"
00027 #include "dsp/FIRDecimator.hh"
00028 #include "dsp/IIRDecimator.hh"
00029 #include "dsp/RecDecimator.hh"
00030 #include "dsp/FFTInterpolator.hh"
00031 #include "dsp/FIRInterpolator.hh"
00032 #include "dsp/IIRInterpolator.hh"
00033 #include "dsp/RecInterpolator.hh"
00034 #include "dsp/Filter.hh"
00035 #include "dsp/ReBuffer.hh"
00036
00037
00038 #ifdef DSP_X86
00039 #include "dsp/X86.h"
00040
00041 extern bool bHave3DNow;
00042 extern bool bHaveSSE;
00043 #endif
00044
00045
00046 extern "C"
00047 {
00048
00049
00050
00051
00052 void dsp_init ()
00053 {
00054 #ifdef DSP_X86
00055 bHave3DNow = (dsp_x86_have_e3dnow()) ? true : false;
00056 bHaveSSE = (dsp_x86_have_sse2()) ? true : false;
00057 #endif
00058 }
00059
00060
00061 signed long dsp_roundf (float fSrc)
00062 {
00063 return clDSPOp::Round(fSrc);
00064 }
00065
00066
00067 signed long dsp_round (double dSrc)
00068 {
00069 return clDSPOp::Round(dSrc);
00070 }
00071
00072
00073 void dsp_addf (float *fpDest, float fSrc, long lCount)
00074 {
00075 clDSPOp::Add(fpDest, fSrc, lCount);
00076 }
00077
00078
00079 void dsp_add (double *dpDest, double dSrc, long lCount)
00080 {
00081 clDSPOp::Add(dpDest, dSrc, lCount);
00082 }
00083
00084
00085 void dsp_caddf (stpSCplx spDest, stSCplx sSrc, long lCount)
00086 {
00087 clDSPOp::Add(spDest, sSrc, lCount);
00088 }
00089
00090
00091 void dsp_cadd (stpDCplx spDest, stDCplx sSrc, long lCount)
00092 {
00093 clDSPOp::Add(spDest, sSrc, lCount);
00094 }
00095
00096
00097 void dsp_add2f (float *fpDest, const float *fpSrc, long lCount)
00098 {
00099 clDSPOp::Add(fpDest, fpSrc, lCount);
00100 }
00101
00102
00103 void dsp_add2 (double *dpDest, const double *dpSrc, long lCount)
00104 {
00105 clDSPOp::Add(dpDest, dpSrc, lCount);
00106 }
00107
00108
00109 void dsp_cadd2f (stpSCplx spDest, const stpSCplx spSrc, long lCount)
00110 {
00111 clDSPOp::Add(spDest, spSrc, lCount);
00112 }
00113
00114
00115 void dsp_cadd2 (stpDCplx spDest, const stpDCplx spSrc, long lCount)
00116 {
00117 clDSPOp::Add(spDest, spSrc, lCount);
00118 }
00119
00120
00121 void dsp_add3f (float *fpDest, const float *fpSrc1, const float *fpSrc2,
00122 long lCount)
00123 {
00124 clDSPOp::Add(fpDest, fpSrc1, fpSrc2, lCount);
00125 }
00126
00127
00128 void dsp_add3 (double *dpDest, const double *dpSrc1, const double *dpSrc2,
00129 long lCount)
00130 {
00131 clDSPOp::Add(dpDest, dpSrc1, dpSrc2, lCount);
00132 }
00133
00134
00135 void dsp_cadd3f (stpSCplx spDest, const stpSCplx spSrc1, const stpSCplx spSrc2,
00136 long lCount)
00137 {
00138 clDSPOp::Add(spDest, spSrc1, spSrc2, lCount);
00139 }
00140
00141
00142 void dsp_cadd3 (stpDCplx spDest, const stpDCplx spSrc1, const stpDCplx spSrc2,
00143 long lCount)
00144 {
00145 clDSPOp::Add(spDest, spSrc1, spSrc2, lCount);
00146 }
00147
00148
00149 void dsp_subf (float *fpDest, float fSrc, long lCount)
00150 {
00151 clDSPOp::Sub(fpDest, fSrc, lCount);
00152 }
00153
00154
00155 void dsp_sub (double *dpDest, double dSrc, long lCount)
00156 {
00157 clDSPOp::Sub(dpDest, dSrc, lCount);
00158 }
00159
00160
00161 void dsp_csubf (stpSCplx spDest, stSCplx sSrc, long lCount)
00162 {
00163 clDSPOp::Sub(spDest, sSrc, lCount);
00164 }
00165
00166
00167 void dsp_csub (stpDCplx spDest, stDCplx sSrc, long lCount)
00168 {
00169 clDSPOp::Sub(spDest, sSrc, lCount);
00170 }
00171
00172
00173 void dsp_sub2f (float *fpDest, const float *fpSrc, long lCount)
00174 {
00175 clDSPOp::Sub(fpDest, fpSrc, lCount);
00176 }
00177
00178
00179 void dsp_sub2 (double *dpDest, const double *dpSrc, long lCount)
00180 {
00181 clDSPOp::Sub(dpDest, dpSrc, lCount);
00182 }
00183
00184
00185 void dsp_csub2f (stpSCplx spDest, const stpSCplx spSrc, long lCount)
00186 {
00187 clDSPOp::Sub(spDest, spSrc, lCount);
00188 }
00189
00190
00191 void dsp_csub2 (stpDCplx spDest, const stpDCplx spSrc, long lCount)
00192 {
00193 clDSPOp::Sub(spDest, spSrc, lCount);
00194 }
00195
00196
00197 void dsp_sub3f (float *fpDest, const float *fpSrc1, const float *fpSrc2,
00198 long lCount)
00199 {
00200 clDSPOp::Sub(fpDest, fpSrc1, fpSrc2, lCount);
00201 }
00202
00203
00204 void dsp_sub3 (double *dpDest, const double *dpSrc1, const double *dpSrc2,
00205 long lCount)
00206 {
00207 clDSPOp::Sub(dpDest, dpSrc1, dpSrc2, lCount);
00208 }
00209
00210
00211 void dsp_csub3f (stpSCplx spDest, const stpSCplx spSrc1, const stpSCplx spSrc2,
00212 long lCount)
00213 {
00214 clDSPOp::Sub(spDest, spSrc1, spSrc2, lCount);
00215 }
00216
00217
00218 void dsp_csub3 (stpDCplx spDest, const stpDCplx spSrc1, const stpDCplx spSrc2,
00219 long lCount)
00220 {
00221 clDSPOp::Sub(spDest, spSrc1, spSrc2, lCount);
00222 }
00223
00224
00225 void dsp_mulf (float *fpDest, float fSrc, long lCount)
00226 {
00227 clDSPOp::Mul(fpDest, fSrc, lCount);
00228 }
00229
00230
00231 void dsp_mul (double *dpDest, double dSrc, long lCount)
00232 {
00233 clDSPOp::Mul(dpDest, dSrc, lCount);
00234 }
00235
00236
00237 void dsp_chmulf (stpSCplx spDest, float fSrc, long lCount)
00238 {
00239 clDSPOp::Mul(spDest, fSrc, lCount);
00240 }
00241
00242
00243 void dsp_chmul (stpDCplx spDest, double dSrc, long lCount)
00244 {
00245 clDSPOp::Mul(spDest, dSrc, lCount);
00246 }
00247
00248
00249 void dsp_cmulf (stpSCplx spDest, stSCplx sSrc, long lCount)
00250 {
00251 clDSPOp::Mul(spDest, sSrc, lCount);
00252 }
00253
00254
00255 void dsp_cmul (stpDCplx spDest, stDCplx sSrc, long lCount)
00256 {
00257 clDSPOp::Mul(spDest, sSrc, lCount);
00258 }
00259
00260
00261 void dsp_mulf_nip (float *fpDest, const float *fpSrc1, float fSrc2,
00262 long lCount)
00263 {
00264 clDSPOp::Mul(fpDest, fpSrc1, fSrc2, lCount);
00265 }
00266
00267
00268 void dsp_mul_nip (double *dpDest, const double *dpSrc1, double dSrc2,
00269 long lCount)
00270 {
00271 clDSPOp::Mul(dpDest, dpSrc1, dSrc2, lCount);
00272 }
00273
00274
00275 void dsp_mul2f (float *fpDest, const float *fpSrc, long lCount)
00276 {
00277 clDSPOp::Mul(fpDest, fpSrc, lCount);
00278 }
00279
00280
00281 void dsp_mul2 (double *dpDest, const double *dpSrc, long lCount)
00282 {
00283 clDSPOp::Mul(dpDest, dpSrc, lCount);
00284 }
00285
00286
00287 void dsp_chmul2f (stpSCplx spDest, const float *fpSrc, long lCount)
00288 {
00289 clDSPOp::Mul(spDest, fpSrc, lCount);
00290 }
00291
00292
00293 void dsp_chmul2 (stpDCplx spDest, const double *dpSrc, long lCount)
00294 {
00295 clDSPOp::Mul(spDest, dpSrc, lCount);
00296 }
00297
00298
00299 void dsp_cmul2f (stpSCplx spDest, const stpSCplx spSrc, long lCount)
00300 {
00301 clDSPOp::Mul(spDest, spSrc, lCount);
00302 }
00303
00304
00305 void dsp_cmul2 (stpDCplx spDest, const stpDCplx spSrc, long lCount)
00306 {
00307 clDSPOp::Mul(spDest, spSrc, lCount);
00308 }
00309
00310
00311 void dsp_mul3f (float *fpDest, const float *fpSrc1, const float *fpSrc2,
00312 long lCount)
00313 {
00314 clDSPOp::Mul(fpDest, fpSrc1, fpSrc2, lCount);
00315 }
00316
00317
00318 void dsp_mul3 (double *dpDest, const double *dpSrc1, const double *dpSrc2,
00319 long lCount)
00320 {
00321 clDSPOp::Mul(dpDest, dpSrc1, dpSrc2, lCount);
00322 }
00323
00324
00325 void dsp_cmul3f (stpSCplx spDest, const stpSCplx spSrc1, const stpSCplx spSrc2,
00326 long lCount)
00327 {
00328 clDSPOp::Mul(spDest, spSrc1, spSrc2, lCount);
00329 }
00330
00331
00332 void dsp_cmul3 (stpDCplx spDest, const stpDCplx spSrc1, const stpDCplx spSrc2,
00333 long lCount)
00334 {
00335 clDSPOp::Mul(spDest, spSrc1, spSrc2, lCount);
00336 }
00337
00338
00339 void dsp_ccmulf (stpSCplx spDest, const stpSCplx spSrc, long lCount)
00340 {
00341 clDSPOp::MulC(spDest, spSrc, lCount);
00342 }
00343
00344
00345 void dsp_ccmul (stpDCplx spDest, const stpDCplx spSrc, long lCount)
00346 {
00347 clDSPOp::MulC(spDest, spSrc, lCount);
00348 }
00349
00350
00351 void dsp_ccmulf_nip (stpSCplx spDest, const stpSCplx spSrc1,
00352 const stpSCplx spSrc2, long lCount)
00353 {
00354 clDSPOp::MulC(spDest, spSrc1, spSrc2, lCount);
00355 }
00356
00357
00358 void dsp_ccmul_nip (stpDCplx spDest, const stpDCplx spSrc1,
00359 const stpDCplx spSrc2, long lCount)
00360 {
00361 clDSPOp::MulC(spDest, spSrc1, spSrc2, lCount);
00362 }
00363
00364
00365 void dsp_divf (float *fpDest, float fSrc, long lCount)
00366 {
00367 clDSPOp::Div(fpDest, fSrc, lCount);
00368 }
00369
00370
00371 void dsp_div (double *dpDest, double dSrc, long lCount)
00372 {
00373 clDSPOp::Div(dpDest, dSrc, lCount);
00374 }
00375
00376
00377 void dsp_cdivf (stpSCplx spDest, stSCplx sSrc, long lCount)
00378 {
00379 clDSPOp::Div(spDest, sSrc, lCount);
00380 }
00381
00382
00383 void dsp_cdiv (stpDCplx spDest, stDCplx sSrc, long lCount)
00384 {
00385 clDSPOp::Div(spDest, sSrc, lCount);
00386 }
00387
00388
00389 void dsp_div2f (float *fpDest, const float *fpSrc, long lCount)
00390 {
00391 clDSPOp::Div(fpDest, fpSrc, lCount);
00392 }
00393
00394
00395 void dsp_div2 (double *dpDest, const double *dpSrc, long lCount)
00396 {
00397 clDSPOp::Div(dpDest, dpSrc, lCount);
00398 }
00399
00400
00401 void dsp_cdiv2f (stpSCplx spDest, const stpSCplx spSrc, long lCount)
00402 {
00403 clDSPOp::Div(spDest, spSrc, lCount);
00404 }
00405
00406
00407 void dsp_cdiv2 (stpDCplx spDest, const stpDCplx spSrc, long lCount)
00408 {
00409 clDSPOp::Div(spDest, spSrc, lCount);
00410 }
00411
00412
00413 void dsp_div3f (float *fpDest, const float *fpSrc1, const float *fpSrc2,
00414 long lCount)
00415 {
00416 clDSPOp::Div(fpDest, fpSrc1, fpSrc2, lCount);
00417 }
00418
00419
00420 void dsp_div3 (double *dpDest, const double *dpSrc1, const double *dpSrc2,
00421 long lCount)
00422 {
00423 clDSPOp::Div(dpDest, dpSrc1, dpSrc2, lCount);
00424 }
00425
00426
00427 void dsp_cdiv3f (stpSCplx spDest, const stpSCplx spSrc1, const stpSCplx spSrc2,
00428 long lCount)
00429 {
00430 clDSPOp::Div(spDest, spSrc1, spSrc2, lCount);
00431 }
00432
00433
00434 void dsp_cdiv3 (stpDCplx spDest, const stpDCplx spSrc1, const stpDCplx spSrc2,
00435 long lCount)
00436 {
00437 clDSPOp::Div(spDest, spSrc1, spSrc2, lCount);
00438 }
00439
00440
00441 void dsp_div1xf (float *fpVect, long lCount)
00442 {
00443 clDSPOp::Div1x(fpVect, lCount);
00444 }
00445
00446
00447 void dsp_div1x (double *dpVect, long lCount)
00448 {
00449 clDSPOp::Div1x(dpVect, lCount);
00450 }
00451
00452
00453 void dsp_div1xf_nip (float *fpDest, const float *fpSrc, long lCount)
00454 {
00455 clDSPOp::Div1x(fpDest, fpSrc, lCount);
00456 }
00457
00458
00459 void dsp_div1x_nip (double *dpDest, const double *dpSrc, long lCount)
00460 {
00461 clDSPOp::Div1x(dpDest, dpSrc, lCount);
00462 }
00463
00464
00465 void dsp_muladdf (float *fpVect, float fMul, float fAdd, long lCount)
00466 {
00467 clDSPOp::MulAdd(fpVect, fMul, fAdd, lCount);
00468 }
00469
00470
00471 void dsp_muladd (double *dpVect, double dMul, double dAdd, long lCount)
00472 {
00473 clDSPOp::MulAdd(dpVect, dMul, dAdd, lCount);
00474 }
00475
00476
00477 void dsp_muladdf_nip (float *fpDest, const float *fpSrc,
00478 float fMul, float fAdd, long lCount)
00479 {
00480 clDSPOp::MulAdd(fpDest, fpSrc, fMul, fAdd, lCount);
00481 }
00482
00483
00484 void dsp_muladd_nip (double *dpDest, const double *dpSrc,
00485 double dMul, double dAdd, long lCount)
00486 {
00487 clDSPOp::MulAdd(dpDest, dpSrc, dMul, dAdd, lCount);
00488 }
00489
00490
00491 void dsp_absf (float *fpVect, long lCount)
00492 {
00493 clDSPOp::Abs(fpVect, lCount);
00494 }
00495
00496
00497 void dsp_abs (double *dpVect, long lCount)
00498 {
00499 clDSPOp::Abs(dpVect, lCount);
00500 }
00501
00502
00503 void dsp_absf_nip (float *fpDest, const float *fpSrc, long lCount)
00504 {
00505 clDSPOp::Abs(fpDest, fpSrc, lCount);
00506 }
00507
00508
00509 void dsp_abs_nip (double *dpDest, const double *dpSrc, long lCount)
00510 {
00511 clDSPOp::Abs(dpDest, dpSrc, lCount);
00512 }
00513
00514
00515 void dsp_sqrtf (float *fpVect, long lCount)
00516 {
00517 clDSPOp::Sqrt(fpVect, lCount);
00518 }
00519
00520
00521 void dsp_sqrt (double *dpVect, long lCount)
00522 {
00523 clDSPOp::Sqrt(dpVect, lCount);
00524 }
00525
00526
00527 void dsp_sqrtf_nip (float *fpDest, const float *fpSrc, long lCount)
00528 {
00529 clDSPOp::Sqrt(fpDest, fpSrc, lCount);
00530 }
00531
00532
00533 void dsp_sqrt_nip (double *dpDest, const double *dpSrc, long lCount)
00534 {
00535 clDSPOp::Sqrt(dpDest, dpSrc, lCount);
00536 }
00537
00538
00539 void dsp_zerof (float *fpVect, long lCount)
00540 {
00541 clDSPOp::Zero(fpVect, lCount);
00542 }
00543
00544
00545 void dsp_zero (double *dpVect, long lCount)
00546 {
00547 clDSPOp::Zero(dpVect, lCount);
00548 }
00549
00550
00551 void dsp_czerof (stpSCplx spVect, long lCount)
00552 {
00553 clDSPOp::Zero(spVect, lCount);
00554 }
00555
00556
00557 void dsp_czero (stpDCplx spVect, long lCount)
00558 {
00559 clDSPOp::Zero(spVect, lCount);
00560 }
00561
00562
00563 void dsp_setf (float *fpDest, float fSrc, long lCount)
00564 {
00565 clDSPOp::Set(fpDest, fSrc, lCount);
00566 }
00567
00568
00569 void dsp_set (double *dpDest, double dSrc, long lCount)
00570 {
00571 clDSPOp::Set(dpDest, dSrc, lCount);
00572 }
00573
00574
00575 void dsp_csetf (stpSCplx spDest, stSCplx sSrc, long lCount)
00576 {
00577 clDSPOp::Set(spDest, sSrc, lCount);
00578 }
00579
00580
00581 void dsp_cset (stpDCplx spDest, stDCplx sSrc, long lCount)
00582 {
00583 clDSPOp::Set(spDest, sSrc, lCount);
00584 }
00585
00586
00587 void dsp_set2f (float *fpDest, float fSrc, long lStart, long lCount,
00588 long lLength)
00589 {
00590 clDSPOp::Set(fpDest, fSrc, lStart, lCount, lLength);
00591 }
00592
00593
00594 void dsp_set2 (double *dpDest, double dSrc, long lStart, long lCount,
00595 long lLength)
00596 {
00597 clDSPOp::Set(dpDest, dSrc, lStart, lCount, lLength);
00598 }
00599
00600
00601 void dsp_cset2f (stpSCplx spDest, stSCplx sSrc, long lStart, long lCount,
00602 long lLength)
00603 {
00604 clDSPOp::Set(spDest, sSrc, lStart, lCount, lLength);
00605 }
00606
00607
00608 void dsp_cset2 (stpDCplx spDest, stDCplx sSrc, long lStart, long lCount,
00609 long lLength)
00610 {
00611 clDSPOp::Set(spDest, sSrc, lStart, lCount, lLength);
00612 }
00613
00614
00615 void dsp_clipf (float *fpVect, float fValue, long lCount)
00616 {
00617 clDSPOp::Clip(fpVect, fValue, lCount);
00618 }
00619
00620
00621 void dsp_clip (double *dpVect, double dValue, long lCount)
00622 {
00623 clDSPOp::Clip(dpVect, dValue, lCount);
00624 }
00625
00626
00627 void dsp_clipf_nip (float *fpDest, const float *fpSrc, float fValue,
00628 long lCount)
00629 {
00630 clDSPOp::Clip(fpDest, fpSrc, fValue, lCount);
00631 }
00632
00633
00634 void dsp_clip_nip (double *dpDest, const double *dpSrc, double dValue,
00635 long lCount)
00636 {
00637 clDSPOp::Clip(dpDest, dpSrc, dValue, lCount);
00638 }
00639
00640
00641 void dsp_clip2f (float *fpVect, float fMin, float fMax, long lCount)
00642 {
00643 clDSPOp::Clip(fpVect, fMin, fMax, lCount);
00644 }
00645
00646
00647 void dsp_clip2 (double *dpVect, double dMin, double dMax, long lCount)
00648 {
00649 clDSPOp::Clip(dpVect, dMin, dMax, lCount);
00650 }
00651
00652
00653 void dsp_clip2f_nip (float *fpDest, const float *fpSrc,
00654 float fMin, float fMax, long lCount)
00655 {
00656 clDSPOp::Clip(fpDest, fpSrc, fMin, fMax, lCount);
00657 }
00658
00659
00660 void dsp_clip2_nip (double *dpDest, const double *dpSrc,
00661 double dMin, double dMax, long lCount)
00662 {
00663 clDSPOp::Clip(dpDest, dpSrc, dMin, dMax, lCount);
00664 }
00665
00666
00667 void dsp_clipzerof (float *fpVect, long lCount)
00668 {
00669 clDSPOp::ClipZero(fpVect, lCount);
00670 }
00671
00672
00673 void dsp_clipzero (double *dpVect, long lCount)
00674 {
00675 clDSPOp::ClipZero(dpVect, lCount);
00676 }
00677
00678
00679 void dsp_clipzerof_nip (float *fpDest, const float *fpSrc, long lCount)
00680 {
00681 clDSPOp::ClipZero(fpDest, fpSrc, lCount);
00682 }
00683
00684
00685 void dsp_clipzero_nip (double *dpDest, const double *dpSrc, long lCount)
00686 {
00687 clDSPOp::ClipZero(dpDest, dpSrc, lCount);
00688 }
00689
00690
00691 void dsp_copyf (float *fpDest, const float *fpSrc, long lCount)
00692 {
00693 clDSPOp::Copy(fpDest, fpSrc, lCount);
00694 }
00695
00696
00697 void dsp_copy (double *dpDest, const double *dpSrc, long lCount)
00698 {
00699 clDSPOp::Copy(dpDest, dpSrc, lCount);
00700 }
00701
00702
00703 void dsp_ccopyf (stpSCplx spDest, const stpSCplx spSrc, long lCount)
00704 {
00705 clDSPOp::Copy(spDest, spSrc, lCount);
00706 }
00707
00708
00709 void dsp_ccopy (stpDCplx spDest, const stpDCplx spSrc, long lCount)
00710 {
00711 clDSPOp::Copy(spDest, spSrc, lCount);
00712 }
00713
00714
00715 float dsp_convolvef (const float *fpSrc1, const float *fpSrc2, long lCount)
00716 {
00717 return clDSPOp::Convolve(fpSrc1, fpSrc2, lCount);
00718 }
00719
00720
00721 double dsp_convolve (const double *dpSrc1, const double *dpSrc2, long lCount)
00722 {
00723 return clDSPOp::Convolve(dpSrc1, dpSrc2, lCount);
00724 }
00725
00726
00727 void dsp_convolve2f (float *fpDest, const float *fpSrc1, const float *fpSrc2,
00728 long lCount)
00729 {
00730 clDSPOp::Convolve(fpDest, fpSrc1, fpSrc2, lCount);
00731 }
00732
00733
00734 void dsp_convolve2 (double *dpDest, const double *dpSrc1, const double *dpSrc2,
00735 long lCount)
00736 {
00737 clDSPOp::Convolve(dpDest, dpSrc1, dpSrc2, lCount);
00738 }
00739
00740
00741 float dsp_correlatef (const float *fpSrc1, const float *fpSrc2, long lCount)
00742 {
00743 return clDSPOp::Correlate(fpSrc1, fpSrc2, lCount);
00744 }
00745
00746
00747 double dsp_correlate (const double *dpSrc1, const double *dpSrc2, long lCount)
00748 {
00749 return clDSPOp::Correlate(dpSrc1, dpSrc2, lCount);
00750 }
00751
00752
00753 void dsp_correlate2f (float *fpDest, const float *fpSrc1, const float *fpSrc2,
00754 long lCount)
00755 {
00756 clDSPOp::Correlate(fpDest, fpSrc1, fpSrc2, lCount);
00757 }
00758
00759
00760 void dsp_correlate2 (double *dpDest, const double *dpSrc1, const double *dpSrc2,
00761 long lCount)
00762 {
00763 clDSPOp::Correlate(dpDest, dpSrc1, dpSrc2, lCount);
00764 }
00765
00766
00767 float dsp_autocorrf (const float *fpSrc, long lCount)
00768 {
00769 return clDSPOp::AutoCorrelate(fpSrc, lCount);
00770 }
00771
00772
00773 double dsp_autocorr (const double *dpSrc, long lCount)
00774 {
00775 return clDSPOp::AutoCorrelate(dpSrc, lCount);
00776 }
00777
00778
00779 void dsp_autocorr2f (float *fpDest, const float *fpSrc, long lCount)
00780 {
00781 clDSPOp::AutoCorrelate(fpDest, fpSrc, lCount);
00782 }
00783
00784
00785 void dsp_autocorr2 (double *dpDest, const double *dpSrc, long lCount)
00786 {
00787 clDSPOp::AutoCorrelate(dpDest, dpSrc, lCount);
00788 }
00789
00790
00791 float dsp_dotproductf (const float *fpSrc1, const float *fpSrc2, long lCount)
00792 {
00793 return clDSPOp::DotProduct(fpSrc1, fpSrc2, lCount);
00794 }
00795
00796
00797 double dsp_dotproduct (const double *dpSrc1, const double *dpSrc2, long lCount)
00798 {
00799 return clDSPOp::DotProduct(dpSrc1, dpSrc2, lCount);
00800 }
00801
00802
00803 void dsp_minmaxf (float *fpMin, float *fpMax, const float *fpSrc, long lCount)
00804 {
00805 clDSPOp::MinMax(fpMin, fpMax, fpSrc, lCount);
00806 }
00807
00808
00809 void dsp_minmax (double *dpMin, double *dpMax, const double *dpSrc, long lCount)
00810 {
00811 clDSPOp::MinMax(dpMin, dpMax, dpSrc, lCount);
00812 }
00813
00814
00815 float dsp_meanf (const float *fpSrc, long lCount)
00816 {
00817 return clDSPOp::Mean(fpSrc, lCount);
00818 }
00819
00820
00821 double dsp_mean (const double *dpSrc, long lCount)
00822 {
00823 return clDSPOp::Mean(dpSrc, lCount);
00824 }
00825
00826
00827 float dsp_medianf (const float *fpSrc, long lCount)
00828 {
00829 return clDSPOp::Median(fpSrc, lCount);
00830 }
00831
00832
00833 double dsp_median (const double *dpSrc, long lCount)
00834 {
00835 return clDSPOp::Median(dpSrc, lCount);
00836 }
00837
00838
00839 void dsp_negatef (float *fpVect, long lCount)
00840 {
00841 clDSPOp::Negate(fpVect, lCount);
00842 }
00843
00844
00845 void dsp_negate (double *dpVect, long lCount)
00846 {
00847 clDSPOp::Negate(dpVect, lCount);
00848 }
00849
00850
00851 void dsp_negatef_nip (float *fpDest, const float *fpSrc, long lCount)
00852 {
00853 clDSPOp::Negate(fpDest, fpSrc, lCount);
00854 }
00855
00856
00857 void dsp_negate_nip (double *dpDest, const double *dpSrc, long lCount)
00858 {
00859 clDSPOp::Negate(dpDest, dpSrc, lCount);
00860 }
00861
00862
00863 void dsp_normalizef (float *fpVect, long lCount)
00864 {
00865 clDSPOp::Normalize(fpVect, lCount);
00866 }
00867
00868
00869 void dsp_normalize (double *dpVect, long lCount)
00870 {
00871 clDSPOp::Normalize(dpVect, lCount);
00872 }
00873
00874
00875 void dsp_normalizef_nip (float *fpDest, const float *fpSrc, long lCount)
00876 {
00877 clDSPOp::Normalize(fpDest, fpSrc, lCount);
00878 }
00879
00880
00881 void dsp_normalize_nip (double *dpDest, const double *dpSrc, long lCount)
00882 {
00883 clDSPOp::Normalize(dpDest, dpSrc, lCount);
00884 }
00885
00886
00887 float dsp_productf (const float *fpSrc, long lCount)
00888 {
00889 return clDSPOp::Product(fpSrc, lCount);
00890 }
00891
00892
00893 double dsp_product (const double *dpSrc, long lCount)
00894 {
00895 return clDSPOp::Product(dpSrc, lCount);
00896 }
00897
00898
00899 void dsp_reversef (float *fpVect, long lCount)
00900 {
00901 clDSPOp::Reverse(fpVect, lCount);
00902 }
00903
00904
00905 void dsp_reverse (double *dpVect, long lCount)
00906 {
00907 clDSPOp::Reverse(dpVect, lCount);
00908 }
00909
00910
00911 void dsp_reversef_nip (float *fpDest, const float *fpSrc, long lCount)
00912 {
00913 clDSPOp::Reverse(fpDest, fpSrc, lCount);
00914 }
00915
00916
00917 void dsp_reverse_nip (double *dpDest, const double *dpSrc, long lCount)
00918 {
00919 clDSPOp::Reverse(dpDest, dpSrc, lCount);
00920 }
00921
00922
00923 void dsp_scalef (float *fpVect, long lCount)
00924 {
00925 clDSPOp::Scale(fpVect, lCount);
00926 }
00927
00928
00929 void dsp_scale (double *dpVect, long lCount)
00930 {
00931 clDSPOp::Scale(dpVect, lCount);
00932 }
00933
00934
00935 void dsp_scalef_nip (float *fpDest, const float *fpSrc, long lCount)
00936 {
00937 clDSPOp::Scale(fpDest, fpSrc, lCount);
00938 }
00939
00940
00941 void dsp_scale_nip (double *dpDest, const double *dpSrc, long lCount)
00942 {
00943 clDSPOp::Scale(dpDest, dpSrc, lCount);
00944 }
00945
00946
00947 void dsp_scale01f (float *fpVect, long lCount)
00948 {
00949 clDSPOp::Scale01(fpVect, lCount);
00950 }
00951
00952
00953 void dsp_scale01 (double *dpVect, long lCount)
00954 {
00955 clDSPOp::Scale01(dpVect, lCount);
00956 }
00957
00958
00959 void dsp_scale01f_nip (float *fpDest, const float *fpSrc, long lCount)
00960 {
00961 clDSPOp::Scale01(fpDest, fpSrc, lCount);
00962 }
00963
00964
00965 void dsp_scale01_nip (double *dpDest, const double *dpSrc, long lCount)
00966 {
00967 clDSPOp::Scale01(dpDest, dpSrc, lCount);
00968 }
00969
00970
00971 void dsp_sortf (float *fpVect, long lCount)
00972 {
00973 clDSPOp::Sort(fpVect, lCount);
00974 }
00975
00976
00977 void dsp_sort (double *dpVect, long lCount)
00978 {
00979 clDSPOp::Sort(dpVect, lCount);
00980 }
00981
00982
00983 void dsp_sortl (long *lpVect, long lCount)
00984 {
00985 clDSPOp::Sort(lpVect, lCount);
00986 }
00987
00988
00989 void dsp_stddevf (float *fpStdDev, float *fpMean, const float *fpSrc,
00990 long lCount)
00991 {
00992 clDSPOp::StdDev(fpStdDev, fpMean, fpSrc, lCount);
00993 }
00994
00995
00996 void dsp_stddev (double *dpStdDev, double *dpMean, const double *dpSrc,
00997 long lCount)
00998 {
00999 clDSPOp::StdDev(dpStdDev, dpMean, dpSrc, lCount);
01000 }
01001
01002
01003 float dsp_sumf (const float *fpSrc, long lCount)
01004 {
01005 return clDSPOp::Sum(fpSrc, lCount);
01006 }
01007
01008
01009 double dsp_sum (const double *dpSrc, long lCount)
01010 {
01011 return clDSPOp::Sum(dpSrc, lCount);
01012 }
01013
01014
01015 void dsp_squaref (float *fpVect, long lCount)
01016 {
01017 clDSPOp::Square(fpVect, lCount);
01018 }
01019
01020
01021 void dsp_square (double *dpVect, long lCount)
01022 {
01023 clDSPOp::Square(dpVect, lCount);
01024 }
01025
01026
01027 void dsp_squaref_nip (float *fpDest, const float *fpSrc, long lCount)
01028 {
01029 clDSPOp::Square(fpDest, fpSrc, lCount);
01030 }
01031
01032
01033 void dsp_square_nip (double *dpDest, const double *dpSrc, long lCount)
01034 {
01035 clDSPOp::Square(dpDest, dpSrc, lCount);
01036 }
01037
01038
01039 void dsp_convertu8f (float *fpDest, const unsigned char *ucpSrc, long lCount)
01040 {
01041 clDSPOp::Convert(fpDest, ucpSrc, lCount);
01042 }
01043
01044
01045 void dsp_convertu8 (double *dpDest, const unsigned char *ucpSrc, long lCount)
01046 {
01047 clDSPOp::Convert(dpDest, ucpSrc, lCount);
01048 }
01049
01050
01051 void dsp_converts16f (float *fpDest, const signed short *ipSrc, long lCount,
01052 int i12bit)
01053 {
01054 clDSPOp::Convert(fpDest, ipSrc, lCount, (i12bit) ? true : false);
01055 }
01056
01057
01058 void dsp_converts16 (double *dpDest, const signed short *ipSrc, long lCount,
01059 int i12bit)
01060 {
01061 clDSPOp::Convert(dpDest, ipSrc, lCount, (i12bit) ? true : false);
01062 }
01063
01064
01065 void dsp_converts32f (float *fpDest, const signed int *ipSrc, long lCount,
01066 int i24bit)
01067 {
01068 clDSPOp::Convert(fpDest, ipSrc, lCount, (i24bit) ? true : false);
01069 }
01070
01071
01072 void dsp_converts32 (double *dpDest, const signed int *ipSrc, long lCount,
01073 int i24bit)
01074 {
01075 clDSPOp::Convert(dpDest, ipSrc, lCount, (i24bit) ? true : false);
01076 }
01077
01078
01079 void dsp_convertd64f (float *fpDest, const double *dpSrc, long lCount)
01080 {
01081 clDSPOp::Convert(fpDest, dpSrc, lCount);
01082 }
01083
01084
01085 void dsp_convertf32 (double *dpDest, const float *fpSrc, long lCount)
01086 {
01087 clDSPOp::Convert(dpDest, fpSrc, lCount);
01088 }
01089
01090
01091 void dsp_convertf32c (unsigned char *ucpDest, const float *fpSrc, long lCount)
01092 {
01093 clDSPOp::Convert(ucpDest, fpSrc, lCount);
01094 }
01095
01096
01097 void dsp_convertd64c (unsigned char *ucpDest, const double *dpSrc, long lCount)
01098 {
01099 clDSPOp::Convert(ucpDest, dpSrc, lCount);
01100 }
01101
01102
01103 void dsp_convertf32s (signed short *ipDest, const float *fpSrc, long lCount,
01104 int i12bit)
01105 {
01106 clDSPOp::Convert(ipDest, fpSrc, lCount, (i12bit) ? true : false);
01107 }
01108
01109
01110 void dsp_convertd64s (signed short *ipDest, const double *dpSrc, long lCount,
01111 int i12bit)
01112 {
01113 clDSPOp::Convert(ipDest, dpSrc, lCount, (i12bit) ? true : false);
01114 }
01115
01116
01117 void dsp_convertf32i (signed int *ipDest, const float *fpSrc, long lCount,
01118 int i24bit)
01119 {
01120 clDSPOp::Convert(ipDest, fpSrc, lCount, (i24bit) ? true : false);
01121 }
01122
01123
01124 void dsp_convertd64i (signed int *ipDest, const double *dpSrc, long lCount,
01125 int i24bit)
01126 {
01127 clDSPOp::Convert(ipDest, dpSrc, lCount, (i24bit) ? true : false);
01128 }
01129
01130
01131 void dsp_cart2polarf (float *fpMagn, float *fpPhase, const float *fpReal,
01132 const float *fpImag, long lCount)
01133 {
01134 clDSPOp::CartToPolar(fpMagn, fpPhase, fpReal, fpImag, lCount);
01135 }
01136
01137
01138 void dsp_cart2polar (double *dpMagn, double *dpPhase, const double *dpReal,
01139 const double *dpImag, long lCount)
01140 {
01141 clDSPOp::CartToPolar(dpMagn, dpPhase, dpReal, dpImag, lCount);
01142 }
01143
01144
01145 void dsp_cart2polar2f (float *fpMagn, float *fpPhase, const stpSCplx spCart,
01146 long lCount)
01147 {
01148 clDSPOp::CartToPolar(fpMagn, fpPhase, spCart, lCount);
01149 }
01150
01151
01152 void dsp_cart2polar2 (double *dpMagn, double *dpPhase, const stpDCplx spCart,
01153 long lCount)
01154 {
01155 clDSPOp::CartToPolar(dpMagn, dpPhase, spCart, lCount);
01156 }
01157
01158
01159 void dsp_cart2polar3f (stpSPolar spPolar, const stpSCplx spCart, long lCount)
01160 {
01161 clDSPOp::CartToPolar(spPolar, spCart, lCount);
01162 }
01163
01164
01165 void dsp_cart2polar3 (stpDPolar spPolar, const stpDCplx spCart, long lCount)
01166 {
01167 clDSPOp::CartToPolar(spPolar, spCart, lCount);
01168 }
01169
01170
01171 void dsp_cart2polar4f (utpSCoord upCoord, long lCount)
01172 {
01173 clDSPOp::CartToPolar(upCoord, lCount);
01174 }
01175
01176
01177 void dsp_cart2polar4 (utpDCoord upCoord, long lCount)
01178 {
01179 clDSPOp::CartToPolar(upCoord, lCount);
01180 }
01181
01182
01183 void dsp_polar2cartf (float *fpReal, float *fpImag, const float *fpMagn,
01184 const float *fpPhase, long lCount)
01185 {
01186 clDSPOp::PolarToCart(fpReal, fpImag, fpMagn, fpPhase, lCount);
01187 }
01188
01189
01190 void dsp_polar2cart (double *dpReal, double *dpImag, const double *dpMagn,
01191 const double *dpPhase, long lCount)
01192 {
01193 clDSPOp::PolarToCart(dpReal, dpImag, dpMagn, dpPhase, lCount);
01194 }
01195
01196
01197 void dsp_polar2cart2f (stpSCplx spCart, const float *fpMagn,
01198 const float *fpPhase, long lCount)
01199 {
01200 clDSPOp::PolarToCart(spCart, fpMagn, fpPhase, lCount);
01201 }
01202
01203
01204 void dsp_polar2cart2 (stpDCplx spCart, const double *dpMagn,
01205 const double *dpPhase, long lCount)
01206 {
01207 clDSPOp::PolarToCart(spCart, dpMagn, dpPhase, lCount);
01208 }
01209
01210
01211 void dsp_polar2cart3f (stpSCplx spCart, const stpSPolar spPolar, long lCount)
01212 {
01213 clDSPOp::PolarToCart(spCart, spPolar, lCount);
01214 }
01215
01216
01217 void dsp_polar2cart3 (stpDCplx spCart, const stpDPolar spPolar, long lCount)
01218 {
01219 clDSPOp::PolarToCart(spCart, spPolar, lCount);
01220 }
01221
01222
01223 void dsp_polar2cart4f (utpSCoord upCoord, long lCount)
01224 {
01225 clDSPOp::PolarToCart(upCoord, lCount);
01226 }
01227
01228
01229 void dsp_polar2cart4 (utpDCoord upCoord, long lCount)
01230 {
01231 clDSPOp::PolarToCart(upCoord, lCount);
01232 }
01233
01234
01235 float dsp_crosscorrf (const float *fpSrc1, const float *fpSrc2, long lCount)
01236 {
01237 return clDSPOp::CrossCorr(fpSrc1, fpSrc2, lCount);
01238 }
01239
01240
01241 double dsp_crosscorr (const double *dpSrc1, const double *dpSrc2, long lCount)
01242 {
01243 return clDSPOp::CrossCorr(dpSrc1, dpSrc2, lCount);
01244 }
01245
01246
01247 float dsp_crosscorr2f (const float *fpSrc1, const float *fpSrc2,
01248 long lDelay, long lCount)
01249 {
01250 return clDSPOp::DelCrossCorr(fpSrc1, fpSrc2, lDelay, lCount);
01251 }
01252
01253
01254 double dsp_crosscorr2 (const double *dpSrc1, const double *dpSrc2,
01255 long lDelay, long lCount)
01256 {
01257 return clDSPOp::DelCrossCorr(dpSrc1, dpSrc2, lDelay, lCount);
01258 }
01259
01260
01261 void dsp_crosscorr3f (float *fpDest, const float *fpSrc1,
01262 const float *fpSrc2, long lCount, const long *lpDelays, long lDelayCount)
01263 {
01264 clDSPOp::DelCrossCorr(fpDest, fpSrc1, fpSrc2, lCount,
01265 lpDelays, lDelayCount);
01266 }
01267
01268
01269 void dsp_crosscorr3 (double *dpDest, const double *dpSrc1,
01270 const double *dpSrc2, long lCount, const long *lpDelays, long lDelayCount)
01271 {
01272 clDSPOp::DelCrossCorr(dpDest, dpSrc1, dpSrc2, lCount,
01273 lpDelays, lDelayCount);
01274 }
01275
01276
01277 float dsp_energyf (const float *fpSrc, long lCount)
01278 {
01279 return clDSPOp::Energy(fpSrc, lCount);
01280 }
01281
01282
01283 double dsp_energy (const double *dpSrc, long lCount)
01284 {
01285 return clDSPOp::Energy(dpSrc, lCount);
01286 }
01287
01288
01289 void dsp_magnitudef (float *fpDest, const stpSCplx spSrc, long lCount)
01290 {
01291 clDSPOp::Magnitude(fpDest, spSrc, lCount);
01292 }
01293
01294
01295 void dsp_magnitude (double *dpDest, const stpDCplx spSrc, long lCount)
01296 {
01297 clDSPOp::Magnitude(dpDest, spSrc, lCount);
01298 }
01299
01300
01301 void dsp_powerf (float *fpDest, const stpSCplx spSrc, long lCount)
01302 {
01303 clDSPOp::Power(fpDest, spSrc, lCount);
01304 }
01305
01306
01307 void dsp_power (double *dpDest, const stpDCplx spSrc, long lCount)
01308 {
01309 clDSPOp::Power(dpDest, spSrc, lCount);
01310 }
01311
01312
01313 void dsp_phasef (float *fpDest, const stpSCplx spSrc, long lCount)
01314 {
01315 clDSPOp::Phase(fpDest, spSrc, lCount);
01316 }
01317
01318
01319 void dsp_phase (double *dpDest, const stpDCplx spSrc, long lCount)
01320 {
01321 clDSPOp::Phase(dpDest, spSrc, lCount);
01322 }
01323
01324
01325 void dsp_powerphasef (float *fpPower, float *fpPhase, const stpSCplx spSrc,
01326 long lCount)
01327 {
01328 clDSPOp::PowerPhase(fpPower, fpPhase, spSrc, lCount);
01329 }
01330
01331
01332 void dsp_powerphase (double *dpPower, double *dpPhase, const stpDCplx spSrc,
01333 long lCount)
01334 {
01335 clDSPOp::PowerPhase(dpPower, dpPhase, spSrc, lCount);
01336 }
01337
01338
01339 void dsp_decimatef (float *fpDest, const float *fpSrc, long lFactor,
01340 long lCount)
01341 {
01342 clDSPOp::Decimate(fpDest, fpSrc, lFactor, lCount);
01343 }
01344
01345
01346 void dsp_decimate (double *dpDest, const double *dpSrc, long lFactor,
01347 long lCount)
01348 {
01349 clDSPOp::Decimate(dpDest, dpSrc, lFactor, lCount);
01350 }
01351
01352
01353 void dsp_decimateavgf (float *fpDest, const float *fpSrc, long lFactor,
01354 long lCount)
01355 {
01356 clDSPOp::DecimateAvg(fpDest, fpSrc, lFactor, lCount);
01357 }
01358
01359
01360 void dsp_decimateavg (double *dpDest, const double *dpSrc, long lFactor,
01361 long lCount)
01362 {
01363 clDSPOp::DecimateAvg(dpDest, dpSrc, lFactor, lCount);
01364 }
01365
01366
01367 void dsp_interpolatef (float *fpDest, const float *fpSrc, long lFactor,
01368 long lCount)
01369 {
01370 clDSPOp::Interpolate(fpDest, fpSrc, lFactor, lCount);
01371 }
01372
01373
01374 void dsp_interpolate (double *dpDest, const double *dpSrc, long lFactor,
01375 long lCount)
01376 {
01377 clDSPOp::Interpolate(dpDest, dpSrc, lFactor, lCount);
01378 }
01379
01380
01381 void dsp_resamplef (float *fpDest, long lDestCount, const float *fpSrc,
01382 long lSrcCount)
01383 {
01384 clDSPOp::Resample(fpDest, lDestCount, fpSrc, lSrcCount);
01385 }
01386
01387
01388 void dsp_resample (double *dpDest, long lDestCount, const double *dpSrc,
01389 long lSrcCount)
01390 {
01391 clDSPOp::Resample(dpDest, lDestCount, dpSrc, lSrcCount);
01392 }
01393
01394
01395 void dsp_resampleavgf (float *fpDest, long lDestCount, const float *fpSrc,
01396 long lSrcCount)
01397 {
01398 clDSPOp::ResampleAvg(fpDest, lDestCount, fpSrc, lSrcCount);
01399 }
01400
01401
01402 void dsp_resampleavg (double *dpDest, long lDestCount, const double *dpSrc,
01403 long lSrcCount)
01404 {
01405 clDSPOp::ResampleAvg(dpDest, lDestCount, dpSrc, lSrcCount);
01406 }
01407
01408
01409 void dsp_interpolateavgf (float *fpDest, const float *fpSrc, long lFactor,
01410 long lCount)
01411 {
01412 clDSPOp::InterpolateAvg(fpDest, fpSrc, lFactor, lCount);
01413 }
01414
01415
01416 void dsp_interpolateavg (double *dpDest, const double *dpSrc, long lFactor,
01417 long lCount)
01418 {
01419 clDSPOp::InterpolateAvg(dpDest, dpSrc, lFactor, lCount);
01420 }
01421
01422
01423 float dsp_rmsf (const float *fpSrc, long lCount)
01424 {
01425 return clDSPOp::RMS(fpSrc, lCount);
01426 }
01427
01428
01429 double dsp_rms (const double *dpSrc, long lCount)
01430 {
01431 return clDSPOp::RMS(dpSrc, lCount);
01432 }
01433
01434
01435 float dsp_variancef (float *fpVariance, float *fpMean, const float *fpSrc,
01436 long lCount)
01437 {
01438 return clDSPOp::Variance(fpVariance, fpMean, fpSrc, lCount);
01439 }
01440
01441
01442 double dsp_variance (double *dpVariance, double *dpMean, const double *dpSrc,
01443 long lCount)
01444 {
01445 return clDSPOp::Variance(dpVariance, dpMean, dpSrc, lCount);
01446 }
01447
01448
01449 float dsp_peaklevelf (const float *fpSrc, long lCount)
01450 {
01451 return clDSPOp::PeakLevel(fpSrc, lCount);
01452 }
01453
01454
01455 double dsp_peaklevel (const double *dpSrc, long lCount)
01456 {
01457 return clDSPOp::PeakLevel(dpSrc, lCount);
01458 }
01459
01460
01461 void dsp_mixf (float *fpDest, const float *fpSrc, long lCount)
01462 {
01463 clDSPOp::Mix(fpDest, fpSrc, lCount);
01464 }
01465
01466
01467 void dsp_mix (double *dpDest, const double *dpSrc, long lCount)
01468 {
01469 clDSPOp::Mix(dpDest, dpSrc, lCount);
01470 }
01471
01472
01473 void dsp_mix2f (float *fpDest, const float *fpSrc1, const float *fpSrc2,
01474 long lCount)
01475 {
01476 clDSPOp::Mix(fpDest, fpSrc1, fpSrc2, lCount);
01477 }
01478
01479
01480 void dsp_mix2 (double *dpDest, const double *dpSrc1, const double *dpSrc2,
01481 long lCount)
01482 {
01483 clDSPOp::Mix(dpDest, dpSrc1, dpSrc2, lCount);
01484 }
01485
01486
01487 void dsp_mixnf (float *fpDest, const float *fpSrc, long lChCount,
01488 long lCount)
01489 {
01490 clDSPOp::Mix(fpDest, fpSrc, lChCount, lCount);
01491 }
01492
01493
01494 void dsp_mixn (double *dpDest, const double *dpSrc, long lChCount,
01495 long lCount)
01496 {
01497 clDSPOp::Mix(dpDest, dpSrc, lChCount, lCount);
01498 }
01499
01500
01501 void dsp_extractf (float *fpDest, const float *fpSrc, long lChannel,
01502 long lChCount, long lCount)
01503 {
01504 clDSPOp::Extract(fpDest, fpSrc, lChannel, lChCount, lCount);
01505 }
01506
01507
01508 void dsp_extract (double *dpDest, const double *dpSrc, long lChannel,
01509 long lChCount, long lCount)
01510 {
01511 clDSPOp::Extract(dpDest, dpSrc, lChannel, lChCount, lCount);
01512 }
01513
01514
01515 void dsp_packf (float *fpDest, const float *fpSrc, long lChannel,
01516 long lChCount, long lCount)
01517 {
01518 clDSPOp::Pack(fpDest, fpSrc, lChannel, lChCount, lCount);
01519 }
01520
01521
01522 void dsp_pack (double *dpDest, const double *dpSrc, long lChannel,
01523 long lChCount, long lCount)
01524 {
01525 clDSPOp::Pack(dpDest, dpSrc, lChannel, lChCount, lCount);
01526 }
01527
01528
01529 void dsp_fftw_convertf2cf (stpSCplx spDest, const float *fpSrc, long lCount)
01530 {
01531 clDSPOp::FFTWConvert(spDest, fpSrc, lCount);
01532 }
01533
01534
01535 void dsp_fftw_convertf2cd (stpDCplx spDest, const float *fpSrc, long lCount)
01536 {
01537 clDSPOp::FFTWConvert(spDest, fpSrc, lCount);
01538 }
01539
01540
01541 void dsp_fftw_convertd2cf (stpSCplx spDest, const double *dpSrc, long lCount)
01542 {
01543 clDSPOp::FFTWConvert(spDest, dpSrc, lCount);
01544 }
01545
01546
01547 void dsp_fftw_convertd2cd (stpDCplx spDest, const double *dpSrc, long lCount)
01548 {
01549 clDSPOp::FFTWConvert(spDest, dpSrc, lCount);
01550 }
01551
01552
01553 void dsp_fftw_convertcf2f (float *fpDest, const stpSCplx spSrc, long lCount)
01554 {
01555 clDSPOp::FFTWConvert(fpDest, spSrc, lCount);
01556 }
01557
01558
01559 void dsp_fftw_convertcd2f (float *fpDest, const stpDCplx spSrc, long lCount)
01560 {
01561 clDSPOp::FFTWConvert(fpDest, spSrc, lCount);
01562 }
01563
01564
01565 void dsp_fftw_convertcf2d (double *dpDest, const stpSCplx spSrc, long lCount)
01566 {
01567 clDSPOp::FFTWConvert(dpDest, spSrc, lCount);
01568 }
01569
01570
01571 void dsp_fftw_convertcd2d (double *dpDest, const stpDCplx spSrc, long lCount)
01572 {
01573 clDSPOp::FFTWConvert(dpDest, spSrc, lCount);
01574 }
01575
01576
01577 dsp_t dsp_new ()
01578 {
01579 return ((dsp_t) new clDSPOp);
01580 }
01581
01582
01583 void dsp_delete (dsp_t dspInst)
01584 {
01585 delete ((clDSPOp *) dspInst);
01586 }
01587
01588
01589 void dsp_win_bartlettf (dsp_t dspInst, float *fpDest, long lCount)
01590 {
01591 ((clDSPOp *) dspInst)->WinBartlett(fpDest, lCount);
01592 }
01593
01594
01595 void dsp_win_bartlett (dsp_t dspInst, double *dpDest, long lCount)
01596 {
01597 ((clDSPOp *) dspInst)->WinBartlett(dpDest, lCount);
01598 }
01599
01600
01601 void dsp_win_blackmanf (dsp_t dspInst, float *fpDest, long lCount,
01602 float fAlpha)
01603 {
01604 ((clDSPOp *) dspInst)->WinBlackman(fpDest, lCount, fAlpha);
01605 }
01606
01607
01608 void dsp_win_blackman (dsp_t dspInst, double *dpDest, long lCount,
01609 double dAlpha)
01610 {
01611 ((clDSPOp *) dspInst)->WinBlackman(dpDest, lCount, dAlpha);
01612 }
01613
01614
01615 void dsp_win_blackman_harrisf (dsp_t dspInst, float *fpDest, long lCount)
01616 {
01617 ((clDSPOp *) dspInst)->WinBlackmanHarris(fpDest, lCount);
01618 }
01619
01620
01621 void dsp_win_blackman_harris (dsp_t dspInst, double *dpDest, long lCount)
01622 {
01623 ((clDSPOp *) dspInst)->WinBlackmanHarris(dpDest, lCount);
01624 }
01625
01626
01627 void dsp_win_cos_taperedf (dsp_t dspInst, float *fpDest, long lCount)
01628 {
01629 ((clDSPOp *) dspInst)->WinCosTapered(fpDest, lCount);
01630 }
01631
01632
01633 void dsp_win_cos_tapered (dsp_t dspInst, double *dpDest, long lCount)
01634 {
01635 ((clDSPOp *) dspInst)->WinCosTapered(dpDest, lCount);
01636 }
01637
01638
01639 void dsp_win_exact_blackmanf (dsp_t dspInst, float *fpDest, long lCount)
01640 {
01641 ((clDSPOp *) dspInst)->WinExactBlackman(fpDest, lCount);
01642 }
01643
01644
01645 void dsp_win_exact_blackman (dsp_t dspInst, double *dpDest, long lCount)
01646 {
01647 ((clDSPOp *) dspInst)->WinExactBlackman(dpDest, lCount);
01648 }
01649
01650
01651 void dsp_win_flat_topf (dsp_t dspInst, float *fpDest, long lCount)
01652 {
01653 ((clDSPOp *) dspInst)->WinFlatTop(fpDest, lCount);
01654 }
01655
01656
01657 void dsp_win_flat_top (dsp_t dspInst, double *dpDest, long lCount)
01658 {
01659 ((clDSPOp *) dspInst)->WinFlatTop(dpDest, lCount);
01660 }
01661
01662
01663 void dsp_win_generic_cosf (dsp_t dspInst, float *fpDest, long lCount,
01664 const float *fpCoeff, long lCoeffCount)
01665 {
01666 ((clDSPOp *) dspInst)->WinGenericCos(fpDest, lCount, fpCoeff,
01667 lCoeffCount);
01668 }
01669
01670
01671 void dsp_win_generic_cos (dsp_t dspInst, double *dpDest, long lCount,
01672 const double *dpCoeff, long lCoeffCount)
01673 {
01674 ((clDSPOp *) dspInst)->WinGenericCos(dpDest, lCount, dpCoeff,
01675 lCoeffCount);
01676 }
01677
01678
01679 void dsp_win_hammingf (dsp_t dspInst, float *fpDest, long lCount)
01680 {
01681 ((clDSPOp *) dspInst)->WinHamming(fpDest, lCount);
01682 }
01683
01684
01685 void dsp_win_hamming (dsp_t dspInst, double *dpDest, long lCount)
01686 {
01687 ((clDSPOp *) dspInst)->WinHamming(dpDest, lCount);
01688 }
01689
01690
01691 void dsp_win_hanningf (dsp_t dspInst, float *fpDest, long lCount)
01692 {
01693 ((clDSPOp *) dspInst)->WinHanning(fpDest, lCount);
01694 }
01695
01696
01697 void dsp_win_hanning (dsp_t dspInst, double *dpDest, long lCount)
01698 {
01699 ((clDSPOp *) dspInst)->WinHanning(dpDest, lCount);
01700 }
01701
01702
01703 void dsp_win_kaiserf (dsp_t dspInst, float *fpDest, float fBeta, long lCount)
01704 {
01705 ((clDSPOp *) dspInst)->WinKaiser(fpDest, fBeta, lCount);
01706 }
01707
01708
01709 void dsp_win_kaiser (dsp_t dspInst, double *dpDest, double dBeta, long lCount)
01710 {
01711 ((clDSPOp *) dspInst)->WinKaiser(dpDest, dBeta, lCount);
01712 }
01713
01714
01715 void dsp_win_kaiser_besself (dsp_t dspInst, float *fpDest, float fAlpha,
01716 long lCount)
01717 {
01718 ((clDSPOp *) dspInst)->WinKaiserBessel(fpDest, fAlpha, lCount);
01719 }
01720
01721
01722 void dsp_win_kaiser_bessel (dsp_t dspInst, double *dpDest, double dAlpha,
01723 long lCount)
01724 {
01725 ((clDSPOp *) dspInst)->WinKaiserBessel(dpDest, dAlpha, lCount);
01726 }
01727
01728
01729 void dsp_win_tukeyf (dsp_t dspInst, float *fpDest, long lCount)
01730 {
01731 ((clDSPOp *) dspInst)->WinTukey(fpDest, lCount);
01732 }
01733
01734
01735 void dsp_win_tukey (dsp_t dspInst, double *dpDest, long lCount)
01736 {
01737 ((clDSPOp *) dspInst)->WinTukey(dpDest, lCount);
01738 }
01739
01740
01741 void dsp_win_dolph_chebyshevf (dsp_t dspInst, float *fpDest, float fGamma,
01742 long lCount)
01743 {
01744 ((clDSPOp *) dspInst)->WinDolphChebyshev(fpDest, fGamma, lCount);
01745 }
01746
01747
01748 void dsp_win_dolph_chebyshev (dsp_t dspInst, double *dpDest, double dGamma,
01749 long lCount)
01750 {
01751 ((clDSPOp *) dspInst)->WinDolphChebyshev(dpDest, dGamma, lCount);
01752 }
01753
01754
01755 long dsp_rebufferf (dsp_t dspInst, float *fpDest, const float *fpSrc,
01756 long lDestCount, long lSrcCount)
01757 {
01758 return ((clDSPOp *) dspInst)->ReBuffer(fpDest, fpSrc, lDestCount,
01759 lSrcCount);
01760 }
01761
01762
01763 long dsp_rebuffer (dsp_t dspInst, double *dpDest, const double *dpSrc,
01764 long lDestCount, long lSrcCount)
01765 {
01766 return ((clDSPOp *) dspInst)->ReBuffer(dpDest, dpSrc, lDestCount,
01767 lSrcCount);
01768 }
01769
01770
01771 float dsp_deg2radf (dsp_t dspInst, float fSource)
01772 {
01773 return ((clDSPOp *) dspInst)->DegToRad(fSource);
01774 }
01775
01776
01777 double dsp_deg2rad (dsp_t dspInst, double dSource)
01778 {
01779 return ((clDSPOp *) dspInst)->DegToRad(dSource);
01780 }
01781
01782
01783 float dsp_rad2degf (dsp_t dspInst, float fSource)
01784 {
01785 return ((clDSPOp *) dspInst)->RadToDeg(fSource);
01786 }
01787
01788
01789 double dsp_rad2deg (dsp_t dspInst, double dSource)
01790 {
01791 return ((clDSPOp *) dspInst)->RadToDeg(dSource);
01792 }
01793
01794
01795 void dsp_fir_allocatef (dsp_t dspInst, const float *fpCoeff, long lCount)
01796 {
01797 ((clDSPOp *) dspInst)->FIRAllocate(fpCoeff, lCount);
01798 }
01799
01800
01801 void dsp_fir_allocate (dsp_t dspInst, const double *dpCoeff, long lCount)
01802 {
01803 ((clDSPOp *) dspInst)->FIRAllocate(dpCoeff, lCount);
01804 }
01805
01806
01807 void dsp_fir_free (dsp_t dspInst)
01808 {
01809 ((clDSPOp *) dspInst)->FIRFree();
01810 }
01811
01812
01813 void dsp_fir_filterf (dsp_t dspInst, float *fpVect, long lCount)
01814 {
01815 ((clDSPOp *) dspInst)->FIRFilter(fpVect, lCount);
01816 }
01817
01818
01819 void dsp_fir_filter (dsp_t dspInst, double *dpVect, long lCount)
01820 {
01821 ((clDSPOp *) dspInst)->FIRFilter(dpVect, lCount);
01822 }
01823
01824
01825 void dsp_fir_filterf_nip (dsp_t dspInst, float *fpDest, const float *fpSrc,
01826 long lCount)
01827 {
01828 ((clDSPOp *) dspInst)->FIRFilter(fpDest, fpSrc, lCount);
01829 }
01830
01831
01832 void dsp_fir_filter_nip (dsp_t dspInst, double *dpDest, const double *dpSrc,
01833 long lCount)
01834 {
01835 ((clDSPOp *) dspInst)->FIRFilter(dpDest, dpSrc, lCount);
01836 }
01837
01838
01839 void dsp_fir_filterf_fst (dsp_t dspInst, float *fpDest, float *fpSrc,
01840 long lCount)
01841 {
01842 ((clDSPOp *) dspInst)->FIRFilterF(fpDest, fpSrc, lCount);
01843 }
01844
01845
01846 void dsp_fir_filter_fst (dsp_t dspInst, double *dpDest, double *dpSrc,
01847 long lCount)
01848 {
01849 ((clDSPOp *) dspInst)->FIRFilterF(dpDest, dpSrc, lCount);
01850 }
01851
01852
01853 void dsp_iir_initf (dsp_t dspInst, const float *fpCoeffs)
01854 {
01855 ((clDSPOp *) dspInst)->IIRInitialize(fpCoeffs);
01856 }
01857
01858
01859 void dsp_iir_init (dsp_t dspInst, const double *dpCoeffs)
01860 {
01861 ((clDSPOp *) dspInst)->IIRInitialize(dpCoeffs);
01862 }
01863
01864
01865 void dsp_iir_filterf (dsp_t dspInst, float *fpVect, long lCount)
01866 {
01867 ((clDSPOp *) dspInst)->IIRFilter(fpVect, lCount);
01868 }
01869
01870
01871 void dsp_iir_filter (dsp_t dspInst, double *dpVect, long lCount)
01872 {
01873 ((clDSPOp *) dspInst)->IIRFilter(dpVect, lCount);
01874 }
01875
01876
01877 void dsp_iir_filterf_nip (dsp_t dspInst, float *fpDest, const float *fpSrc,
01878 long lCount)
01879 {
01880 ((clDSPOp *) dspInst)->IIRFilter(fpDest, fpSrc, lCount);
01881 }
01882
01883
01884 void dsp_iir_filter_nip (dsp_t dspInst, double *dpDest, const double *dpSrc,
01885 long lCount)
01886 {
01887 ((clDSPOp *) dspInst)->IIRFilter(dpDest, dpSrc, lCount);
01888 }
01889
01890
01891 void dsp_iir_clear (dsp_t dspInst)
01892 {
01893 ((clDSPOp *) dspInst)->IIRClear();
01894 }
01895
01896
01897 void dsp_fft_init (dsp_t dspInst, long lSize, int iReal)
01898 {
01899 ((clDSPOp *) dspInst)->FFTInitialize(lSize, (iReal) ? true : false);
01900 }
01901
01902
01903 void dsp_fft_uninit (dsp_t dspInst)
01904 {
01905 ((clDSPOp *) dspInst)->FFTUninitialize();
01906 }
01907
01908
01909 void dsp_fftf (dsp_t dspInst, stpSCplx spDest, float *fpSrc)
01910 {
01911 ((clDSPOp *) dspInst)->FFTi(spDest, fpSrc);
01912 }
01913
01914
01915 void dsp_fft (dsp_t dspInst, stpDCplx spDest, double *dpSrc)
01916 {
01917 ((clDSPOp *) dspInst)->FFTi(spDest, dpSrc);
01918 }
01919
01920
01921 void dsp_fftf_nip (dsp_t dspInst, stpSCplx spDest, const float *fpSrc)
01922 {
01923 ((clDSPOp *) dspInst)->FFTo(spDest, fpSrc);
01924 }
01925
01926
01927 void dsp_fft_nip (dsp_t dspInst, stpDCplx spDest, const double *dpSrc)
01928 {
01929 ((clDSPOp *) dspInst)->FFTo(spDest, dpSrc);
01930 }
01931
01932
01933 void dsp_cfftf_nip (dsp_t dspInst, stpSCplx spDest, const stpSCplx spSrc)
01934 {
01935 ((clDSPOp *) dspInst)->FFTo(spDest, spSrc);
01936 }
01937
01938
01939 void dsp_cfft_nip (dsp_t dspInst, stpDCplx spDest, const stpDCplx spSrc)
01940 {
01941 ((clDSPOp *) dspInst)->FFTo(spDest, spSrc);
01942 }
01943
01944
01945 void dsp_ifftf_nip (dsp_t dspInst, float *fpDest, const stpSCplx spSrc)
01946 {
01947 ((clDSPOp *) dspInst)->IFFTo(fpDest, spSrc);
01948 }
01949
01950
01951 void dsp_ifft_nip (dsp_t dspInst, double *dpDest, const stpDCplx spSrc)
01952 {
01953 ((clDSPOp *) dspInst)->IFFTo(dpDest, spSrc);
01954 }
01955
01956
01957 void dsp_cifftf_nip (dsp_t dspInst, stpSCplx spDest, const stpSCplx spSrc)
01958 {
01959 ((clDSPOp *) dspInst)->IFFTo(spDest, spSrc);
01960 }
01961
01962
01963 void dsp_cifft_nip (dsp_t dspInst, stpDCplx spDest, const stpDCplx spSrc)
01964 {
01965 ((clDSPOp *) dspInst)->IFFTo(spDest, spSrc);
01966 }
01967
01968
01969
01970
01971
01972 dsp_iircas_t dsp_iir_cas_new ()
01973 {
01974 return ((dsp_iircas_t) new clIIRCascade);
01975 }
01976
01977
01978 void dsp_iir_cas_delete (dsp_iircas_t dspiircasInst)
01979 {
01980 delete ((clIIRCascade *) dspiircasInst);
01981 }
01982
01983
01984 int dsp_iir_cas_initf (dsp_iircas_t dspiircasInst,
01985 const float fpCoeffs[][5], long lStageCount)
01986 {
01987 if (!((clIIRCascade *) dspiircasInst)->Initialize(fpCoeffs, lStageCount))
01988 return 0;
01989 return 1;
01990 }
01991
01992
01993 int dsp_iir_cas_init (dsp_iircas_t dspiircasInst,
01994 const double dpCoeffs[][5], long lStageCount)
01995 {
01996 if (!((clIIRCascade *) dspiircasInst)->Initialize(dpCoeffs, lStageCount))
01997 return 0;
01998 return 1;
01999 }
02000
02001
02002 void dsp_iir_cas_uninit (dsp_iircas_t dspiircasInst)
02003 {
02004 ((clIIRCascade *) dspiircasInst)->Uninitialize();
02005 }
02006
02007
02008 void dsp_iir_cas_processf (dsp_iircas_t dspiircasInst,
02009 float *fpVect, long lCount)
02010 {
02011 ((clIIRCascade *) dspiircasInst)->Process(fpVect, lCount);
02012 }
02013
02014
02015 void dsp_iir_cas_process (dsp_iircas_t dspiircasInst,
02016 double *dpVect, long lCount)
02017 {
02018 ((clIIRCascade *) dspiircasInst)->Process(dpVect, lCount);
02019 }
02020
02021
02022 void dsp_iir_cas_processf_nip (dsp_iircas_t dspiircasInst,
02023 float *fpDest, const float *fpSrc, long lCount)
02024 {
02025 ((clIIRCascade *) dspiircasInst)->Process(fpDest, fpSrc, lCount);
02026 }
02027
02028
02029 void dsp_iir_cas_process_nip (dsp_iircas_t dspiircasInst,
02030 double *dpDest, const double *dpSrc, long lCount)
02031 {
02032 ((clIIRCascade *) dspiircasInst)->Process(dpDest, dpSrc, lCount);
02033 }
02034
02035
02036 void dsp_iir_cas_clear (dsp_iircas_t dspiircasInst)
02037 {
02038 ((clIIRCascade *) dspiircasInst)->Clear();
02039 }
02040
02041
02042
02043
02044
02045 dsp_decfft_t dsp_dec_fft_new ()
02046 {
02047 return ((dsp_decfft_t) new clFFTDecimator);
02048 }
02049
02050
02051 void dsp_dec_fft_delete (dsp_decfft_t dspdecfftInst)
02052 {
02053 delete ((clFFTDecimator *) dspdecfftInst);
02054 }
02055
02056
02057 int dsp_dec_fft_initf (dsp_decfft_t dspdecfftInst, long lDecFact,
02058 long lFiltSize, int iHighPass)
02059 {
02060 float *fpNullPtr = NULL;
02061
02062 if (!((clFFTDecimator *) dspdecfftInst)->Initialize(lDecFact, lFiltSize,
02063 fpNullPtr, (iHighPass) ? true : false)) return 0;
02064 return 1;
02065 }
02066
02067
02068 int dsp_dec_fft_init (dsp_decfft_t dspdecfftInst, long lDecFact,
02069 long lFiltSize, int iHighPass)
02070 {
02071 double *dpNullPtr = NULL;
02072
02073 if (!((clFFTDecimator *) dspdecfftInst)->Initialize(lDecFact, lFiltSize,
02074 dpNullPtr, (iHighPass) ? true : false)) return 0;
02075 return 1;
02076 }
02077
02078
02079 void dsp_dec_fft_uninit (dsp_decfft_t dspdecfftInst)
02080 {
02081 ((clFFTDecimator *) dspdecfftInst)->Uninitialize();
02082 }
02083
02084
02085 void dsp_dec_fft_putf (dsp_decfft_t dspdecfftInst, const float *fpSrcData,
02086 long lSrcCount)
02087 {
02088 ((clFFTDecimator *) dspdecfftInst)->Put(fpSrcData, lSrcCount);
02089 }
02090
02091
02092 void dsp_dec_fft_put (dsp_decfft_t dspdecfftInst, const double *dpSrcData,
02093 long lSrcCount)
02094 {
02095 ((clFFTDecimator *) dspdecfftInst)->Put(dpSrcData, lSrcCount);
02096 }
02097
02098
02099 int dsp_dec_fft_getf (dsp_decfft_t dspdecfftInst, float *fpDestData,
02100 long lDestCount)
02101 {
02102 if (!((clFFTDecimator *) dspdecfftInst)->Get(fpDestData, lDestCount))
02103 return 0;
02104 return 1;
02105 }
02106
02107
02108 int dsp_dec_fft_get (dsp_decfft_t dspdecfftInst, double *dpDestData,
02109 long lDestCount)
02110 {
02111 if (!((clFFTDecimator *) dspdecfftInst)->Get(dpDestData, lDestCount))
02112 return 0;
02113 return 1;
02114 }
02115
02116
02117
02118
02119
02120 dsp_decfir_t dsp_dec_fir_new ()
02121 {
02122 return ((dsp_decfir_t) new clFIRDecimator);
02123 }
02124
02125
02126 void dsp_dec_fir_delete (dsp_decfir_t dspdecfirInst)
02127 {
02128 delete ((clFIRDecimator *) dspdecfirInst);
02129 }
02130
02131
02132 int dsp_dec_fir_initf (dsp_decfir_t dspdecfirInst, long lDecFact, int iHighPass)
02133 {
02134 float *fpNullPtr = NULL;
02135
02136 if (!((clFIRDecimator *) dspdecfirInst)->Initialize(lDecFact, fpNullPtr,
02137 (iHighPass) ? true : false)) return 0;
02138 return 1;
02139 }
02140
02141
02142 int dsp_dec_fir_init (dsp_decfir_t dspdecfirInst, long lDecFact, int iHighPass)
02143 {
02144 double *dpNullPtr = NULL;
02145
02146 if (!((clFIRDecimator *) dspdecfirInst)->Initialize(lDecFact, dpNullPtr,
02147 (iHighPass) ? true : false)) return 0;
02148 return 1;
02149 }
02150
02151
02152 void dsp_dec_fir_uninit (dsp_decfir_t dspdecfirInst)
02153 {
02154 ((clFIRDecimator *) dspdecfirInst)->Uninitialize();
02155 }
02156
02157
02158 void dsp_dec_fir_putf (dsp_decfir_t dspdecfirInst, const float *fpSrcData,
02159 long lSrcCount)
02160 {
02161 ((clFIRDecimator *) dspdecfirInst)->Put(fpSrcData, lSrcCount);
02162 }
02163
02164
02165 void dsp_dec_fir_put (dsp_decfir_t dspdecfirInst, const double *dpSrcData,
02166 long lSrcCount)
02167 {
02168 ((clFIRDecimator *) dspdecfirInst)->Put(dpSrcData, lSrcCount);
02169 }
02170
02171
02172 int dsp_dec_fir_getf (dsp_decfir_t dspdecfirInst, float *fpDestData,
02173 long lDestCount)
02174 {
02175 if (!((clFIRDecimator *) dspdecfirInst)->Get(fpDestData, lDestCount))
02176 return 0;
02177 return 1;
02178 }
02179
02180
02181 int dsp_dec_fir_get (dsp_decfir_t dspdecfirInst, double *dpDestData,
02182 long lDestCount)
02183 {
02184 if (!((clFIRDecimator *) dspdecfirInst)->Get(dpDestData, lDestCount))
02185 return 0;
02186 return 1;
02187 }
02188
02189
02190
02191
02192
02193 dsp_deciir_t dsp_dec_iir_new ()
02194 {
02195 return ((dsp_deciir_t) new clIIRDecimator);
02196 }
02197
02198
02199 void dsp_dec_iir_delete (dsp_deciir_t dspdeciirInst)
02200 {
02201 delete ((clIIRDecimator *) dspdeciirInst);
02202 }
02203
02204
02205 int dsp_dec_iir_initf (dsp_deciir_t dspdeciirInst, long lDecFact, int iHighPass)
02206 {
02207 float *fpNullPtr = NULL;
02208
02209 if (!((clIIRDecimator *) dspdeciirInst)->Initialize(lDecFact, fpNullPtr,
02210 (iHighPass) ? true : false)) return 0;
02211 return 1;
02212 }
02213
02214
02215 int dsp_dec_iir_init (dsp_deciir_t dspdeciirInst, long lDecFact, int iHighPass)
02216 {
02217 double *dpNullPtr = NULL;
02218
02219 if (!((clIIRDecimator *) dspdeciirInst)->Initialize(lDecFact, dpNullPtr,
02220 (iHighPass) ? true : false)) return 0;
02221 return 1;
02222 }
02223
02224
02225 void dsp_dec_iir_uninit (dsp_deciir_t dspdeciirInst)
02226 {
02227 ((clIIRDecimator *) dspdeciirInst)->Uninitialize();
02228 }
02229
02230
02231 void dsp_dec_iir_putf (dsp_deciir_t dspdeciirInst, const float *fpSrcData,
02232 long lSrcCount)
02233 {
02234 ((clIIRDecimator *) dspdeciirInst)->Put(fpSrcData, lSrcCount);
02235 }
02236
02237
02238 void dsp_dec_iir_put (dsp_deciir_t dspdeciirInst, const double *dpSrcData,
02239 long lSrcCount)
02240 {
02241 ((clIIRDecimator *) dspdeciirInst)->Put(dpSrcData, lSrcCount);
02242 }
02243
02244
02245 int dsp_dec_iir_getf (dsp_deciir_t dspdeciirInst, float *fpDestData,
02246 long lDestCount)
02247 {
02248 if (!((clIIRDecimator *) dspdeciirInst)->Get(fpDestData, lDestCount))
02249 return 0;
02250 return 1;
02251 }
02252
02253
02254 int dsp_dec_iir_get (dsp_deciir_t dspdeciirInst, double *dpDestData,
02255 long lDestCount)
02256 {
02257 if (!((clIIRDecimator *) dspdeciirInst)->Get(dpDestData, lDestCount))
02258 return 0;
02259 return 1;
02260 }
02261
02262
02263
02264
02265
02266 dsp_decrec_t dsp_dec_rec_new ()
02267 {
02268 return ((dsp_decrec_t) new clRecDecimator);
02269 }
02270
02271
02272 void dsp_dec_rec_delete (dsp_decrec_t dspdecrecInst)
02273 {
02274 delete ((clRecDecimator *) dspdecrecInst);
02275 }
02276
02277
02278 int dsp_dec_rec_initf (dsp_decrec_t dspdecrecInst, long lDecFact,
02279 long lFiltSize, float fBandCenter, int iFilterType)
02280 {
02281 float *fpNullPtr = NULL;
02282
02283 if (!((clRecDecimator *) dspdecrecInst)->Initialize(lDecFact,
02284 lFiltSize, fpNullPtr, fBandCenter, iFilterType))
02285 return 0;
02286 return 1;
02287 }
02288
02289
02290 int dsp_dec_rec_init (dsp_decrec_t dspdecrecInst, long lDecFact,
02291 long lFiltSize, double dBandCenter, int iFilterType)
02292 {
02293 double *dpNullPtr = NULL;
02294
02295 if (!((clRecDecimator *) dspdecrecInst)->Initialize(lDecFact,
02296 lFiltSize, dpNullPtr, dBandCenter, iFilterType))
02297 return 0;
02298 return 1;
02299 }
02300
02301
02302 void dsp_dec_rec_uninit (dsp_decrec_t dspdecrecInst)
02303 {
02304 ((clRecDecimator *) dspdecrecInst)->Uninitialize();
02305 }
02306
02307
02308 void dsp_dec_rec_putf (dsp_decrec_t dspdecrecInst, const float *fpSrcData,
02309 long lSrcCount)
02310 {
02311 ((clRecDecimator *) dspdecrecInst)->Put(fpSrcData, lSrcCount);
02312 }
02313
02314
02315 void dsp_dec_rec_put (dsp_decrec_t dspdecrecInst, const double *dpSrcData,
02316 long lSrcCount)
02317 {
02318 ((clRecDecimator *) dspdecrecInst)->Put(dpSrcData, lSrcCount);
02319 }
02320
02321
02322 int dsp_dec_rec_getf (dsp_decrec_t dspdecrecInst, float *fpDestData,
02323 long lDestCount)
02324 {
02325 if (!((clRecDecimator *) dspdecrecInst)->Get(fpDestData, lDestCount))
02326 return 0;
02327 return 1;
02328 }
02329
02330
02331 int dsp_dec_rec_get (dsp_decrec_t dspdecrecInst, double *dpDestData,
02332 long lDestCount)
02333 {
02334 if (!((clRecDecimator *) dspdecrecInst)->Get(dpDestData, lDestCount))
02335 return 0;
02336 return 1;
02337 }
02338
02339
02340
02341
02342
02343 dsp_intfft_t dsp_int_fft_new ()
02344 {
02345 return ((dsp_intfft_t) new clFFTInterpolator);
02346 }
02347
02348
02349 void dsp_int_fft_delete (dsp_intfft_t dspintfftInst)
02350 {
02351 delete ((clFFTInterpolator *) dspintfftInst);
02352 }
02353
02354
02355 int dsp_int_fft_initf (dsp_intfft_t dspintfftInst, long lIntFact,
02356 long lFiltSize, int iHighPass)
02357 {
02358 float *fpNullPtr = NULL;
02359
02360 if (!((clFFTInterpolator *) dspintfftInst)->Initialize(lIntFact, lFiltSize,
02361 fpNullPtr, (iHighPass) ? true : false)) return 0;
02362 return 1;
02363 }
02364
02365
02366 int dsp_int_fft_init (dsp_intfft_t dspintfftInst, long lIntFact,
02367 long lFiltSize, int iHighPass)
02368 {
02369 double *dpNullPtr = NULL;
02370
02371 if (!((clFFTInterpolator *) dspintfftInst)->Initialize(lIntFact, lFiltSize,
02372 dpNullPtr, (iHighPass) ? true : false)) return 0;
02373 return 1;
02374 }
02375
02376
02377 void dsp_int_fft_uninit (dsp_intfft_t dspintfftInst)
02378 {
02379 ((clFFTInterpolator *) dspintfftInst)->Uninitialize();
02380 }
02381
02382
02383 void dsp_int_fft_putf (dsp_intfft_t dspintfftInst, const float *fpSrcData,
02384 long lSrcCount)
02385 {
02386 ((clFFTInterpolator *) dspintfftInst)->Put(fpSrcData, lSrcCount);
02387 }
02388
02389
02390 void dsp_int_fft_put (dsp_intfft_t dspintfftInst, const double *dpSrcData,
02391 long lSrcCount)
02392 {
02393 ((clFFTInterpolator *) dspintfftInst)->Put(dpSrcData, lSrcCount);
02394 }
02395
02396
02397 int dsp_int_fft_getf (dsp_intfft_t dspintfftInst, float *fpDestData,
02398 long lDestCount)
02399 {
02400 if (!((clFFTInterpolator *) dspintfftInst)->Get(fpDestData, lDestCount))
02401 return 0;
02402 return 1;
02403 }
02404
02405
02406 int dsp_int_fft_get (dsp_intfft_t dspintfftInst, double *dpDestData,
02407 long lDestCount)
02408 {
02409 if (!((clFFTInterpolator *) dspintfftInst)->Get(dpDestData, lDestCount))
02410 return 0;
02411 return 1;
02412 }
02413
02414
02415
02416
02417
02418 dsp_intfir_t dsp_int_fir_new ()
02419 {
02420 return ((dsp_intfir_t) new clFIRInterpolator);
02421 }
02422
02423
02424 void dsp_int_fir_delete (dsp_intfir_t dspintfirInst)
02425 {
02426 delete ((clFIRInterpolator *) dspintfirInst);
02427 }
02428
02429
02430 int dsp_int_fir_initf (dsp_intfir_t dspintfirInst, long lIntFact, int iHighPass)
02431 {
02432 float *fpNullPtr = NULL;
02433
02434 if (!((clFIRInterpolator *) dspintfirInst)->Initialize(lIntFact, fpNullPtr,
02435 (iHighPass) ? true : false)) return 0;
02436 return 1;
02437 }
02438
02439
02440 int dsp_int_fir_init (dsp_intfir_t dspintfirInst, long lIntFact, int iHighPass)
02441 {
02442 double *dpNullPtr = NULL;
02443
02444 if (!((clFIRInterpolator *) dspintfirInst)->Initialize(lIntFact, dpNullPtr,
02445 (iHighPass) ? true : false)) return 0;
02446 return 1;
02447 }
02448
02449
02450 void dsp_int_fir_uninit (dsp_intfir_t dspintfirInst)
02451 {
02452 ((clFIRInterpolator *) dspintfirInst)->Uninitialize();
02453 }
02454
02455
02456 void dsp_int_fir_putf (dsp_intfir_t dspintfirInst, const float *fpSrcData,
02457 long lSrcCount)
02458 {
02459 ((clFIRInterpolator *) dspintfirInst)->Put(fpSrcData, lSrcCount);
02460 }
02461
02462
02463 void dsp_int_fir_put (dsp_intfir_t dspintfirInst, const double *dpSrcData,
02464 long lSrcCount)
02465 {
02466 ((clFIRInterpolator *) dspintfirInst)->Put(dpSrcData, lSrcCount);
02467 }
02468
02469
02470 int dsp_int_fir_getf (dsp_intfir_t dspintfirInst, float *fpDestData,
02471 long lDestCount)
02472 {
02473 if (!((clFIRInterpolator *) dspintfirInst)->Get(fpDestData, lDestCount))
02474 return 0;
02475 return 1;
02476 }
02477
02478
02479 int dsp_int_fir_get (dsp_intfir_t dspintfirInst, double *dpDestData,
02480 long lDestCount)
02481 {
02482 if (!((clFIRInterpolator *) dspintfirInst)->Get(dpDestData, lDestCount))
02483 return 0;
02484 return 1;
02485 }
02486
02487
02488
02489
02490
02491 dsp_intiir_t dsp_int_iir_new ()
02492 {
02493 return ((dsp_intiir_t) new clIIRInterpolator);
02494 }
02495
02496
02497 void dsp_int_iir_delete (dsp_intiir_t dspintiirInst)
02498 {
02499 delete ((clIIRInterpolator *) dspintiirInst);
02500 }
02501
02502
02503 int dsp_int_iir_initf (dsp_intiir_t dspintiirInst, long lIntFact, int iHighPass)
02504 {
02505 float *fpNullPtr = NULL;
02506
02507 if (!((clIIRInterpolator *) dspintiirInst)->Initialize(lIntFact, fpNullPtr,
02508 (iHighPass) ? true : false)) return 0;
02509 return 1;
02510 }
02511
02512
02513 int dsp_int_iir_init (dsp_intiir_t dspintiirInst, long lIntFact, int iHighPass)
02514 {
02515 double *dpNullPtr = NULL;
02516
02517 if (!((clIIRInterpolator *) dspintiirInst)->Initialize(lIntFact, dpNullPtr,
02518 (iHighPass) ? true : false)) return 0;
02519 return 1;
02520 }
02521
02522
02523 void dsp_int_iir_uninit (dsp_intiir_t dspintiirInst)
02524 {
02525 ((clIIRInterpolator *) dspintiirInst)->Uninitialize();
02526 }
02527
02528
02529 void dsp_int_iir_putf (dsp_intiir_t dspintiirInst, const float *fpSrcData,
02530 long lSrcCount)
02531 {
02532 ((clIIRInterpolator *) dspintiirInst)->Put(fpSrcData, lSrcCount);
02533 }
02534
02535
02536 void dsp_int_iir_put (dsp_intiir_t dspintiirInst, const double *dpSrcData,
02537 long lSrcCount)
02538 {
02539 ((clIIRInterpolator *) dspintiirInst)->Put(dpSrcData, lSrcCount);
02540 }
02541
02542
02543 int dsp_int_iir_getf (dsp_intiir_t dspintiirInst, float *fpDestData,
02544 long lDestCount)
02545 {
02546 if (!((clIIRInterpolator *) dspintiirInst)->Get(fpDestData, lDestCount))
02547 return 0;
02548 return 1;
02549 }
02550
02551
02552 int dsp_int_iir_get (dsp_intiir_t dspintiirInst, double *dpDestData,
02553 long lDestCount)
02554 {
02555 if (!((clIIRInterpolator *) dspintiirInst)->Get(dpDestData, lDestCount))
02556 return 0;
02557 return 1;
02558 }
02559
02560
02561
02562
02563
02564 dsp_intrec_t dsp_int_rec_new ()
02565 {
02566 return ((dsp_intrec_t) new clRecInterpolator);
02567 }
02568
02569
02570 void dsp_int_rec_delete (dsp_intrec_t dspintrecInst)
02571 {
02572 delete ((clRecInterpolator *) dspintrecInst);
02573 }
02574
02575
02576 int dsp_int_rec_initf (dsp_intrec_t dspintrecInst, long lIntFact,
02577 long lFiltSize, float fBandCenter, int iFilterType)
02578 {
02579 float *fpNullPtr = NULL;
02580
02581 if (!((clRecInterpolator *) dspintrecInst)->Initialize(lIntFact,
02582 lFiltSize, fpNullPtr, fBandCenter, iFilterType))
02583 return 0;
02584 return 1;
02585 }
02586
02587
02588 int dsp_int_rec_init (dsp_intrec_t dspintrecInst, long lIntFact,
02589 long lFiltSize, double dBandCenter, int iFilterType)
02590 {
02591 double *dpNullPtr = NULL;
02592
02593 if (!((clRecInterpolator *) dspintrecInst)->Initialize(lIntFact,
02594 lFiltSize, dpNullPtr, dBandCenter, iFilterType))
02595 return 0;
02596 return 1;
02597 }
02598
02599
02600 void dsp_int_rec_uninit (dsp_intrec_t dspintrecInst)
02601 {
02602 ((clRecInterpolator *) dspintrecInst)->Uninitialize();
02603 }
02604
02605
02606 void dsp_int_rec_putf (dsp_intrec_t dspintrecInst, const float *fpSrcData,
02607 long lSrcCount)
02608 {
02609 ((clRecInterpolator *) dspintrecInst)->Put(fpSrcData, lSrcCount);
02610 }
02611
02612
02613 void dsp_int_rec_put (dsp_intrec_t dspintrecInst, const double *dpSrcData,
02614 long lSrcCount)
02615 {
02616 ((clRecInterpolator *) dspintrecInst)->Put(dpSrcData, lSrcCount);
02617 }
02618
02619
02620 int dsp_int_rec_getf (dsp_intrec_t dspintrecInst, float *fpDestData,
02621 long lDestCount)
02622 {
02623 if (!((clRecInterpolator *) dspintrecInst)->Get(fpDestData, lDestCount))
02624 return 0;
02625 return 1;
02626 }
02627
02628
02629 int dsp_int_rec_get (dsp_intrec_t dspintrecInst, double *dpDestData,
02630 long lDestCount)
02631 {
02632 if (!((clRecInterpolator *) dspintrecInst)->Get(dpDestData, lDestCount))
02633 return 0;
02634 return 1;
02635 }
02636
02637
02638
02639
02640
02641 dsp_filter_t dsp_filter_new ()
02642 {
02643 return ((dsp_filter_t) new clFilter);
02644 }
02645
02646
02647 void dsp_filter_delete (dsp_filter_t dspfilterInst)
02648 {
02649 delete ((clFilter *) dspfilterInst);
02650 }
02651
02652
02653 int dsp_filter_initf (dsp_filter_t dspfilterInst, long lWindowSize)
02654 {
02655 float *fpNullPtr = NULL;
02656
02657 if (!((clFilter *) dspfilterInst)->Initialize(lWindowSize, fpNullPtr))
02658 return 0;
02659 return 1;
02660 }
02661
02662
02663 int dsp_filter_init (dsp_filter_t dspfilterInst, long lWindowSize)
02664 {
02665 double *dpNullPtr = NULL;
02666
02667 if (!((clFilter *) dspfilterInst)->Initialize(lWindowSize, dpNullPtr))
02668 return 0;
02669 return 1;
02670 }
02671
02672
02673 int dsp_filter_init2f (dsp_filter_t dspfilterInst, long lWindowSize,
02674 const float *fpFiltCoeffs, float fOverlap, float fBeta)
02675 {
02676 if (!((clFilter *) dspfilterInst)->Initialize(lWindowSize, fpFiltCoeffs,
02677 fOverlap, fBeta)) return 0;
02678 return 1;
02679 }
02680
02681
02682 int dsp_filter_init2 (dsp_filter_t dspfilterInst, long lWindowSize,
02683 const double *dpFiltCoeffs, double dOverlap, double dBeta)
02684 {
02685 if (!((clFilter *) dspfilterInst)->Initialize(lWindowSize, dpFiltCoeffs,
02686 dOverlap, dBeta)) return 0;
02687 return 1;
02688 }
02689
02690
02691 int dsp_filter_init_lpf (dsp_filter_t dspfilterInst, float fPassBand,
02692 float fStopBand, float fRippleRatio, float fOverlap)
02693 {
02694 if (!((clFilter *) dspfilterInst)->InitializeLP(fPassBand, fStopBand,
02695 fRippleRatio, fOverlap)) return 0;
02696 return 1;
02697 }
02698
02699
02700 int dsp_filter_init_lp (dsp_filter_t dspfilterInst, double dPassBand,
02701 double dStopBand, double dRippleRatio, double dOverlap)
02702 {
02703 if (!((clFilter *) dspfilterInst)->InitializeLP(dPassBand, dStopBand,
02704 dRippleRatio, dOverlap)) return 0;
02705 return 1;
02706 }
02707
02708
02709 int dsp_filter_init_hpf (dsp_filter_t dspfilterInst, float fPassBand,
02710 float fStopBand, float fRippleRatio, float fOverlap)
02711 {
02712 if (!((clFilter *) dspfilterInst)->InitializeHP(fPassBand, fStopBand,
02713 fRippleRatio, fOverlap)) return 0;
02714 return 1;
02715 }
02716
02717
02718 int dsp_filter_init_hp (dsp_filter_t dspfilterInst, double dPassBand,
02719 double dStopBand, double dRippleRatio, double dOverlap)
02720 {
02721 if (!((clFilter *) dspfilterInst)->InitializeHP(dPassBand, dStopBand,
02722 dRippleRatio, dOverlap)) return 0;
02723 return 1;
02724 }
02725
02726
02727 void dsp_filter_set_coeffsf (dsp_filter_t dspfilterInst,
02728 const float *fpFiltCoeffs)
02729 {
02730 ((clFilter *) dspfilterInst)->SetCoeffs(fpFiltCoeffs);
02731 }
02732
02733
02734 void dsp_filter_set_coeffs (dsp_filter_t dspfilterInst,
02735 const double *dpFiltCoeffs)
02736 {
02737 ((clFilter *) dspfilterInst)->SetCoeffs(dpFiltCoeffs);
02738 }
02739
02740
02741 void dsp_filter_set_ccoeffsf (dsp_filter_t dspfilterInst,
02742 const stpSCplx spFiltCoeffs, int iSmooth)
02743 {
02744 ((clFilter *) dspfilterInst)->SetCoeffs(spFiltCoeffs,
02745 (iSmooth) ? true : false);
02746 }
02747
02748
02749 void dsp_filter_set_ccoeffs (dsp_filter_t dspfilterInst,
02750 const stpDCplx spFiltCoeffs, int iSmooth)
02751 {
02752 ((clFilter *) dspfilterInst)->SetCoeffs(spFiltCoeffs,
02753 (iSmooth) ? true : false);
02754 }
02755
02756
02757 void dsp_filter_get_coeffsf (dsp_filter_t dspfilterInst,
02758 float *fpFiltCoeffs)
02759 {
02760 ((clFilter *) dspfilterInst)->GetCoeffs(fpFiltCoeffs);
02761 }
02762
02763
02764 void dsp_filter_get_coeffs (dsp_filter_t dspfilterInst,
02765 double *dpFiltCoeffs)
02766 {
02767 ((clFilter *) dspfilterInst)->GetCoeffs(dpFiltCoeffs);
02768 }
02769
02770
02771 void dsp_filter_get_ccoeffsf (dsp_filter_t dspfilterInst,
02772 stpSCplx spFiltCoeffs)
02773 {
02774 ((clFilter *) dspfilterInst)->GetCoeffs(spFiltCoeffs);
02775 }
02776
02777
02778 void dsp_filter_get_ccoeffs (dsp_filter_t dspfilterInst,
02779 stpDCplx spFiltCoeffs)
02780 {
02781 ((clFilter *) dspfilterInst)->GetCoeffs(spFiltCoeffs);
02782 }
02783
02784
02785 void dsp_filter_putf (dsp_filter_t dspfilterInst, const float *fpSrcData,
02786 long lSrcCount)
02787 {
02788 ((clFilter *) dspfilterInst)->Put(fpSrcData, lSrcCount);
02789 }
02790
02791
02792 void dsp_filter_put (dsp_filter_t dspfilterInst, const double *dpSrcData,
02793 long lSrcCount)
02794 {
02795 ((clFilter *) dspfilterInst)->Put(dpSrcData, lSrcCount);
02796 }
02797
02798
02799 void dsp_filter_put2f (dsp_filter_t dspfilterInst, const float *fpSrcData,
02800 long lSrcCount, const stpSCplx spCoeffs)
02801 {
02802 ((clFilter *) dspfilterInst)->Put(fpSrcData, lSrcCount, spCoeffs);
02803 }
02804
02805
02806 void dsp_filter_put2 (dsp_filter_t dspfilterInst, const double *dpSrcData,
02807 long lSrcCount, const stpDCplx spCoeffs)
02808 {
02809 ((clFilter *) dspfilterInst)->Put(dpSrcData, lSrcCount, spCoeffs);
02810 }
02811
02812
02813 void dsp_filter_getf (dsp_filter_t dspfilterInst, float *fpDestData,
02814 long lDestCount)
02815 {
02816 ((clFilter *) dspfilterInst)->Get(fpDestData, lDestCount);
02817 }
02818
02819
02820 void dsp_filter_get (dsp_filter_t dspfilterInst, double *dpDestData,
02821 long lDestCount)
02822 {
02823 ((clFilter *) dspfilterInst)->Get(dpDestData, lDestCount);
02824 }
02825
02826
02827 void dsp_filter_design_lpf (dsp_filter_t dspfilterInst, float *fpCorner,
02828 int iDCBlock)
02829 {
02830 ((clFilter *) dspfilterInst)->DesignLP(fpCorner,
02831 (iDCBlock) ? true : false);
02832 }
02833
02834
02835 void dsp_filter_design_lp (dsp_filter_t dspfilterInst, double *dpCorner,
02836 int iDCBlock)
02837 {
02838 ((clFilter *) dspfilterInst)->DesignLP(dpCorner,
02839 (iDCBlock) ? true : false);
02840 }
02841
02842
02843 void dsp_filter_design_lp2f (dsp_filter_t dspfilterInst, float *fpCorner,
02844 float fSampleRate, int iDCBlock)
02845 {
02846 ((clFilter *) dspfilterInst)->DesignLP(fpCorner, fSampleRate,
02847 (iDCBlock) ? true : false);
02848 }
02849
02850
02851 void dsp_filter_design_lp2 (dsp_filter_t dspfilterInst, double *dpCorner,
02852 double dSampleRate, int iDCBlock)
02853 {
02854 ((clFilter *) dspfilterInst)->DesignLP(dpCorner, dSampleRate,
02855 (iDCBlock) ? true : false);
02856 }
02857
02858
02859 void dsp_filter_design_hpf (dsp_filter_t dspfilterInst, float *fpCorner)
02860 {
02861 ((clFilter *) dspfilterInst)->DesignHP(fpCorner);
02862 }
02863
02864
02865 void dsp_filter_design_hp (dsp_filter_t dspfilterInst, double *dpCorner)
02866 {
02867 ((clFilter *) dspfilterInst)->DesignHP(dpCorner);
02868 }
02869
02870
02871 void dsp_filter_design_hp2f (dsp_filter_t dspfilterInst, float *fpCorner,
02872 float fSampleRate)
02873 {
02874 ((clFilter *) dspfilterInst)->DesignHP(fpCorner, fSampleRate);
02875 }
02876
02877
02878 void dsp_filter_design_hp2 (dsp_filter_t dspfilterInst, double *dpCorner,
02879 double dSampleRate)
02880 {
02881 ((clFilter *) dspfilterInst)->DesignHP(dpCorner, dSampleRate);
02882 }
02883
02884
02885 void dsp_filter_design_bpf (dsp_filter_t dspfilterInst, float *fpLowCorner,
02886 float *fpHighCorner)
02887 {
02888 ((clFilter *) dspfilterInst)->DesignBP(fpLowCorner, fpHighCorner);
02889 }
02890
02891
02892 void dsp_filter_design_bp (dsp_filter_t dspfilterInst, double *dpLowCorner,
02893 double *dpHighCorner)
02894 {
02895 ((clFilter *) dspfilterInst)->DesignBP(dpLowCorner, dpHighCorner);
02896 }
02897
02898
02899 void dsp_filter_design_bp2f (dsp_filter_t dspfilterInst, float *fpLowCorner,
02900 float *fpHighCorner, float fSampleRate)
02901 {
02902 ((clFilter *) dspfilterInst)->DesignBP(fpLowCorner, fpHighCorner,
02903 fSampleRate);
02904 }
02905
02906
02907 void dsp_filter_design_bp2 (dsp_filter_t dspfilterInst, double *dpLowCorner,
02908 double *dpHighCorner, double dSampleRate)
02909 {
02910 ((clFilter *) dspfilterInst)->DesignBP(dpLowCorner, dpHighCorner,
02911 dSampleRate);
02912 }
02913
02914
02915 void dsp_filter_design_brf (dsp_filter_t dspfilterInst, float *fpLowCorner,
02916 float *fpHighCorner)
02917 {
02918 ((clFilter *) dspfilterInst)->DesignBR(fpLowCorner, fpHighCorner);
02919 }
02920
02921
02922 void dsp_filter_design_br (dsp_filter_t dspfilterInst, double *dpLowCorner,
02923 double *dpHighCorner)
02924 {
02925 ((clFilter *) dspfilterInst)->DesignBR(dpLowCorner, dpHighCorner);
02926 }
02927
02928
02929 void dsp_filter_design_br2f (dsp_filter_t dspfilterInst, float *fpLowCorner,
02930 float *fpHighCorner, float fSampleRate)
02931 {
02932 ((clFilter *) dspfilterInst)->DesignBR(fpLowCorner, fpHighCorner,
02933 fSampleRate);
02934 }
02935
02936
02937 void dsp_filter_design_br2 (dsp_filter_t dspfilterInst, double *dpLowCorner,
02938 double *dpHighCorner, double dSampleRate)
02939 {
02940 ((clFilter *) dspfilterInst)->DesignBR(dpLowCorner, dpHighCorner,
02941 dSampleRate);
02942 }
02943
02944
02945
02946
02947
02948 dsp_rebuf_t dsp_rebuf_new ()
02949 {
02950 return ((dsp_rebuf_t) new clReBuffer);
02951 }
02952
02953
02954 void dsp_rebuf_delete (dsp_rebuf_t dsprebufInst)
02955 {
02956 delete ((clReBuffer *) dsprebufInst);
02957 }
02958
02959
02960 void dsp_rebuf_putf (dsp_rebuf_t dsprebufInst, const float *fpSrcData,
02961 long lSrcCount)
02962 {
02963 ((clReBuffer *) dsprebufInst)->Put(fpSrcData, lSrcCount);
02964 }
02965
02966
02967 void dsp_rebuf_put (dsp_rebuf_t dsprebufInst, const double *dpSrcData,
02968 long lSrcCount)
02969 {
02970 ((clReBuffer *) dsprebufInst)->Put(dpSrcData, lSrcCount);
02971 }
02972
02973
02974 int dsp_rebuf_getf (dsp_rebuf_t dsprebufInst, float *fpDestData,
02975 long lDestCount)
02976 {
02977 if (!((clReBuffer *) dsprebufInst)->Get(fpDestData, lDestCount))
02978 return 0;
02979 return 1;
02980 }
02981
02982
02983 int dsp_rebuf_get (dsp_rebuf_t dsprebufInst, double *dpDestData,
02984 long lDestCount)
02985 {
02986 if (!((clReBuffer *) dsprebufInst)->Get(dpDestData, lDestCount))
02987 return 0;
02988 return 1;
02989 }
02990
02991
02992 long dsp_rebuf_size (dsp_rebuf_t dsprebufInst)
02993 {
02994 return ((clReBuffer *) dsprebufInst)->GetCount();
02995 }
02996
02997
02998 void dsp_rebuf_clear (dsp_rebuf_t dsprebufInst)
02999 {
03000 ((clReBuffer *) dsprebufInst)->Clear();
03001 }
03002
03003
03004 void dsp_rebuf_copy (dsp_rebuf_t dsprebufInst, dsp_rebuf_t dsprebufCopySrc)
03005 {
03006 *((clReBuffer *) dsprebufInst) = *((clReBuffer *) dsprebufCopySrc);
03007
03008
03009
03010 }
03011
03012 }