cdspop.cc

各种工程计算的库函数

{
    clDSPOp::PolarToCart(upCoord, lCount);
}


float dsp_crosscorrf (const float *fpSrc1, const float *fpSrc2, long lCount)
{
    return clDSPOp::CrossCorr(fpSrc1, fpSrc2, lCount);
}


double dsp_crosscorr (const double *dpSrc1, const double *dpSrc2, long lCount)
{
    return clDSPOp::CrossCorr(dpSrc1, dpSrc2, lCount);
}


float dsp_crosscorr2f (const float *fpSrc1, const float *fpSrc2,
    long lDelay, long lCount)
{
    return clDSPOp::DelCrossCorr(fpSrc1, fpSrc2, lDelay, lCount);
}


double dsp_crosscorr2 (const double *dpSrc1, const double *dpSrc2,
    long lDelay, long lCount)
{
    return clDSPOp::DelCrossCorr(dpSrc1, dpSrc2, lDelay, lCount);
}


void dsp_crosscorr3f (float *fpDest, const float *fpSrc1, 
    const float *fpSrc2, long lCount, const long *lpDelays, long lDelayCount)
{
    clDSPOp::DelCrossCorr(fpDest, fpSrc1, fpSrc2, lCount, 
        lpDelays, lDelayCount);
}


void dsp_crosscorr3 (double *dpDest, const double *dpSrc1,
    const double *dpSrc2, long lCount, const long *lpDelays, long lDelayCount)
{
    clDSPOp::DelCrossCorr(dpDest, dpSrc1, dpSrc2, lCount,
        lpDelays, lDelayCount);
}


float dsp_energyf (const float *fpSrc, long lCount)
{
    return clDSPOp::Energy(fpSrc, lCount);
}


double dsp_energy (const double *dpSrc, long lCount)
{
    return clDSPOp::Energy(dpSrc, lCount);
}


void dsp_magnitudef (float *fpDest, const stpSCplx spSrc, long lCount)
{
    clDSPOp::Magnitude(fpDest, spSrc, lCount);
}


void dsp_magnitude (double *dpDest, const stpDCplx spSrc, long lCount)
{
    clDSPOp::Magnitude(dpDest, spSrc, lCount);
}


void dsp_powerf (float *fpDest, const stpSCplx spSrc, long lCount)
{
    clDSPOp::Power(fpDest, spSrc, lCount);
}


void dsp_power (double *dpDest, const stpDCplx spSrc, long lCount)
{
    clDSPOp::Power(dpDest, spSrc, lCount);
}


void dsp_phasef (float *fpDest, const stpSCplx spSrc, long lCount)
{
    clDSPOp::Phase(fpDest, spSrc, lCount);
}


void dsp_phase (double *dpDest, const stpDCplx spSrc, long lCount)
{
    clDSPOp::Phase(dpDest, spSrc, lCount);
}


void dsp_powerphasef (float *fpPower, float *fpPhase, const stpSCplx spSrc,
    long lCount)
{
    clDSPOp::PowerPhase(fpPower, fpPhase, spSrc, lCount);
}


void dsp_powerphase (double *dpPower, double *dpPhase, const stpDCplx spSrc,
    long lCount)
{
    clDSPOp::PowerPhase(dpPower, dpPhase, spSrc, lCount);
}


void dsp_decimatef (float *fpDest, const float *fpSrc, long lFactor,
    long lCount)
{
    clDSPOp::Decimate(fpDest, fpSrc, lFactor, lCount);
}


void dsp_decimate (double *dpDest, const double *dpSrc, long lFactor,
    long lCount)
{
    clDSPOp::Decimate(dpDest, dpSrc, lFactor, lCount);
}


void dsp_decimateavgf (float *fpDest, const float *fpSrc, long lFactor,
    long lCount)
{
    clDSPOp::DecimateAvg(fpDest, fpSrc, lFactor, lCount);
}


void dsp_decimateavg (double *dpDest, const double *dpSrc, long lFactor,
    long lCount)
{
    clDSPOp::DecimateAvg(dpDest, dpSrc, lFactor, lCount);
}


void dsp_interpolatef (float *fpDest, const float *fpSrc, long lFactor,
    long lCount)
{
    clDSPOp::Interpolate(fpDest, fpSrc, lFactor, lCount);
}


void dsp_interpolate (double *dpDest, const double *dpSrc, long lFactor,
    long lCount)
{
    clDSPOp::Interpolate(dpDest, dpSrc, lFactor, lCount);
}


void dsp_resamplef (float *fpDest, long lDestCount, const float *fpSrc,
    long lSrcCount)
{
    clDSPOp::Resample(fpDest, lDestCount, fpSrc, lSrcCount);
}


