filter.cc

各种工程计算的库函数

    }
    ReadyFilterD();
}


void clFilter::SetCoeffs (const stpSCplx spSFiltCoeffs, bool bSmooth)
{
    stpSCplx spSCCoeffs = CCoeffs;

    Copy(spSCCoeffs, spSFiltCoeffs, lSpectPoints);
    if (bSmooth) ReadyFilterS();
}


void clFilter::SetCoeffs (const stpDCplx spDFiltCoeffs, bool bSmooth)
{
    stpDCplx spDCCoeffs = CCoeffs;

    Copy(spDCCoeffs, spDFiltCoeffs, lSpectPoints);
    if (bSmooth) ReadyFilterD();
}


void clFilter::GetCoeffs (float *fpFiltCoeffs)
{
    long lCoeffCntr;
    stpSCplx spSCCoeffs = CCoeffs;

    for (lCoeffCntr = 0; lCoeffCntr < lSpectPoints; lCoeffCntr++)
    {
        fpFiltCoeffs[lCoeffCntr] = spSCCoeffs[lCoeffCntr].R;
    }
}


void clFilter::GetCoeffs (double *dpFiltCoeffs)
{
    long lCoeffCntr;
    stpDCplx spDCCoeffs = CCoeffs;

    for (lCoeffCntr = 0; lCoeffCntr < lSpectPoints; lCoeffCntr++)
    {
        dpFiltCoeffs[lCoeffCntr] = spDCCoeffs[lCoeffCntr].R;
    }
}


void clFilter::GetCoeffs (stpSCplx spSFiltCoeffs)
{
    stpSCplx spSCCoeffs = CCoeffs;

    Copy(spSFiltCoeffs, spSCCoeffs, lSpectPoints);
}


void clFilter::GetCoeffs (stpDCplx spDFiltCoeffs)
{
    stpDCplx spDCCoeffs = CCoeffs;

    Copy(spDFiltCoeffs, spDCCoeffs, lSpectPoints);
}


long clFilter::GetDelay ()
{
    return (lOldSize / 2);
}


void clFilter::Put (const float *fpSrcData, long lSrcCount)
{
    float *fpPrev = Prev;
    float *fpProc = Proc;
    stpSCplx spSCCoeffs = CCoeffs;
    stpSCplx spSCProc = CProc;

    InBuf.Put(fpSrcData, lSrcCount);
    while (InBuf.Get(&fpProc[lOldSize], lNewSize))
    {
        Copy(fpProc, fpPrev, lOldSize);
        Copy(fpPrev, &fpProc[lNewSize], lOldSize);

        FFTi(spSCProc, fpProc);
        Mul(spSCProc, spSCCoeffs, lSpectPoints);
        IFFTo(fpProc, spSCProc);

        OutBuf.Put(&fpProc[lOldSize >> 1], lNewSize);
    }
}


void clFilter::Put (const double *dpSrcData, long lSrcCount)
{
    double *dpPrev = Prev;
    double *dpProc = Proc;
    stpDCplx spDCCoeffs = CCoeffs;
    stpDCplx spDCProc = CProc;

    InBuf.Put(dpSrcData, lSrcCount);
    while (InBuf.Get(&dpProc[lOldSize], lNewSize))
    {
        Copy(dpProc, dpPrev, lOldSize);
        Copy(dpPrev, &dpProc[lNewSize], lOldSize);

        FFTi(spDCProc, dpProc);
        Mul(spDCProc, spDCCoeffs, lSpectPoints);
        IFFTo(dpProc, spDCProc);

        OutBuf.Put(&dpProc[lOldSize >> 1], lNewSize);
    }
}


void clFilter::Put (const float *fpSrcData, long lSrcCount, 
    const stpSCplx spSCCoeffs)
{
    float *fpPrev = Prev;
    float *fpProc = Proc;
    stpSCplx spSCProc = CProc;

    InBuf.Put(fpSrcData, lSrcCount);
    while (InBuf.Get(&fpProc[lOldSize], lNewSize))
    {
        Copy(fpProc, fpPrev, lOldSize);
        Copy(fpPrev, &fpProc[lNewSize], lOldSize);

        FFTi(spSCProc, fpProc);
        Mul(spSCProc, spSCCoeffs, lSpectPoints);
        IFFTo(fpProc, spSCProc);

        OutBuf.Put(&fpProc[lOldSize >> 1], lNewSize);
    }
}


void clFilter::Put (const double *dpSrcData, long lSrcCount, 
    const stpDCplx spDCCoeffs)
{
    double *dpPrev = Prev;
    double *dpProc = Proc;
    stpDCplx spDCProc = CProc;

    InBuf.Put(dpSrcData, lSrcCount);
    while (InBuf.Get(&dpProc[lOldSize], lNewSize))
    {
        Copy(dpProc, dpPrev, lOldSize);
        Copy(dpPrev, &dpProc[lNewSize], lOldSize);

        FFTi(spDCProc, dpProc);
        Mul(spDCProc, spDCCoeffs, lSpectPoints);
        IFFTo(dpProc, spDCProc);

        OutBuf.Put(&dpProc[lOldSize >> 1], lNewSize);
    }
}


