cdspop.cc

各种工程计算的库函数

void dsp_iir_initf (dsp_t dspInst, const float *fpCoeffs)
{
    ((clDSPOp *) dspInst)->IIRInitialize(fpCoeffs);
}


void dsp_iir_init (dsp_t dspInst, const double *dpCoeffs)
{
    ((clDSPOp *) dspInst)->IIRInitialize(dpCoeffs);
}


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


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


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


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


void dsp_iir_clear (dsp_t dspInst)
{
    ((clDSPOp *) dspInst)->IIRClear();
}


void dsp_fft_init (dsp_t dspInst, long lSize, int iReal)
{
    ((clDSPOp *) dspInst)->FFTInitialize(lSize, (iReal) ? true : false);
}


void dsp_fft_uninit (dsp_t dspInst)
{
    ((clDSPOp *) dspInst)->FFTUninitialize();
}


void dsp_fftf (dsp_t dspInst, stpSCplx spDest, float *fpSrc)
{
    ((clDSPOp *) dspInst)->FFTi(spDest, fpSrc);
}


void dsp_fft (dsp_t dspInst, stpDCplx spDest, double *dpSrc)
{
    ((clDSPOp *) dspInst)->FFTi(spDest, dpSrc);
}


void dsp_fftf_nip (dsp_t dspInst, stpSCplx spDest, const float *fpSrc)
{
    ((clDSPOp *) dspInst)->FFTo(spDest, fpSrc);
}


void dsp_fft_nip (dsp_t dspInst, stpDCplx spDest, const double *dpSrc)
{
    ((clDSPOp *) dspInst)->FFTo(spDest, dpSrc);
}


void dsp_cfftf_nip (dsp_t dspInst, stpSCplx spDest, const stpSCplx spSrc)
{
    ((clDSPOp *) dspInst)->FFTo(spDest, spSrc);
}


void dsp_cfft_nip (dsp_t dspInst, stpDCplx spDest, const stpDCplx spSrc)
{
    ((clDSPOp *) dspInst)->FFTo(spDest, spSrc);
}


void dsp_ifftf_nip (dsp_t dspInst, float *fpDest, const stpSCplx spSrc)
{
    ((clDSPOp *) dspInst)->IFFTo(fpDest, spSrc);
}


void dsp_ifft_nip (dsp_t dspInst, double *dpDest, const stpDCplx spSrc)
{
    ((clDSPOp *) dspInst)->IFFTo(dpDest, spSrc);
}


void dsp_cifftf_nip (dsp_t dspInst, stpSCplx spDest, const stpSCplx spSrc)
{
    ((clDSPOp *) dspInst)->IFFTo(spDest, spSrc);
}


void dsp_cifft_nip (dsp_t dspInst, stpDCplx spDest, const stpDCplx spSrc)
{
    ((clDSPOp *) dspInst)->IFFTo(spDest, spSrc);
}


void dsp_dct_init (dsp_t dspInst, long lSize)
{
    ((clDSPOp *) dspInst)->DCTInitialize(lSize);
}


void dsp_dct_uninit (dsp_t dspInst)
{
    ((clDSPOp *) dspInst)->FFTUninitialize();
}


void dsp_dctf (dsp_t dspInst, float *fpVect)
{
    ((clDSPOp *) dspInst)->DCTi(fpVect);
}


void dsp_dct (dsp_t dspInst, double *dpVect)
{
    ((clDSPOp *) dspInst)->DCTi(dpVect);
}


void dsp_dctf_nip (dsp_t dspInst, float *fpDest, const float *fpSrc)
{
    ((clDSPOp *) dspInst)->DCTo(fpDest, fpSrc);
}


void dsp_dct_nip (dsp_t dspInst, double *dpDest, const double *dpSrc)
{
    ((clDSPOp *) dspInst)->DCTo(dpDest, dpSrc);
}


void dsp_idctf (dsp_t dspInst, float *fpVect)
{
    ((clDSPOp *) dspInst)->IDCTi(fpVect);
}


void dsp_idct (dsp_t dspInst, double *dpVect)
{
    ((clDSPOp *) dspInst)->IDCTi(dpVect);
}


void dsp_idctf_nip (dsp_t dspInst, float *fpDest, const float *fpSrc)
{
    ((clDSPOp *) dspInst)->IDCTo(fpDest, fpSrc);
}


void dsp_idct_nip (dsp_t dspInst, double *dpDest, const double *dpSrc)
{
    ((clDSPOp *) dspInst)->IDCTo(dpDest, dpSrc);
}


