cdspop.cc

各种工程计算的库函数

/* clFIRInterpolator */


dsp_intfir_t dsp_int_fir_new ()
{
    return ((dsp_intfir_t) new clFIRInterpolator);
}


void dsp_int_fir_delete (dsp_intfir_t dspintfirInst)
{
    delete ((clFIRInterpolator *) dspintfirInst);
}


int dsp_int_fir_initf (dsp_intfir_t dspintfirInst, long lIntFact, int iHighPass)
{
    float *fpNullPtr = NULL;
    
    if (!((clFIRInterpolator *) dspintfirInst)->Initialize(lIntFact, fpNullPtr,
        (iHighPass) ? true : false)) return 0;
    return 1;
}


int dsp_int_fir_init (dsp_intfir_t dspintfirInst, long lIntFact, int iHighPass)
{
    double *dpNullPtr = NULL;
    
    if (!((clFIRInterpolator *) dspintfirInst)->Initialize(lIntFact, dpNullPtr,
        (iHighPass) ? true : false)) return 0;
    return 1;
}


void dsp_int_fir_uninit (dsp_intfir_t dspintfirInst)
{
    ((clFIRInterpolator *) dspintfirInst)->Uninitialize();
}


void dsp_int_fir_putf (dsp_intfir_t dspintfirInst, const float *fpSrcData,
    long lSrcCount)
{
    ((clFIRInterpolator *) dspintfirInst)->Put(fpSrcData, lSrcCount);
}


void dsp_int_fir_put (dsp_intfir_t dspintfirInst, const double *dpSrcData,
    long lSrcCount)
{
    ((clFIRInterpolator *) dspintfirInst)->Put(dpSrcData, lSrcCount);
}


int dsp_int_fir_getf (dsp_intfir_t dspintfirInst, float *fpDestData,
    long lDestCount)
{
    if (!((clFIRInterpolator *) dspintfirInst)->Get(fpDestData, lDestCount))
        return 0;
    return 1;
}


int dsp_int_fir_get (dsp_intfir_t dspintfirInst, double *dpDestData,
    long lDestCount)
{
    if (!((clFIRInterpolator *) dspintfirInst)->Get(dpDestData, lDestCount))
        return 0;
    return 1;
}


/* clIIRInterpolator */


dsp_intiir_t dsp_int_iir_new ()
{
    return ((dsp_intiir_t) new clIIRInterpolator);
}


void dsp_int_iir_delete (dsp_intiir_t dspintiirInst)
{
    delete ((clIIRInterpolator *) dspintiirInst);
}


int dsp_int_iir_initf (dsp_intiir_t dspintiirInst, long lIntFact, int iHighPass)
{
    float *fpNullPtr = NULL;
    
    if (!((clIIRInterpolator *) dspintiirInst)->Initialize(lIntFact, fpNullPtr,
        (iHighPass) ? true : false)) return 0;
    return 1;
}


int dsp_int_iir_init (dsp_intiir_t dspintiirInst, long lIntFact, int iHighPass)
{
    double *dpNullPtr = NULL;
    
    if (!((clIIRInterpolator *) dspintiirInst)->Initialize(lIntFact, dpNullPtr,
        (iHighPass) ? true : false)) return 0;
    return 1;
}


void dsp_int_iir_uninit (dsp_intiir_t dspintiirInst)
{
    ((clIIRInterpolator *) dspintiirInst)->Uninitialize();
}


void dsp_int_iir_putf (dsp_intiir_t dspintiirInst, const float *fpSrcData,
    long lSrcCount)
{
    ((clIIRInterpolator *) dspintiirInst)->Put(fpSrcData, lSrcCount);
}


void dsp_int_iir_put (dsp_intiir_t dspintiirInst, const double *dpSrcData,
    long lSrcCount)
{
    ((clIIRInterpolator *) dspintiirInst)->Put(dpSrcData, lSrcCount);
}


int dsp_int_iir_getf (dsp_intiir_t dspintiirInst, float *fpDestData,
    long lDestCount)
{
    if (!((clIIRInterpolator *) dspintiirInst)->Get(fpDestData, lDestCount))
        return 0;
    return 1;
}


int dsp_int_iir_get (dsp_intiir_t dspintiirInst, double *dpDestData,
    long lDestCount)
{
    if (!((clIIRInterpolator *) dspintiirInst)->Get(dpDestData, lDestCount))
        return 0;
    return 1;
}


/* clRecInterpolator */


dsp_intrec_t dsp_int_rec_new ()
{
    return ((dsp_intrec_t) new clRecInterpolator);
}


void dsp_int_rec_delete (dsp_intrec_t dspintrecInst)
{
    delete ((clRecInterpolator *) dspintrecInst);
}