void dsp_resample (double *dpDest, long lDestCount, const double *dpSrc,
    long lSrcCount)
{
    clDSPOp::Resample(dpDest, lDestCount, dpSrc, lSrcCount);
}


void dsp_resampleavgf (float *fpDest, long lDestCount, const float *fpSrc,
    long lSrcCount)
{
    clDSPOp::ResampleAvg(fpDest, lDestCount, fpSrc, lSrcCount);
}


void dsp_resampleavg (double *dpDest, long lDestCount, const double *dpSrc,
    long lSrcCount)
{
    clDSPOp::ResampleAvg(dpDest, lDestCount, dpSrc, lSrcCount);
}


void dsp_interpolateavgf (float *fpDest, const float *fpSrc, long lFactor,
    long lCount)
{
    clDSPOp::InterpolateAvg(fpDest, fpSrc, lFactor, lCount);
}


void dsp_interpolateavg (double *dpDest, const double *dpSrc, long lFactor,
    long lCount)
{
    clDSPOp::InterpolateAvg(dpDest, dpSrc, lFactor, lCount);
}


float dsp_rmsf (const float *fpSrc, long lCount)
{
    return clDSPOp::RMS(fpSrc, lCount);
}


double dsp_rms (const double *dpSrc, long lCount)
{
    return clDSPOp::RMS(dpSrc, lCount);
}


float dsp_variancef (float *fpVariance, float *fpMean, const float *fpSrc,
    long lCount)
{
    return clDSPOp::Variance(fpVariance, fpMean, fpSrc, lCount);
}


double dsp_variance (double *dpVariance, double *dpMean, const double *dpSrc,
    long lCount)
{
    return clDSPOp::Variance(dpVariance, dpMean, dpSrc, lCount);
}


float dsp_peaklevelf (const float *fpSrc, long lCount)
{
    return clDSPOp::PeakLevel(fpSrc, lCount);
}


double dsp_peaklevel (const double *dpSrc, long lCount)
{
    return clDSPOp::PeakLevel(dpSrc, lCount);
}


void dsp_mixf (float *fpDest, const float *fpSrc, long lCount)
{
    clDSPOp::Mix(fpDest, fpSrc, lCount);
}


void dsp_mix (double *dpDest, const double *dpSrc, long lCount)
{
    clDSPOp::Mix(dpDest, dpSrc, lCount);
}


void dsp_mix2f (float *fpDest, const float *fpSrc1, const float *fpSrc2,
    long lCount)
{
    clDSPOp::Mix(fpDest, fpSrc1, fpSrc2, lCount);
}


void dsp_mix2 (double *dpDest, const double *dpSrc1, const double *dpSrc2,
    long lCount)
{
    clDSPOp::Mix(dpDest, dpSrc1, dpSrc2, lCount);
}


void dsp_mixnf (float *fpDest, const float *fpSrc, long lChCount,
    long lCount)
{
    clDSPOp::Mix(fpDest, fpSrc, lChCount, lCount);
}


void dsp_mixn (double *dpDest, const double *dpSrc, long lChCount,
    long lCount)
{
    clDSPOp::Mix(dpDest, dpSrc, lChCount, lCount);
}


void dsp_extractf (float *fpDest, const float *fpSrc, long lChannel,
    long lChCount, long lCount)
{
    clDSPOp::Extract(fpDest, fpSrc, lChannel, lChCount, lCount);
}


void dsp_extract (double *dpDest, const double *dpSrc, long lChannel,
    long lChCount, long lCount)
{
    clDSPOp::Extract(dpDest, dpSrc, lChannel, lChCount, lCount);
}


void dsp_packf (float *fpDest, const float *fpSrc, long lChannel,
    long lChCount, long lCount)
{
    clDSPOp::Pack(fpDest, fpSrc, lChannel, lChCount, lCount);
}


void dsp_pack (double *dpDest, const double *dpSrc, long lChannel,
    long lChCount, long lCount)
{
    clDSPOp::Pack(dpDest, dpSrc, lChannel, lChCount, lCount);
}


void dsp_fftw_convertf2cf (stpSCplx spDest, const float *fpSrc, long lCount)
{
    clDSPOp::FFTWConvert(spDest, fpSrc, lCount);
}


void dsp_fftw_convertf2cd (stpDCplx spDest, const float *fpSrc, long lCount)
{
    clDSPOp::FFTWConvert(spDest, fpSrc, lCount);
}


void dsp_fftw_convertd2cf (stpSCplx spDest, const double *dpSrc, long lCount)
{
    clDSPOp::FFTWConvert(spDest, dpSrc, lCount);
}


void dsp_fftw_convertd2cd (stpDCplx spDest, const double *dpSrc, long lCount)
{
    clDSPOp::FFTWConvert(spDest, dpSrc, lCount);
}