bool clFilter::Get (float *fpDestData, long lDestCount)
{
    return OutBuf.Get(fpDestData, lDestCount);
}


bool clFilter::Get (double *dpDestData, long lDestCount)
{
    return OutBuf.Get(dpDestData, lDestCount);
}


void clFilter::DesignLP (float *fpCorner, bool bDCBlock)
{
    long lPassCount;
    float *fpCoeffs;
    clDSPAlloc Coeffs(lSpectPoints * sizeof(float));

    fpCoeffs = Coeffs;
    lPassCount = (long) floor((float) lSpectPoints * (*fpCorner));
    *fpCorner = (float) lPassCount / (float) lSpectPoints;
    Zero(fpCoeffs, lSpectPoints);
    Set(fpCoeffs, 1.0f, lPassCount);
    if (bDCBlock) fpCoeffs[0] = 0.0f;
    SetCoeffs(fpCoeffs);
}


void clFilter::DesignLP (double *dpCorner, bool bDCBlock)
{
    long lPassCount;
    double *dpCoeffs;
    clDSPAlloc Coeffs(lSpectPoints * sizeof(double));

    dpCoeffs = Coeffs;
    lPassCount = (long) floor((double) lSpectPoints * (*dpCorner));
    *dpCorner = (double) lPassCount / (double) lSpectPoints;
    Zero(dpCoeffs, lSpectPoints);
    Set(dpCoeffs, 1.0, lPassCount);
    if (bDCBlock) dpCoeffs[0] = 0.0;
    SetCoeffs(dpCoeffs);
}


void clFilter::DesignLP (float *fpCorner, float fSampleRate, bool bDCBlock)
{
    float fNyquist;
    float fNormCorner;

    fNyquist = fSampleRate / 2.0f;
    fNormCorner = (*fpCorner) / fNyquist;
    DesignLP(&fNormCorner, bDCBlock);
    *fpCorner = fNormCorner * fNyquist;
}


void clFilter::DesignLP (double *dpCorner, double dSampleRate, bool bDCBlock)
{
    double dNyquist;
    double dNormCorner;

    dNyquist = dSampleRate / 2.0;
    dNormCorner = (*dpCorner) / dNyquist;
    DesignLP(&dNormCorner, bDCBlock);
    *dpCorner = dNormCorner * dNyquist;
}


void clFilter::DesignHP (float *fpCorner)
{
    long lStopCount;
    float *fpCoeffs;
    clDSPAlloc Coeffs(lSpectPoints * sizeof(float));

    fpCoeffs = Coeffs;
    lStopCount = (long) ceil((float) lSpectPoints * (*fpCorner));
    *fpCorner = (float) lStopCount / (float) lSpectPoints;
    Set(fpCoeffs, 1.0f, lSpectPoints);
    Zero(fpCoeffs, lStopCount);
    SetCoeffs(fpCoeffs);
}


void clFilter::DesignHP (double *dpCorner)
{
    long lStopCount;
    double *dpCoeffs;
    clDSPAlloc Coeffs(lSpectPoints * sizeof(double));

    dpCoeffs = Coeffs;
    lStopCount = (long) ceil((double) lSpectPoints * (*dpCorner));
    *dpCorner = (double) lStopCount / (double) lSpectPoints;
    Set(dpCoeffs, 1.0, lSpectPoints);
    Zero(dpCoeffs, lStopCount);
    SetCoeffs(dpCoeffs);
}


void clFilter::DesignHP (float *fpCorner, float fSampleRate)
{
    float fNyquist;
    float fNormCorner;

    fNyquist = fSampleRate / 2.0f;
    fNormCorner = (*fpCorner) / fNyquist;
    DesignHP(&fNormCorner);
    *fpCorner = fNormCorner * fNyquist;
}


void clFilter::DesignHP (double *dpCorner, double dSampleRate)
{
    double dNyquist;
    double dNormCorner;

    dNyquist = dSampleRate / 2.0;
    dNormCorner = (*dpCorner) / dNyquist;
    DesignHP(&dNormCorner);
    *dpCorner = dNormCorner * dNyquist;
}


void clFilter::DesignBP (float *fpLowCorner, float *fpHighCorner)
{
    long lLowIdx;
    long lHighIdx;
    float *fpCoeffs;
    clDSPAlloc Coeffs(lSpectPoints * sizeof(float));

    fpCoeffs = Coeffs;
    lLowIdx = (long) ceil((float) lSpectPoints * (*fpLowCorner));
    lHighIdx = (long) floor((float) lSpectPoints * (*fpHighCorner));
    *fpLowCorner = (float) lLowIdx / (float) lSpectPoints;
    *fpHighCorner = (float) lHighIdx / (float) lSpectPoints;
    Zero(fpCoeffs, lSpectPoints);
    Set(&fpCoeffs[lLowIdx], 1.0f, lHighIdx - lLowIdx);
    SetCoeffs(fpCoeffs);
}