int dsp_int_rec_initf (dsp_intrec_t dspintrecInst, long lIntFact,
    long lFiltSize, float fBandCenter, int iFilterType)
{
    float *fpNullPtr = NULL;

    if (!((clRecInterpolator *) dspintrecInst)->Initialize(lIntFact,
        lFiltSize, fpNullPtr, fBandCenter, iFilterType))
        return 0;
    return 1;
}


int dsp_int_rec_init (dsp_intrec_t dspintrecInst, long lIntFact,
    long lFiltSize, double dBandCenter, int iFilterType)
{
    double *dpNullPtr = NULL;
    
    if (!((clRecInterpolator *) dspintrecInst)->Initialize(lIntFact,
        lFiltSize, dpNullPtr, dBandCenter, iFilterType))
        return 0;
    return 1;
}


void dsp_int_rec_uninit (dsp_intrec_t dspintrecInst)
{
    ((clRecInterpolator *) dspintrecInst)->Uninitialize();
}


void dsp_int_rec_putf (dsp_intrec_t dspintrecInst, const float *fpSrcData,
    long lSrcCount)
{
    ((clRecInterpolator *) dspintrecInst)->Put(fpSrcData, lSrcCount);
}


void dsp_int_rec_put (dsp_intrec_t dspintrecInst, const double *dpSrcData,
    long lSrcCount)
{
    ((clRecInterpolator *) dspintrecInst)->Put(dpSrcData, lSrcCount);
}


int dsp_int_rec_getf (dsp_intrec_t dspintrecInst, float *fpDestData,
    long lDestCount)
{
    if (!((clRecInterpolator *) dspintrecInst)->Get(fpDestData, lDestCount))
        return 0;
    return 1;
}


int dsp_int_rec_get (dsp_intrec_t dspintrecInst, double *dpDestData,
    long lDestCount)
{
    if (!((clRecInterpolator *) dspintrecInst)->Get(dpDestData, lDestCount))
        return 0;
    return 1;
}


/* clFilter */


dsp_filter_t dsp_filter_new ()
{
    return ((dsp_filter_t) new clFilter);
}


void dsp_filter_delete (dsp_filter_t dspfilterInst)
{
    delete ((clFilter *) dspfilterInst);
}


int dsp_filter_initf (dsp_filter_t dspfilterInst, long lWindowSize)
{
    float *fpNullPtr = NULL;

    if (!((clFilter *) dspfilterInst)->Initialize(lWindowSize, fpNullPtr))
        return 0;
    return 1;
}


int dsp_filter_init (dsp_filter_t dspfilterInst, long lWindowSize)
{
    double *dpNullPtr = NULL;
    
    if (!((clFilter *) dspfilterInst)->Initialize(lWindowSize, dpNullPtr))
        return 0;
    return 1;
}


int dsp_filter_init2f (dsp_filter_t dspfilterInst, long lWindowSize,
    const float *fpFiltCoeffs, float fOverlap, float fBeta)
{
    if (!((clFilter *) dspfilterInst)->Initialize(lWindowSize, fpFiltCoeffs,
        fOverlap, fBeta)) return 0;
    return 1;
}


int dsp_filter_init2 (dsp_filter_t dspfilterInst, long lWindowSize,
    const double *dpFiltCoeffs, double dOverlap, double dBeta)
{
    if (!((clFilter *) dspfilterInst)->Initialize(lWindowSize, dpFiltCoeffs,
        dOverlap, dBeta)) return 0;
    return 1;
}


int dsp_filter_init_lpf (dsp_filter_t dspfilterInst, float fPassBand,
    float fStopBand, float fRippleRatio, float fOverlap)
{
    if (!((clFilter *) dspfilterInst)->InitializeLP(fPassBand, fStopBand,
        fRippleRatio, fOverlap)) return 0;
    return 1;
}


int dsp_filter_init_lp (dsp_filter_t dspfilterInst, double dPassBand,
    double dStopBand, double dRippleRatio, double dOverlap)
{
    if (!((clFilter *) dspfilterInst)->InitializeLP(dPassBand, dStopBand,
        dRippleRatio, dOverlap)) return 0;
    return 1;
}


int dsp_filter_init_hpf (dsp_filter_t dspfilterInst, float fPassBand,
    float fStopBand, float fRippleRatio, float fOverlap)
{
    if (!((clFilter *) dspfilterInst)->InitializeHP(fPassBand, fStopBand,
        fRippleRatio, fOverlap)) return 0;
    return 1;
}


int dsp_filter_init_hp (dsp_filter_t dspfilterInst, double dPassBand,
    double dStopBand, double dRippleRatio, double dOverlap)
{
    if (!((clFilter *) dspfilterInst)->InitializeHP(dPassBand, dStopBand,
        dRippleRatio, dOverlap)) return 0;
    return 1;
}