/* clIIRCascade */


dsp_iircas_t dsp_iir_cas_new ()
{
    return ((dsp_iircas_t) new clIIRCascade);
}


void dsp_iir_cas_delete (dsp_iircas_t dspiircasInst)
{
    delete ((clIIRCascade *) dspiircasInst);
}


int dsp_iir_cas_initf (dsp_iircas_t dspiircasInst, 
    const float fpCoeffs[][5], long lStageCount)
{
    if (!((clIIRCascade *) dspiircasInst)->Initialize(fpCoeffs, lStageCount))
        return 0;
    return 1;
}


int dsp_iir_cas_init (dsp_iircas_t dspiircasInst, 
    const double dpCoeffs[][5], long lStageCount)
{
    if (!((clIIRCascade *) dspiircasInst)->Initialize(dpCoeffs, lStageCount))
        return 0;
    return 1;
}


void dsp_iir_cas_uninit (dsp_iircas_t dspiircasInst)
{
    ((clIIRCascade *) dspiircasInst)->Uninitialize();
}


void dsp_iir_cas_processf (dsp_iircas_t dspiircasInst, 
    float *fpVect, long lCount)
{
    ((clIIRCascade *) dspiircasInst)->Process(fpVect, lCount);
}


void dsp_iir_cas_process (dsp_iircas_t dspiircasInst,
    double *dpVect, long lCount)
{
    ((clIIRCascade *) dspiircasInst)->Process(dpVect, lCount);
}


void dsp_iir_cas_processf_nip (dsp_iircas_t dspiircasInst,
    float *fpDest, const float *fpSrc, long lCount)
{
    ((clIIRCascade *) dspiircasInst)->Process(fpDest, fpSrc, lCount);
}


void dsp_iir_cas_process_nip (dsp_iircas_t dspiircasInst,
    double *dpDest, const double *dpSrc, long lCount)
{
    ((clIIRCascade *) dspiircasInst)->Process(dpDest, dpSrc, lCount);
}


void dsp_iir_cas_clear (dsp_iircas_t dspiircasInst)
{
    ((clIIRCascade *) dspiircasInst)->Clear();
}


/* clFFTDecimator */


dsp_decfft_t dsp_dec_fft_new ()
{
    return ((dsp_decfft_t) new clFFTDecimator);
}


void dsp_dec_fft_delete (dsp_decfft_t dspdecfftInst)
{
    delete ((clFFTDecimator *) dspdecfftInst);
}


int dsp_dec_fft_initf (dsp_decfft_t dspdecfftInst, long lDecFact,
    long lFiltSize, int iHighPass)
{
    float *fpNullPtr = NULL;
    
    if (!((clFFTDecimator *) dspdecfftInst)->Initialize(lDecFact, lFiltSize,
        fpNullPtr, (iHighPass) ? true : false)) return 0;
    return 1;
}


int dsp_dec_fft_init (dsp_decfft_t dspdecfftInst, long lDecFact,
    long lFiltSize, int iHighPass)
{
    double *dpNullPtr = NULL;
    
    if (!((clFFTDecimator *) dspdecfftInst)->Initialize(lDecFact, lFiltSize,
        dpNullPtr, (iHighPass) ? true : false)) return 0;
    return 1;
}


void dsp_dec_fft_uninit (dsp_decfft_t dspdecfftInst)
{
    ((clFFTDecimator *) dspdecfftInst)->Uninitialize();
}


void dsp_dec_fft_putf (dsp_decfft_t dspdecfftInst, const float *fpSrcData,
    long lSrcCount)
{
    ((clFFTDecimator *) dspdecfftInst)->Put(fpSrcData, lSrcCount);
}


void dsp_dec_fft_put (dsp_decfft_t dspdecfftInst, const double *dpSrcData,
    long lSrcCount)
{
    ((clFFTDecimator *) dspdecfftInst)->Put(dpSrcData, lSrcCount);
}


int dsp_dec_fft_getf (dsp_decfft_t dspdecfftInst, float *fpDestData,
    long lDestCount)
{
    if (!((clFFTDecimator *) dspdecfftInst)->Get(fpDestData, lDestCount))
        return 0;
    return 1;
}


int dsp_dec_fft_get (dsp_decfft_t dspdecfftInst, double *dpDestData,
    long lDestCount)
{
    if (!((clFFTDecimator *) dspdecfftInst)->Get(dpDestData, lDestCount))
        return 0;
    return 1;
}


/* clFIRDecimator */


