FEAPIExamplePluginZeroCrossings/zplFFTGen.cpp

Go to the documentation of this file.

//     /*! \file zplFFTGen.cpp: \brief interface of the CzplFFTGen class. */
//
//        Copyright (c) 2004-2007  
//        zplane.development
//        Flohrer Lerch Schwerdtfeger GbR
//        All rights reserved.
//
//        Redistribution and use in source and binary forms, with or without 
//        modification, are permitted provided that the following conditions 
//        are met:
//
//        *   Redistributions of source code must retain the above copyright 
//            notice, this list of conditions and the following disclaimer. 
//        *   Redistributions in binary form must reproduce the above 
//            copyright notice, this list of conditions and the following 
//            disclaimer in the documentation and/or other materials 
//            provided with the distribution. 
//        *   Neither the name of the FEAPI development team nor the names 
//            of its contributors may be used to endorse or promote products 
//            derived from this software without specific prior written 
//            permission. 
//
//        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
//        "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
//        LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
//        FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
//        COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
//        INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
//        BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
//        LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
//        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
//        LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
//        ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
//        POSSIBILITY OF SUCH DAMAGE.
//

// standard headers
#include <string.h>
#include <math.h>

// project headers
#include "zplVecLib.h"
#include "fft.h"

#if !defined(_2PI)
#define _2PI                    (float)(6.283185307179586476925286766559)    
#endif

class CzplfFFTGen : public CzplfFFT_If
{
public:

    
    CzplfFFTGen (int iBlockLength, int iZeroPadFactor, _Fft_Windows_ eWindowType);
    virtual ~CzplfFFTGen ();


    void           zplfFFT         (zCOMPLEX *pfDest, float *pfSrc);

    void           zplfIFFT        (float *pfDest, zCOMPLEX *pfSrc);

    int      m_eLastError;

protected:

    int      BuildFFTTables ();
    void       FreeFFTTables ();

    float    *m_pfSinTable,
                *m_pfCosTable;

};



CzplfFFTGen::CzplfFFTGen (int iBlockLength, int iZeroPadFactor, _Fft_Windows_ eWindowType)
{
    m_eLastError    = 0;
    m_iBlockLength  = iBlockLength;
    m_iFFTLength    = m_iBlockLength * iZeroPadFactor;

    m_pfWindow      = 0;
    m_pfWindow      = zplfMalloc (m_iBlockLength);

    if (!m_pfWindow)
        m_eLastError    = -1;
    else
        this->CalculateWindow (eWindowType);

    m_pfSinTable    = 0;
    m_pfCosTable    = 0;

    m_eLastError   |= this->BuildFFTTables ();
}


CzplfFFTGen::~CzplfFFTGen ()
{
    if (m_pfWindow)
        zplfFree (m_pfWindow);

    this->FreeFFTTables ();
}
    

void CzplfFFTGen::zplfFFT         (zCOMPLEX *pfDest, float *pfSrc)
{
    ZASSERT ((pfDest == 0) || (pfSrc == 0));
    ZASSERT ((m_pfSinTable == 0) || (m_pfCosTable == 0) || (m_pfWindow == 0));
    ZASSERT (m_eLastError != 0);

    // copy buffer
    if (pfDest != pfSrc)
        memcpy (pfDest, pfSrc, sizeof (float) * m_iBlockLength);

    // zeropad
    if (m_iFFTLength-m_iBlockLength > 0)
        zplfSetZero (&pfDest[m_iBlockLength], (m_iFFTLength - m_iBlockLength));

    // window
    zplfRealMul_I (pfDest, m_pfWindow, m_iBlockLength);

    // calc FFT
    zRealFFTSplitGeneric (pfDest, m_iFFTLength, m_pfSinTable, m_pfCosTable);

    return;
}

void CzplfFFTGen::zplfIFFT         (float *pfDest, zCOMPLEX *pfSrc)
{
    ZASSERT ((pfDest == 0) || (pfSrc == 0));
    ZASSERT ((m_pfSinTable == 0) || (m_pfCosTable == 0) || (m_pfWindow == 0));
    ZASSERT (m_eLastError != 0);

    // calc FFT
    zRealIFFTSplitGeneric (pfSrc, m_iFFTLength, m_pfSinTable, m_pfCosTable);

    // copy buffer
    memcpy (pfDest, pfSrc, sizeof (float) * m_iBlockLength);

    return;
}

int CzplfFFTGen::BuildFFTTables ()
{
    int    iQuarterBlockSize   = (m_iFFTLength>>3)-1;
    float  fPiBlock            = _2PI / m_iFFTLength,
            f3PiBlock           = 3.0F * fPiBlock;

    m_pfSinTable        = zplfMalloc (1+(iQuarterBlockSize<<1));
    if (m_pfSinTable == 0)
        return -1;
    m_pfCosTable        = zplfMalloc (1+(iQuarterBlockSize<<1));
    if (m_pfCosTable == 0)
        return -1;

    for (int i = 0; i < iQuarterBlockSize; i++)
    {
        m_pfSinTable[i]                     = sinf ((i+1) * fPiBlock);
        m_pfCosTable[i]                     = cosf ((i+1) * fPiBlock);

        m_pfSinTable[i+iQuarterBlockSize]   = sinf ((i+1) * f3PiBlock);
        m_pfCosTable[i+iQuarterBlockSize]   = cosf ((i+1) * f3PiBlock);
    }

    return 0;
}

void CzplfFFTGen::FreeFFTTables ()
{
    if (m_pfSinTable)
        zplfFree (m_pfSinTable);
    if (m_pfCosTable)
        zplfFree (m_pfCosTable);
}



int zplfFFTCreateInstance_Gen (CzplfFFT_If*& pCFFT, int iBlockLength, int iZeroPadFactor, CzplfFFT_If::_Fft_Windows_ eWindowType)
{
    int          rErr        = 0;
    CzplfFFTGen     *pCNewFFT   = 0;
    pCFFT                       = 0;

    // check parameters
    if ((iZeroPadFactor <= 0))
        return -1;
    if ((iBlockLength <= 0))
        return -1;
    if ((iBlockLength%4 != 0))
        return -1;
    if ((iZeroPadFactor != Int2PowTwo (iZeroPadFactor)))
        return -1;
    if ((iBlockLength != Int2PowTwo (iBlockLength)))
        return -1;
    
    pCNewFFT = new CzplfFFTGen (iBlockLength, iZeroPadFactor, eWindowType);
    
    if ((pCNewFFT == 0) || (pCNewFFT->m_eLastError != 0))
        return -1;
    else
        pCFFT   = pCNewFFT;

    return 0;
}


int zplfFFTDestroyInstance_Gen (CzplfFFT_If*& pCFFT)
{
    CzplfFFTGen     *pCRealFFT   = (CzplfFFTGen*)pCFFT;
    if (pCRealFFT == 0)
        return -1;
    
    delete pCRealFFT;
    pCFFT = 0;

    return 0;

}

---