void dsp_fftw_convertcf2f (float *fpDest, const stpSCplx spSrc, long lCount)
{
    clDSPOp::FFTWConvert(fpDest, spSrc, lCount);
}


void dsp_fftw_convertcd2f (float *fpDest, const stpDCplx spSrc, long lCount)
{
    clDSPOp::FFTWConvert(fpDest, spSrc, lCount);
}


void dsp_fftw_convertcf2d (double *dpDest, const stpSCplx spSrc, long lCount)
{
    clDSPOp::FFTWConvert(dpDest, spSrc, lCount);
}


void dsp_fftw_convertcd2d (double *dpDest, const stpDCplx spSrc, long lCount)
{
    clDSPOp::FFTWConvert(dpDest, spSrc, lCount);
}


dsp_t dsp_new ()
{
    return ((dsp_t) new clDSPOp);
}


void dsp_delete (dsp_t dspInst)
{
    delete ((clDSPOp *) dspInst);
}


void dsp_win_bartlettf (dsp_t dspInst, float *fpDest, long lCount)
{
    ((clDSPOp *) dspInst)->WinBartlett(fpDest, lCount);
}


void dsp_win_bartlett (dsp_t dspInst, double *dpDest, long lCount)
{
    ((clDSPOp *) dspInst)->WinBartlett(dpDest, lCount);
}


void dsp_win_blackmanf (dsp_t dspInst, float *fpDest, long lCount, 
    float fAlpha)
{
    ((clDSPOp *) dspInst)->WinBlackman(fpDest, lCount, fAlpha);
}


void dsp_win_blackman (dsp_t dspInst, double *dpDest, long lCount,
    double dAlpha)
{
    ((clDSPOp *) dspInst)->WinBlackman(dpDest, lCount, dAlpha);
}


void dsp_win_blackman_harrisf (dsp_t dspInst, float *fpDest, long lCount)
{
    ((clDSPOp *) dspInst)->WinBlackmanHarris(fpDest, lCount);
}


void dsp_win_blackman_harris (dsp_t dspInst, double *dpDest, long lCount)
{
    ((clDSPOp *) dspInst)->WinBlackmanHarris(dpDest, lCount);
}


void dsp_win_cos_taperedf (dsp_t dspInst, float *fpDest, long lCount)
{
    ((clDSPOp *) dspInst)->WinCosTapered(fpDest, lCount);
}


void dsp_win_cos_tapered (dsp_t dspInst, double *dpDest, long lCount)
{
    ((clDSPOp *) dspInst)->WinCosTapered(dpDest, lCount);
}


void dsp_win_exact_blackmanf (dsp_t dspInst, float *fpDest, long lCount)
{
    ((clDSPOp *) dspInst)->WinExactBlackman(fpDest, lCount);
}


void dsp_win_exact_blackman (dsp_t dspInst, double *dpDest, long lCount)
{
    ((clDSPOp *) dspInst)->WinExactBlackman(dpDest, lCount);
}


void dsp_win_flat_topf (dsp_t dspInst, float *fpDest, long lCount)
{
    ((clDSPOp *) dspInst)->WinFlatTop(fpDest, lCount);
}


void dsp_win_flat_top (dsp_t dspInst, double *dpDest, long lCount)
{
    ((clDSPOp *) dspInst)->WinFlatTop(dpDest, lCount);
}


void dsp_win_generic_cosf (dsp_t dspInst, float *fpDest, long lCount,
    const float *fpCoeff, long lCoeffCount)
{
    ((clDSPOp *) dspInst)->WinGenericCos(fpDest, lCount, fpCoeff,
        lCoeffCount);
}


void dsp_win_generic_cos (dsp_t dspInst, double *dpDest, long lCount,
    const double *dpCoeff, long lCoeffCount)
{
    ((clDSPOp *) dspInst)->WinGenericCos(dpDest, lCount, dpCoeff,
        lCoeffCount);
}


void dsp_win_hammingf (dsp_t dspInst, float *fpDest, long lCount)
{
    ((clDSPOp *) dspInst)->WinHamming(fpDest, lCount);
}


void dsp_win_hamming (dsp_t dspInst, double *dpDest, long lCount)
{
    ((clDSPOp *) dspInst)->WinHamming(dpDest, lCount);
}


void dsp_win_hanningf (dsp_t dspInst, float *fpDest, long lCount)
{
    ((clDSPOp *) dspInst)->WinHanning(fpDest, lCount);
}


void dsp_win_hanning (dsp_t dspInst, double *dpDest, long lCount)
{
    ((clDSPOp *) dspInst)->WinHanning(dpDest, lCount);
}