dsp_decfir_t dsp_dec_fir_new ()
{
    return ((dsp_decfir_t) new clFIRDecimator);
}


void dsp_dec_fir_delete (dsp_decfir_t dspdecfirInst)
{
    delete ((clFIRDecimator *) dspdecfirInst);
}


int dsp_dec_fir_initf (dsp_decfir_t dspdecfirInst, long lDecFact, int iHighPass)
{
    float *fpNullPtr = NULL;
    
    if (!((clFIRDecimator *) dspdecfirInst)->Initialize(lDecFact, fpNullPtr,
        (iHighPass) ? true : false)) return 0;
    return 1;
}


int dsp_dec_fir_init (dsp_decfir_t dspdecfirInst, long lDecFact, int iHighPass)
{
    double *dpNullPtr = NULL;
    
    if (!((clFIRDecimator *) dspdecfirInst)->Initialize(lDecFact, dpNullPtr,
        (iHighPass) ? true : false)) return 0;
    return 1;
}


void dsp_dec_fir_uninit (dsp_decfir_t dspdecfirInst)
{
    ((clFIRDecimator *) dspdecfirInst)->Uninitialize();
}


void dsp_dec_fir_putf (dsp_decfir_t dspdecfirInst, const float *fpSrcData,
    long lSrcCount)
{
    ((clFIRDecimator *) dspdecfirInst)->Put(fpSrcData, lSrcCount);
}


void dsp_dec_fir_put (dsp_decfir_t dspdecfirInst, const double *dpSrcData,
    long lSrcCount)
{
    ((clFIRDecimator *) dspdecfirInst)->Put(dpSrcData, lSrcCount);
}


int dsp_dec_fir_getf (dsp_decfir_t dspdecfirInst, float *fpDestData,
    long lDestCount)
{
    if (!((clFIRDecimator *) dspdecfirInst)->Get(fpDestData, lDestCount))
        return 0;
    return 1;
}


int dsp_dec_fir_get (dsp_decfir_t dspdecfirInst, double *dpDestData,
    long lDestCount)
{
    if (!((clFIRDecimator *) dspdecfirInst)->Get(dpDestData, lDestCount))
        return 0;
    return 1;
}


/* clIIRDecimator */


dsp_deciir_t dsp_dec_iir_new ()
{
    return ((dsp_deciir_t) new clIIRDecimator);
}


void dsp_dec_iir_delete (dsp_deciir_t dspdeciirInst)
{
    delete ((clIIRDecimator *) dspdeciirInst);
}


int dsp_dec_iir_initf (dsp_deciir_t dspdeciirInst, long lDecFact, int iHighPass)
{
    float *fpNullPtr = NULL;
    
    if (!((clIIRDecimator *) dspdeciirInst)->Initialize(lDecFact, fpNullPtr,
        (iHighPass) ? true : false)) return 0;
    return 1;
}


int dsp_dec_iir_init (dsp_deciir_t dspdeciirInst, long lDecFact, int iHighPass)
{
    double *dpNullPtr = NULL;
    
    if (!((clIIRDecimator *) dspdeciirInst)->Initialize(lDecFact, dpNullPtr,
        (iHighPass) ? true : false)) return 0;
    return 1;
}


void dsp_dec_iir_uninit (dsp_deciir_t dspdeciirInst)
{
    ((clIIRDecimator *) dspdeciirInst)->Uninitialize();
}


void dsp_dec_iir_putf (dsp_deciir_t dspdeciirInst, const float *fpSrcData,
    long lSrcCount)
{
    ((clIIRDecimator *) dspdeciirInst)->Put(fpSrcData, lSrcCount);
}


void dsp_dec_iir_put (dsp_deciir_t dspdeciirInst, const double *dpSrcData,
    long lSrcCount)
{
    ((clIIRDecimator *) dspdeciirInst)->Put(dpSrcData, lSrcCount);
}


int dsp_dec_iir_getf (dsp_deciir_t dspdeciirInst, float *fpDestData,
    long lDestCount)
{
    if (!((clIIRDecimator *) dspdeciirInst)->Get(fpDestData, lDestCount))
        return 0;
    return 1;
}


int dsp_dec_iir_get (dsp_deciir_t dspdeciirInst, double *dpDestData,
    long lDestCount)
{
    if (!((clIIRDecimator *) dspdeciirInst)->Get(dpDestData, lDestCount))
        return 0;
    return 1;
}


/* clRecDecimator */