void clFilter::DesignBP (double *dpLowCorner, double *dpHighCorner)
{
    long lLowIdx;
    long lHighIdx;
    double *dpCoeffs;
    clDSPAlloc Coeffs(lSpectPoints * sizeof(double));

    dpCoeffs = Coeffs;
    lLowIdx = (long) ceil((double) lSpectPoints * (*dpLowCorner));
    lHighIdx = (long) floor((double) lSpectPoints * (*dpHighCorner));
    *dpLowCorner = (double) lLowIdx / (double) lSpectPoints;
    *dpHighCorner = (double) lHighIdx / (double) lSpectPoints;
    Zero(dpCoeffs, lSpectPoints);
    Set(&dpCoeffs[lLowIdx], 1.0, lHighIdx - lLowIdx);
    SetCoeffs(dpCoeffs);
}


void clFilter::DesignBP (float *fpLowCorner, float *fpHighCorner, 
    float fSampleRate)
{
    float fNyquist;
    float fNormLowCorner;
    float fNormHighCorner;

    fNyquist = fSampleRate / 2.0f;
    fNormLowCorner = (*fpLowCorner) / fNyquist;
    fNormHighCorner = (*fpHighCorner) / fNyquist;
    DesignBP(&fNormLowCorner, &fNormHighCorner);
    *fpLowCorner = fNormLowCorner * fNyquist;
    *fpHighCorner = fNormHighCorner * fNyquist;
}


void clFilter::DesignBP (double *dpLowCorner, double *dpHighCorner,
    double dSampleRate)
{
    double dNyquist;
    double dNormLowCorner;
    double dNormHighCorner;

    dNyquist = dSampleRate / 2.0;
    dNormLowCorner = (*dpLowCorner) / dNyquist;
    dNormHighCorner = (*dpHighCorner) / dNyquist;
    DesignBP(&dNormLowCorner, &dNormHighCorner);
    *dpLowCorner = dNormLowCorner * dNyquist;
    *dpHighCorner = dNormHighCorner * dNyquist;
}


void clFilter::DesignBR (float *fpLowCorner, float *fpHighCorner)
{
    long lLowIdx;
    long lHighIdx;
    float *fpCoeffs;
    clDSPAlloc Coeffs(lSpectPoints * sizeof(float));

    fpCoeffs = Coeffs;
    lLowIdx = (long) ceil((float) lSpectPoints * (*fpLowCorner));
    lHighIdx = (long) floor((float) lSpectPoints * (*fpHighCorner));
    *fpLowCorner = (float) lLowIdx / (float) lSpectPoints;
    *fpHighCorner = (float) lHighIdx / (float) lSpectPoints;
    Set(fpCoeffs, 1.0f, lSpectPoints);
    Zero(&fpCoeffs[lLowIdx], lHighIdx - lLowIdx);
    SetCoeffs(fpCoeffs);
}


void clFilter::DesignBR (double *dpLowCorner, double *dpHighCorner)
{
    long lLowIdx;
    long lHighIdx;
    double *dpCoeffs;
    clDSPAlloc Coeffs(lSpectPoints * sizeof(double));

    dpCoeffs = Coeffs;
    lLowIdx = (long) ceil((double) lSpectPoints * (*dpLowCorner));
    lHighIdx = (long) floor((double) lSpectPoints * (*dpHighCorner));
    *dpLowCorner = (double) lLowIdx / (double) lSpectPoints;
    *dpHighCorner = (double) lHighIdx / (double) lSpectPoints;
    Set(dpCoeffs, 1.0, lSpectPoints);
    Zero(&dpCoeffs[lLowIdx], lHighIdx - lLowIdx);
    SetCoeffs(dpCoeffs);
}


void clFilter::DesignBR (float *fpLowCorner, float *fpHighCorner,
    float fSampleRate)
{
    float fNyquist;
    float fNormLowCorner;
    float fNormHighCorner;

    fNyquist = fSampleRate / 2.0f;
    fNormLowCorner = (*fpLowCorner) / fNyquist;
    fNormHighCorner = (*fpHighCorner) / fNyquist;
    DesignBR(&fNormLowCorner, &fNormHighCorner);
    *fpLowCorner = fNormLowCorner * fNyquist;
    *fpHighCorner = fNormHighCorner * fNyquist;
}


void clFilter::DesignBR (double *dpLowCorner, double *dpHighCorner,
    double dSampleRate)
{
    double dNyquist;
    double dNormLowCorner;
    double dNormHighCorner;

    dNyquist = dSampleRate / 2.0;
    dNormLowCorner = (*dpLowCorner) / dNyquist;
    dNormHighCorner = (*dpHighCorner) / dNyquist;
    DesignBR(&dNormLowCorner, &dNormHighCorner);
    *dpLowCorner = dNormLowCorner * dNyquist;
    *dpHighCorner = dNormHighCorner * dNyquist;
}