void dsp_filter_set_coeffsf (dsp_filter_t dspfilterInst, 
    const float *fpFiltCoeffs)
{
    ((clFilter *) dspfilterInst)->SetCoeffs(fpFiltCoeffs);
}


void dsp_filter_set_coeffs (dsp_filter_t dspfilterInst,
    const double *dpFiltCoeffs)
{
    ((clFilter *) dspfilterInst)->SetCoeffs(dpFiltCoeffs);
}


void dsp_filter_set_ccoeffsf (dsp_filter_t dspfilterInst,
    const stpSCplx spFiltCoeffs, int iSmooth)
{
    ((clFilter *) dspfilterInst)->SetCoeffs(spFiltCoeffs,
        (iSmooth) ? true : false);
}


void dsp_filter_set_ccoeffs (dsp_filter_t dspfilterInst,
    const stpDCplx spFiltCoeffs, int iSmooth)
{
    ((clFilter *) dspfilterInst)->SetCoeffs(spFiltCoeffs,
        (iSmooth) ? true : false);
}


void dsp_filter_get_coeffsf (dsp_filter_t dspfilterInst,
    float *fpFiltCoeffs)
{
    ((clFilter *) dspfilterInst)->GetCoeffs(fpFiltCoeffs);
}


void dsp_filter_get_coeffs (dsp_filter_t dspfilterInst,
    double *dpFiltCoeffs)
{
    ((clFilter *) dspfilterInst)->GetCoeffs(dpFiltCoeffs);
}


void dsp_filter_get_ccoeffsf (dsp_filter_t dspfilterInst,
    stpSCplx spFiltCoeffs)
{
    ((clFilter *) dspfilterInst)->GetCoeffs(spFiltCoeffs);
}


void dsp_filter_get_ccoeffs (dsp_filter_t dspfilterInst,
    stpDCplx spFiltCoeffs)
{
    ((clFilter *) dspfilterInst)->GetCoeffs(spFiltCoeffs);
}


void dsp_filter_putf (dsp_filter_t dspfilterInst, const float *fpSrcData,
    long lSrcCount)
{
    ((clFilter *) dspfilterInst)->Put(fpSrcData, lSrcCount);
}


void dsp_filter_put (dsp_filter_t dspfilterInst, const double *dpSrcData,
    long lSrcCount)
{
    ((clFilter *) dspfilterInst)->Put(dpSrcData, lSrcCount);
}


void dsp_filter_put2f (dsp_filter_t dspfilterInst, const float *fpSrcData,
    long lSrcCount, const stpSCplx spCoeffs)
{
    ((clFilter *) dspfilterInst)->Put(fpSrcData, lSrcCount, spCoeffs);
}


void dsp_filter_put2 (dsp_filter_t dspfilterInst, const double *dpSrcData,
    long lSrcCount, const stpDCplx spCoeffs)
{
    ((clFilter *) dspfilterInst)->Put(dpSrcData, lSrcCount, spCoeffs);
}


void dsp_filter_getf (dsp_filter_t dspfilterInst, float *fpDestData,
    long lDestCount)
{
    ((clFilter *) dspfilterInst)->Get(fpDestData, lDestCount);
}


void dsp_filter_get (dsp_filter_t dspfilterInst, double *dpDestData,
    long lDestCount)
{
    ((clFilter *) dspfilterInst)->Get(dpDestData, lDestCount);
}


void dsp_filter_design_lpf (dsp_filter_t dspfilterInst, float *fpCorner,
    int iDCBlock)
{
    ((clFilter *) dspfilterInst)->DesignLP(fpCorner,
        (iDCBlock) ? true : false);
}


void dsp_filter_design_lp (dsp_filter_t dspfilterInst, double *dpCorner,
    int iDCBlock)
{
    ((clFilter *) dspfilterInst)->DesignLP(dpCorner,
        (iDCBlock) ? true : false);
}


void dsp_filter_design_lp2f (dsp_filter_t dspfilterInst, float *fpCorner,
    float fSampleRate, int iDCBlock)
{
    ((clFilter *) dspfilterInst)->DesignLP(fpCorner, fSampleRate,
        (iDCBlock) ? true : false);
}


void dsp_filter_design_lp2 (dsp_filter_t dspfilterInst, double *dpCorner,
    double dSampleRate, int iDCBlock)
{
    ((clFilter *) dspfilterInst)->DesignLP(dpCorner, dSampleRate,
        (iDCBlock) ? true : false);
}


void dsp_filter_design_hpf (dsp_filter_t dspfilterInst, float *fpCorner)
{
    ((clFilter *) dspfilterInst)->DesignHP(fpCorner);
}


void dsp_filter_design_hp (dsp_filter_t dspfilterInst, double *dpCorner)
{
    ((clFilter *) dspfilterInst)->DesignHP(dpCorner);
}