dsp_decrec_t dsp_dec_rec_new ()
{
    return ((dsp_decrec_t) new clRecDecimator);
}


void dsp_dec_rec_delete (dsp_decrec_t dspdecrecInst)
{
    delete ((clRecDecimator *) dspdecrecInst);
}


int dsp_dec_rec_initf (dsp_decrec_t dspdecrecInst, long lDecFact,
    long lFiltSize, float fBandCenter, int iFilterType)
{
    float *fpNullPtr = NULL;

    if (!((clRecDecimator *) dspdecrecInst)->Initialize(lDecFact,
        lFiltSize, fpNullPtr, fBandCenter, iFilterType))
        return 0;
    return 1;
}


int dsp_dec_rec_init (dsp_decrec_t dspdecrecInst, long lDecFact,
    long lFiltSize, double dBandCenter, int iFilterType)
{
    double *dpNullPtr = NULL;
    
    if (!((clRecDecimator *) dspdecrecInst)->Initialize(lDecFact,
        lFiltSize, dpNullPtr, dBandCenter, iFilterType))
        return 0;
    return 1;
}


void dsp_dec_rec_uninit (dsp_decrec_t dspdecrecInst)
{
    ((clRecDecimator *) dspdecrecInst)->Uninitialize();
}


void dsp_dec_rec_putf (dsp_decrec_t dspdecrecInst, const float *fpSrcData,
    long lSrcCount)
{
    ((clRecDecimator *) dspdecrecInst)->Put(fpSrcData, lSrcCount);
}


void dsp_dec_rec_put (dsp_decrec_t dspdecrecInst, const double *dpSrcData,
    long lSrcCount)
{
    ((clRecDecimator *) dspdecrecInst)->Put(dpSrcData, lSrcCount);
}


int dsp_dec_rec_getf (dsp_decrec_t dspdecrecInst, float *fpDestData,
    long lDestCount)
{
    if (!((clRecDecimator *) dspdecrecInst)->Get(fpDestData, lDestCount))
        return 0;
    return 1;
}


int dsp_dec_rec_get (dsp_decrec_t dspdecrecInst, double *dpDestData,
    long lDestCount)
{
    if (!((clRecDecimator *) dspdecrecInst)->Get(dpDestData, lDestCount))
        return 0;
    return 1;
}


/* clFFTInterpolator */


dsp_intfft_t dsp_int_fft_new ()
{
    return ((dsp_intfft_t) new clFFTInterpolator);
}


void dsp_int_fft_delete (dsp_intfft_t dspintfftInst)
{
    delete ((clFFTInterpolator *) dspintfftInst);
}


int dsp_int_fft_initf (dsp_intfft_t dspintfftInst, long lIntFact,
    long lFiltSize, int iHighPass)
{
    float *fpNullPtr = NULL;
    
    if (!((clFFTInterpolator *) dspintfftInst)->Initialize(lIntFact, lFiltSize,
        fpNullPtr, (iHighPass) ? true : false)) return 0;
    return 1;
}


int dsp_int_fft_init (dsp_intfft_t dspintfftInst, long lIntFact,
    long lFiltSize, int iHighPass)
{
    double *dpNullPtr = NULL;
    
    if (!((clFFTInterpolator *) dspintfftInst)->Initialize(lIntFact, lFiltSize,
        dpNullPtr, (iHighPass) ? true : false)) return 0;
    return 1;
}


void dsp_int_fft_uninit (dsp_intfft_t dspintfftInst)
{
    ((clFFTInterpolator *) dspintfftInst)->Uninitialize();
}


void dsp_int_fft_putf (dsp_intfft_t dspintfftInst, const float *fpSrcData,
    long lSrcCount)
{
    ((clFFTInterpolator *) dspintfftInst)->Put(fpSrcData, lSrcCount);
}


void dsp_int_fft_put (dsp_intfft_t dspintfftInst, const double *dpSrcData,
    long lSrcCount)
{
    ((clFFTInterpolator *) dspintfftInst)->Put(dpSrcData, lSrcCount);
}


int dsp_int_fft_getf (dsp_intfft_t dspintfftInst, float *fpDestData,
    long lDestCount)
{
    if (!((clFFTInterpolator *) dspintfftInst)->Get(fpDestData, lDestCount))
        return 0;
    return 1;
}


int dsp_int_fft_get (dsp_intfft_t dspintfftInst, double *dpDestData,
    long lDestCount)
{
    if (!((clFFTInterpolator *) dspintfftInst)->Get(dpDestData, lDestCount))
        return 0;
    return 1;
}