void dsp_win_kaiserf (dsp_t dspInst, float *fpDest, float fBeta, long lCount)
{
    ((clDSPOp *) dspInst)->WinKaiser(fpDest, fBeta, lCount);
}


void dsp_win_kaiser (dsp_t dspInst, double *dpDest, double dBeta, long lCount)
{
    ((clDSPOp *) dspInst)->WinKaiser(dpDest, dBeta, lCount);
}


void dsp_win_kaiser_besself (dsp_t dspInst, float *fpDest, float fAlpha,
    long lCount)
{
    ((clDSPOp *) dspInst)->WinKaiserBessel(fpDest, fAlpha, lCount);
}


void dsp_win_kaiser_bessel (dsp_t dspInst, double *dpDest, double dAlpha,
    long lCount)
{
    ((clDSPOp *) dspInst)->WinKaiserBessel(dpDest, dAlpha, lCount);
}


void dsp_win_tukeyf (dsp_t dspInst, float *fpDest, long lCount)
{
    ((clDSPOp *) dspInst)->WinTukey(fpDest, lCount);
}


void dsp_win_tukey (dsp_t dspInst, double *dpDest, long lCount)
{
    ((clDSPOp *) dspInst)->WinTukey(dpDest, lCount);
}


void dsp_win_dolph_chebyshevf (dsp_t dspInst, float *fpDest, float fGamma,
    long lCount)
{
    ((clDSPOp *) dspInst)->WinDolphChebyshev(fpDest, fGamma, lCount);
}


void dsp_win_dolph_chebyshev (dsp_t dspInst, double *dpDest, double dGamma,
    long lCount)
{
    ((clDSPOp *) dspInst)->WinDolphChebyshev(dpDest, dGamma, lCount);
}


long dsp_rebufferf (dsp_t dspInst, float *fpDest, const float *fpSrc,
    long lDestCount, long lSrcCount)
{
    return ((clDSPOp *) dspInst)->ReBuffer(fpDest, fpSrc, lDestCount,
        lSrcCount);
}


long dsp_rebuffer (dsp_t dspInst, double *dpDest, const double *dpSrc,
    long lDestCount, long lSrcCount)
{
    return ((clDSPOp *) dspInst)->ReBuffer(dpDest, dpSrc, lDestCount,
        lSrcCount);
}


float dsp_deg2radf (dsp_t dspInst, float fSource)
{
    return ((clDSPOp *) dspInst)->DegToRad(fSource);
}


double dsp_deg2rad (dsp_t dspInst, double dSource)
{
    return ((clDSPOp *) dspInst)->DegToRad(dSource);
}


float dsp_rad2degf (dsp_t dspInst, float fSource)
{
    return ((clDSPOp *) dspInst)->RadToDeg(fSource);
}


double dsp_rad2deg (dsp_t dspInst, double dSource)
{
    return ((clDSPOp *) dspInst)->RadToDeg(dSource);
}


void dsp_fir_allocatef (dsp_t dspInst, const float *fpCoeff, long lCount)
{
    ((clDSPOp *) dspInst)->FIRAllocate(fpCoeff, lCount);
}


void dsp_fir_allocate (dsp_t dspInst, const double *dpCoeff, long lCount)
{
    ((clDSPOp *) dspInst)->FIRAllocate(dpCoeff, lCount);
}


void dsp_fir_free (dsp_t dspInst)
{
    ((clDSPOp *) dspInst)->FIRFree();
}


void dsp_fir_filterf (dsp_t dspInst, float *fpVect, long lCount)
{
    ((clDSPOp *) dspInst)->FIRFilter(fpVect, lCount);
}


void dsp_fir_filter (dsp_t dspInst, double *dpVect, long lCount)
{
    ((clDSPOp *) dspInst)->FIRFilter(dpVect, lCount);
}


void dsp_fir_filterf_nip (dsp_t dspInst, float *fpDest, const float *fpSrc,
    long lCount)
{
    ((clDSPOp *) dspInst)->FIRFilter(fpDest, fpSrc, lCount);
}


void dsp_fir_filter_nip (dsp_t dspInst, double *dpDest, const double *dpSrc,
    long lCount)
{
    ((clDSPOp *) dspInst)->FIRFilter(dpDest, dpSrc, lCount);
}


void dsp_fir_filterf_fst (dsp_t dspInst, float *fpDest, float *fpSrc,
    long lCount)
{
    ((clDSPOp *) dspInst)->FIRFilterF(fpDest, fpSrc, lCount);
}


void dsp_fir_filter_fst (dsp_t dspInst, double *dpDest, double *dpSrc,
    long lCount)
{
    ((clDSPOp *) dspInst)->FIRFilterF(dpDest, dpSrc, lCount);
}