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

cdspop.cc

Go to the documentation of this file.
00001 /*
00002 
00003     DSP operations C-wrapper
00004     Copyright (C) 2002-2003 Jussi Laako
00005 
00006     This program is free software; you can redistribute it and/or modify
00007     it under the terms of the GNU General Public License as published by
00008     the Free Software Foundation; either version 2 of the License, or
00009     (at your option) any later version.
00010 
00011     This program is distributed in the hope that it will be useful,
00012     but WITHOUT ANY WARRANTY; without even the implied warranty of
00013     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014     GNU General Public License for more details.
00015 
00016     You should have received a copy of the GNU General Public License
00017     along with this program; if not, write to the Free Software
00018     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00019 
00020 */
00021 
00022 
00023 #include "dsp/dspop.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 /* clDSPOp */
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 /* clIIRCascade */
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 /* clFFTDecimator */
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 /* clFIRDecimator */
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 /* clIIRDecimator */
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 /* clRecDecimator */
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 /* clFFTInterpolator */
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 /* clFIRInterpolator */
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 /* clIIRInterpolator */
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 /* clRecInterpolator */
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 /* clFilter */
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 /* clReBuffer */
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     /* or */
03008     /*((clReBuffer *) dsprebufInst)->operator=(*((clReBuffer *) dsprebufCopySrc));*/
03009     /* if you like... :) */
03010 }
03011 
03012 }

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