void dsp_filter_design_hp2f (dsp_filter_t dspfilterInst, float *fpCorner,
    float fSampleRate)
{
    ((clFilter *) dspfilterInst)->DesignHP(fpCorner, fSampleRate);
}


void dsp_filter_design_hp2 (dsp_filter_t dspfilterInst, double *dpCorner,
    double dSampleRate)
{
    ((clFilter *) dspfilterInst)->DesignHP(dpCorner, dSampleRate);
}


void dsp_filter_design_bpf (dsp_filter_t dspfilterInst, float *fpLowCorner,
    float *fpHighCorner)
{
    ((clFilter *) dspfilterInst)->DesignBP(fpLowCorner, fpHighCorner);
}


void dsp_filter_design_bp (dsp_filter_t dspfilterInst, double *dpLowCorner,
    double *dpHighCorner)
{
    ((clFilter *) dspfilterInst)->DesignBP(dpLowCorner, dpHighCorner);
}


void dsp_filter_design_bp2f (dsp_filter_t dspfilterInst, float *fpLowCorner,
    float *fpHighCorner, float fSampleRate)
{
    ((clFilter *) dspfilterInst)->DesignBP(fpLowCorner, fpHighCorner,
        fSampleRate);
}


void dsp_filter_design_bp2 (dsp_filter_t dspfilterInst, double *dpLowCorner,
    double *dpHighCorner, double dSampleRate)
{
    ((clFilter *) dspfilterInst)->DesignBP(dpLowCorner, dpHighCorner,
        dSampleRate);
}


void dsp_filter_design_brf (dsp_filter_t dspfilterInst, float *fpLowCorner,
    float *fpHighCorner)
{
    ((clFilter *) dspfilterInst)->DesignBR(fpLowCorner, fpHighCorner);
}


void dsp_filter_design_br (dsp_filter_t dspfilterInst, double *dpLowCorner,
    double *dpHighCorner)
{
    ((clFilter *) dspfilterInst)->DesignBR(dpLowCorner, dpHighCorner);
}


void dsp_filter_design_br2f (dsp_filter_t dspfilterInst, float *fpLowCorner,
    float *fpHighCorner, float fSampleRate)
{
    ((clFilter *) dspfilterInst)->DesignBR(fpLowCorner, fpHighCorner,
        fSampleRate);
}


void dsp_filter_design_br2 (dsp_filter_t dspfilterInst, double *dpLowCorner,
    double *dpHighCorner, double dSampleRate)
{
    ((clFilter *) dspfilterInst)->DesignBR(dpLowCorner, dpHighCorner,
        dSampleRate);
}


/* clFlipBand */


dsp_flip_t dsp_flip_new ()
{
    return ((dsp_flip_t) new clFlipBand);
}


void dsp_flip_delete (dsp_flip_t dspflipInst)
{
    delete ((clFlipBand *) dspflipInst);
}


void dsp_flip_initf (dsp_flip_t dspflipInst, long lSize)
{
    float *fpNullPtr = NULL;

    ((clFlipBand *) dspflipInst)->Initialize(lSize, fpNullPtr);
}


void dsp_flip_init (dsp_flip_t dspflipInst, long lSize)
{
    double *dpNullPtr = NULL;
    
    ((clFlipBand *) dspflipInst)->Initialize(lSize, dpNullPtr);
}


void dsp_flip_uninit (dsp_flip_t dspflipInst)
{
    ((clFlipBand *) dspflipInst)->Uninitialize();
}


void dsp_flip_putf (dsp_flip_t dspflipInst, const float *fpSrc, long lCount)
{
    ((clFlipBand *) dspflipInst)->Put(fpSrc, lCount);
}


void dsp_flip_put (dsp_flip_t dspflipInst, const double *dpSrc, long lCount)
{
    ((clFlipBand *) dspflipInst)->Put(dpSrc, lCount);
}


void dsp_flip_getf (dsp_flip_t dspflipInst, float *fpDest, long lCount)
{
    ((clFlipBand *) dspflipInst)->Get(fpDest, lCount);
}


void dsp_flip_get (dsp_flip_t dspflipInst, double *dpDest, long lCount)
{
    ((clFlipBand *) dspflipInst)->Get(dpDest, lCount);
}


void dsp_flip_clear (dsp_flip_t dspflipInst)
{
    ((clFlipBand *) dspflipInst)->Clear();
}


/* clReBuffer */


dsp_rebuf_t dsp_rebuf_new ()
{
    return ((dsp_rebuf_t) new clReBuffer);
}


void dsp_rebuf_delete (dsp_rebuf_t dsprebufInst)
{
    delete ((clReBuffer *) dsprebufInst);
}


void dsp_rebuf_putf (dsp_rebuf_t dsprebufInst, const float *fpSrcData,
    long lSrcCount)
{
    ((clReBuffer *) dsprebufInst)->Put(fpSrcData, lSrcCount);
}


void d