FEAPIExamplePluginSpectral.cpp

Go to the documentation of this file.

//     /*! \file FEAPIExamplePluginSpectral.cpp: \brief implementation of the CSpectralFeatures class. */
//
//        Copyright (c) 2005-2007, Alexander Lerch, zplane.development 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.
//


#include <string>
#include <iostream>
#include <math.h>

#include "zplVecLib.h"

#include "FEAPI.h"
#include "FEAPIExamplePluginSpectral.h"
#include "FEAPIEntryPoints.h"

#ifndef FLT_MAX
#define FLT_MAX 3.402823466e+38F
#endif

#define kDefaultNumOfResults    8
#define kDefaultRollOff         0.85F

#define _MY_MAJOR_VERSION       0x00000000
#define _MY_MINOR_VERSION       0x00000000
#define _MY_SUB_VERSION         0x00000001


// defines for plug in name etc.
#define _MY_PLUGIN_NAME        "Spectral"
#define _MY_PLUGIN_VENDOR      "zplane.development"
#define _MY_PLUGIN_DESCRIPTION "This PlugIn calculates the spectral features Flux, Rolloff, Centroid and Spread."
#define _MY_PLUGIN_COPYRIGHT   "(c) 2005 by zplane.development"
#define _MY_PLUGIN_ID          "zplSpectral"


// defines for description of result
#define kFeatureName           "Relative number of Zero-Crossings"
#define kFeatureUnit           "-"
#define kFeatureDescription    "The number of zero crossings in the analysis block divided by the analysis block length"
#define kFeatureRangeMin       0.0F
#define kFeatureRangeMax       1.0F
#define kFeatureIsQuantized    -1  // value is not quantized


enum SpectralParameters_t
{
    kParamBlockSize      = 0,
    kParamHopSize        = 1,
    kParamChannelMode    = 2,
    kParamWindowType     = 3,
    kParamLowFreqBound   = 4,

    kNumParameters
};

enum SpectralFeatures_t
{
    kFeatureFlux         = 0,
    kFeatureRolloff      = 1,
    kFeatureCentroid     = 2,
    kFeatureSpread       = 3,

    kNumFeatures
};

static const FEAPI_ParameterDescription_t SpectralParameterDescription[kNumParameters] = 
{
    //Name,                                     Unit,       Description,                                                                                                                    RangeMin,           RangeMax,               Default,    Quantized,      Realtime
    {"Analysis Block Length",                   "Frames",   "Length of analysis window for one result",                                                                                     4,                  (float)((1<<30)-1),     1024,       4,              false},
    {"Analysis Hop-Size",                       "ms",       "Distance between two analysis block beginnings",                                                                               1,                  (float)((1<<30)-1),     10,         -1,             false},
    {"Individual Channels or Sum Channel",      "",         "Determines wether the calculation should be done on the sum of all input channels ('0') or on each individual channel ('1')",  0,                  1,                      0,          1,              false},
    {"FFT Window",                              "",         "Window Type for FFT analysis (0: rectangular, 1: hanning, 2: hamming, 3: blackman)",                                           0,                  3,                      1,          1,              false},
    {"Low Frequency Cutoff",                    "Hz",       "Only take into account frequencies above this frequency",                                                                      0,                  (float)((1<<30)-1),     0,          -1,             true},
    
};

static const FEAPI_SignalDescription_t SpectralFeatureDescription[kNumFeatures] = 
{
    //Name,                                     Unit,       Description,                                                                                                                                RangeMin,           RangeMax,               Quantized               SampleRate
    {"Spectral Flux",                           "",         "/sqrt{/sum_{/forall k}{(X(n)-X(n-1))^2}}, n = block index, k = frequency index, X = abs spectrum",                                                0,                  (float)((1<<30)-1),     -4,                     0},
    {"Spectral Rolloff",                        "",         "Defined as frequency f_K, given that 0.85/sum_{/forall k}{X_k} == /sum_0^K{X_k}, k = frequency index, X = abs spectrum",                   0,                  (float)((1<<30)-1),     -1,                     0},
    {"Spectral Centroid",                       "",         "C=/frac{/sum_{/forall k}{/log_2(0.001f_k}P}{/sum_{/forall k}{P}}, k = frequency index, P = power spectrum",                                -(float)((1<<30)-1),(float)((1<<30)-1),     -1,                     0},
    {"Spectrum Spread",                         "",         "/frac{/sum_{/forall k}{(/log_2(0.001f_k}-C)^2 P}{/sum_{/forall k}{P}}, k = frequency index, P = power spectrum, C = spectral centroid",    0,                  (float)((1<<30)-1),     -1,                     0},
    
};

static INLINE int sfRollOffIdx (const float *pfSpectrum, int iLength)
{
    float   fSum        = 0,
            fOverallSum = 0;
    int     i;

    for (i = 0; i < iLength; i++)
        fOverallSum    += pfSpectrum[i];
 
    fOverallSum    *= kDefaultRollOff;
    i               = 0;
    while (fSum < fOverallSum)
    {
        fSum   += pfSpectrum[i];
        i++;
    }

    return i;
}

static INLINE float sfFlux (const float *pfSpectrum, float *pfOldSpectrum, int iStartIdx, int iLength)
{
    float   fSum = 0;
    int     i;

    zplfRealSub_I (pfOldSpectrum, (float*)pfSpectrum, iLength);
    zplfRealMul_I (pfOldSpectrum, pfOldSpectrum, iLength);
    for (i = iStartIdx; i < iLength; i++)
        fSum   += pfOldSpectrum[i];

    return sqrtf (fSum);
}

static INLINE float sfCentroid (const float *pfSpectrum, float *pfLogFreqs, float fOverallSum, int iStartIdx, int iLength)
{
    float   fSum = 0;
    int     i;

    if (fOverallSum < 1e-30)
        return 0;

    zplfRealMul_I (pfLogFreqs, (float*)pfSpectrum, iLength);
    for (i = iStartIdx; i < iLength; i++)
        fSum   += pfLogFreqs[i];

    return (fSum / fOverallSum);
}

static INLINE float sfSpread (const float *pfSpectrum, float *pfLogFreqs, float fCentroid, float fOverallSum, int iStartIdx, int iLength)
{
    float   fSum = 0;
    int     i;

    if (fOverallSum < 1e-30)
        return 0;

    zplfRealAddC_I (pfLogFreqs, -fCentroid, iLength);
    zplfRealMul_I (pfLogFreqs, pfLogFreqs, iLength);
    zplfRealMul_I (pfLogFreqs, (float*)pfSpectrum, iLength);
    for (i = iStartIdx; i < iLength; i++)
        fSum   += pfLogFreqs[i];

    return sqrtf (fSum / fOverallSum);
}

CSpectralFeatures::CSpectralFeatures () : CFeatureExtractBase()
{

    zplVecLibDispatcher ();
    
    m_ppCRingBuffer         = 0;
    m_ppResults             = 0;
    m_pfProcessBuffer       = 0;
    m_ptLocalTimeStamp      = 0;
    m_pfParameters          = 0;
    m_pFFTInstance          = 0;
    m_ppfFFTHistory         = 0;
    m_pfHelpBuffer          = 0;
    m_pfLogFreqs            = 0;
    m_iMPEG7SetZero         = 0;

    m_iSizeOfResultBuffer   = kDefaultNumOfResults;

    // set strings that will be returned by the default methods
    m_cPluginName           = _MY_PLUGIN_NAME;
    m_cPluginVendor         = _MY_PLUGIN_VENDOR;
    m_cPluginDescription    = _MY_PLUGIN_DESCRIPTION;
    m_cPluginId             = _MY_PLUGIN_ID;
    m_cPluginCopyRight      = _MY_PLUGIN_COPYRIGHT;

    // set plug in version info
    m_iMajorVersion         = _MY_MAJOR_VERSION;
    m_iMinorVersion         = _MY_MINOR_VERSION;
    m_iSubVersion           = _MY_SUB_VERSION;

    m_pfParameters          = new float [kNumParameters];
    for (int i = 0; i < kNumParameters; i++)
        m_pfParameters[i]     = SpectralParameterDescription[i].fDefaultValue;
}


CSpectralFeatures::~CSpectralFeatures ()
{
    int iCh;
    if (m_ppCRingBuffer)
    {
        for (iCh = 0; iCh < this->GetPluginNumOfInputs (); iCh++)
        {
            if (m_ppCRingBuffer[iCh])
                delete m_ppCRingBuffer[iCh];
            m_ppCRingBuffer[iCh]    = 0;
        }
        delete [] m_ppCRingBuffer;
        m_ppCRingBuffer     = 0;
    }
    if (m_ppResults)
    {
        for (iCh = 0; iCh < this->GetPluginNumOfResults (); iCh++)
        {
            if (m_ppResults[iCh])
                delete [] m_ppResults[iCh];
            m_ppResults[iCh]        = 0;
        }
        delete [] m_ppResults;
        m_ppResults         = 0;
    }
    if (m_ptLocalTimeStamp)
        delete [] m_ptLocalTimeStamp;
    m_ptLocalTimeStamp  = 0;

    if (m_pfParameters)
        delete [] m_pfParameters;
    m_pfParameters      = 0;

    zplfFree (m_pfProcessBuffer);
    zplfFree (m_pfHelpBuffer);
    zplfFree (m_pfLogFreqs);
    if (m_ppfFFTHistory)
    {
        for (iCh = 0; iCh < this->GetPluginNumOfResults ()/kNumFeatures; iCh++)
            zplfFree (m_ppfFFTHistory[iCh]);

        delete [] m_ppfFFTHistory;
        m_ppfFFTHistory = 0;
    }
    zplfFFTDestroyInstance (m_pFFTInstance);
}


FEAPI_Error_t      CSpectralFeatures::InitializePlugin (float               fInputSampleRate, 
                                                        int                 iNumberOfAudioChannels,
                                                        int                 iHostApiMajorVersion,
                                                        FEAPI_UserData_t     *pstUserData)
{
    FEAPI_Error_t   rErr;
    int             iCh;

    // free already allocated memory
    if (m_ppCRingBuffer)
    {
        for (iCh = 0; iCh < this->GetPluginNumOfInputs ()/kNumFeatures; iCh++)
        {
            if (m_ppCRingBuffer[iCh])
                delete m_ppCRingBuffer[iCh];
            m_ppCRingBuffer[iCh]    = 0;
        }
        delete [] m_ppCRingBuffer;
        m_ppCRingBuffer     = 0;
    }
    if (m_ppResults)
    {
        for (iCh = 0; iCh < this->GetPluginNumOfResults (); iCh++)
        {
            if (m_ppResults[iCh])
                delete [] m_ppResults[iCh];
            m_ppResults[iCh]        = 0;
        }
        delete [] m_ppResults;
        m_ppResults         = 0;
    }
    if (m_ptLocalTimeStamp)
        delete [] m_ptLocalTimeStamp;
    m_ptLocalTimeStamp  = 0;
    zplfFree (m_pfProcessBuffer);
    zplfFree (m_pfHelpBuffer);
    zplfFree (m_pfLogFreqs);
    if (m_ppfFFTHistory)
    {
        for (iCh = 0; iCh < this->GetPluginNumOfResults ()/kNumFeatures; iCh++)
            zplfFree (m_ppfFFTHistory[iCh]);

        delete [] m_ppfFFTHistory;
        m_ppfFFTHistory = 0;
    }

    rErr    = CFeatureExtractBase::InitializePlugin (   fInputSampleRate, 
                                                        iNumberOfAudioChannels,
                                                        iHostApiMajorVersion,
                                                        pstUserData);

    if (rErr != FEAPI_kNoError)
        return rErr;

    // Set information about the plugin inputs
    char acChannelStr[FEAPI_kMaxDescriptionLength];
    for (int h = 0; h < iNumberOfAudioChannels; ++h) 
    {
        sprintf(acChannelStr, "Channel: %d", h);
        SetPluginInputPinInfo(CPin::SetIndex(h)
            .SetName(acChannelStr)
            .SetUnit("")
            .SetDescription(acChannelStr)
            .SetRangeMin(-1.0f)
            .SetRangeMax(1.0f)
            .SetSampleRate(fInputSampleRate)
        );
    }

    // Setting information about the plugin parameters
    for (int i = 0; i < kNumParameters; ++i) 
    {
        SetPluginParameterPinInfo(CPin::SetIndex(i)
            .SetName(SpectralParameterDescription[i].acName)
            .SetUnit(SpectralParameterDescription[i].acUnit)
            .SetDescription(SpectralParameterDescription[i].acDescription)
            .SetRangeMin(SpectralParameterDescription[i].fRangeMin)
            .SetRangeMax(SpectralParameterDescription[i].fRangeMax)
            .SetDefaultValue(SpectralParameterDescription[i].fDefaultValue)
            .SetQuantizedTo(SpectralParameterDescription[i].fQuantizedTo)
            .SetIsChangeableInRealTime(SpectralParameterDescription[i].bIsChangeableInRealTime)
        );
    }

    // allocate ringbuffers and memory for results and temp memory for processing
    int iAllocLength    = (m_pfParameters[kParamBlockSize] > m_pfParameters[kParamHopSize]/1000*fInputSampleRate)?
        (int)(m_pfParameters[kParamBlockSize] + .5F) : (int)(m_pfParameters[kParamHopSize]/1000*fInputSampleRate + .5F);
    m_pfProcessBuffer   = zplfMalloc (iAllocLength);
    m_pfHelpBuffer      = zplfMalloc ((iAllocLength)>>1);
    m_pfLogFreqs        = zplfMalloc ((iAllocLength)>>1);
    m_ppCRingBuffer     = new CRingBuffer<float>*[iNumberOfAudioChannels];
    for (iCh = 0; iCh < iNumberOfAudioChannels; iCh++)
    {
        m_ppCRingBuffer[iCh]    = new CRingBuffer<float>(iAllocLength<<1);
    }

    // Setting information about the plugin results
    char acDescription[FEAPI_kMaxDescriptionLength];
    //int  iNumOfChannels =  (m_pfParameters[kParamChannelMode]  ==  0)  ?  1  :  iNumberOfAudioChannels;
    int iNumOfResults   = kNumFeatures * ((m_pfParameters[kParamChannelMode] == 0) ? 1 : iNumberOfAudioChannels);
    if (m_pfParameters[kParamChannelMode] == 0)
    {
        for (iCh = 0; iCh < iNumOfResults; ++iCh) 
        {
            sprintf(acDescription, "%s", SpectralFeatureDescription[iCh].acDescription);
            SetPluginResultPinInfo(CPin::SetIndex(iCh)
                .SetName(SpectralFeatureDescription[iCh].acName)
                .SetUnit(SpectralFeatureDescription[iCh].acUnit)
                .SetDescription(acDescription)
                .SetRangeMin(SpectralFeatureDescription[iCh].fRangeMin)
                .SetRangeMax(SpectralFeatureDescription[iCh].fRangeMax)
                .SetQuantizedTo(SpectralFeatureDescription[iCh].fQuantizedTo)
                .SetSampleRate(1000.0F / m_pfParameters[kParamHopSize])
                );
        }
    }
    else
    {
        for (iCh = 0; iCh < iNumOfResults; ++iCh) 
        {
            sprintf(acDescription, "Channel: %d;", iCh/iNumberOfAudioChannels);
            strcat(acDescription, SpectralFeatureDescription[iCh/iNumberOfAudioChannels].acDescription);
            SetPluginResultPinInfo(CPin::SetIndex(iCh)
                .SetName(SpectralFeatureDescription[iCh/iNumberOfAudioChannels].acName)
                .SetUnit(SpectralFeatureDescription[iCh/iNumberOfAudioChannels].acUnit)
                .SetDescription(acDescription)
                .SetRangeMin(SpectralFeatureDescription[iCh/iNumberOfAudioChannels].fRangeMin)
                .SetRangeMax(SpectralFeatureDescription[iCh/iNumberOfAudioChannels].fRangeMax)
                .SetQuantizedTo(SpectralFeatureDescription[iCh/iNumberOfAudioChannels].fQuantizedTo)
                .SetSampleRate(1000.0F / m_pfParameters[kParamHopSize])
            );
        }
    }
    m_ppResults             = new InternalResults_t*[iNumOfResults];
    m_ppfFFTHistory         = new float*[iNumOfResults];
    m_ptLocalTimeStamp      = new FEAPI_TimeStamp_t [iNumOfResults];
    for (iCh = 0; iCh < iNumOfResults; iCh++)
    {
        m_ppResults[iCh]        = new InternalResults_t[m_iSizeOfResultBuffer];
        m_ppfFFTHistory[iCh]    = zplfMalloc (((int)(m_pfParameters[kParamBlockSize]+.1F))>>1);
        zplfSetZero (m_ppfFFTHistory[iCh], ((int)(m_pfParameters[kParamBlockSize]+.1F))>>1);
        memset (m_ppResults[iCh], 0, sizeof (InternalResults_t) * m_iSizeOfResultBuffer);
    }
    memset (m_ptLocalTimeStamp, 0, sizeof(FEAPI_TimeStamp_t)*iNumberOfAudioChannels);

    zplfFFTDestroyInstance (m_pFFTInstance);
    zplfFFTCreateInstance (m_pFFTInstance, (int)(m_pfParameters[kParamBlockSize] + .1F),1, CzplfFFT_If::_Fft_Windows_ ((int)(m_pfParameters[kParamWindowType] + .1F)));

    // init tables
    m_iMPEG7SetZero = this->CalcFreqTable ();
    
    return FEAPI_kNoError;
}

FEAPI_Error_t      CSpectralFeatures::SetPluginParameter (int iParameterIndex, float fValue)
{
    if ((iParameterIndex >= this->GetPluginNumOfParameters ()) || (iParameterIndex < 0))
        return FEAPI_kUnspecifiedError;

    if ((fValue < SpectralParameterDescription[iParameterIndex].fRangeMin) || (fValue > SpectralParameterDescription[iParameterIndex].fRangeMax))
        return FEAPI_kUnspecifiedError;

    m_pfParameters[iParameterIndex] = fValue;

    if ((iParameterIndex == kParamBlockSize) && ((int)(fValue) != Int2PowTwo ((int)fValue)))
        return FEAPI_kUnspecifiedError;

    // since all other parameters are non-realtime parameters, we can call initialize here for simplicity
    if (iParameterIndex != kParamLowFreqBound)
        this->InitializePlugin (m_fSampleRate, this->GetPluginNumOfInputs (), 1, 0);
    
    return FEAPI_kNoError;
}


float       CSpectralFeatures::GetPluginParameter (int iParameterIndex)
{
    if ((iParameterIndex >= this->GetPluginNumOfParameters ()) || (iParameterIndex < 0))
        return FEAPI_kUnspecifiedError;

    return m_pfParameters[iParameterIndex];
}


int         CSpectralFeatures::GetPluginResultLatency (int iResultIndex)
{
    return (int)(m_pfParameters[kParamBlockSize]);
}


FEAPI_Error_t      CSpectralFeatures::ProcessPluginDone ()
{
    int iNumProcessChannels = this->GetPluginNumOfResults ()/kNumFeatures, // either 1 or num of channels...
        iProcessBlockSize   = (int)(m_pfParameters[kParamBlockSize]),
        iProcessBufSize     = (m_pfParameters[kParamBlockSize] > m_pfParameters[kParamHopSize]/1000*m_fSampleRate)? (int)(m_pfParameters[kParamBlockSize] + .5F) : (int)(m_pfParameters[kParamHopSize]/1000*m_fSampleRate + .5F),
        iStartIdx           = (int)(m_pfParameters[kParamLowFreqBound] / m_fSampleRate * iProcessBlockSize),
        iSamplesInBuffer    = m_ppCRingBuffer[0]->GetSamplesInBuffer ();

    for (int iCh = 0; iCh < iNumProcessChannels; iCh++)
    {
        float   fSum  = 0,
                fResult;

        // get data from ring bufffer and oncrement read pointer
        m_ppCRingBuffer[iCh]->GetPostInc (m_pfProcessBuffer, iSamplesInBuffer);
        memset (&m_pfProcessBuffer[iSamplesInBuffer], 0, sizeof(float)*(iProcessBufSize - iSamplesInBuffer));
    
        // adjust time stamp
        m_ptLocalTimeStamp[iCh]  = m_ptLocalTimeStamp[iCh] - iSamplesInBuffer/m_fSampleRate;

        // calc fft
        m_pFFTInstance->zplfFFT (m_pfProcessBuffer, m_pfProcessBuffer);

        // calc abs
        zplfCompAbs (m_pfProcessBuffer, m_pfProcessBuffer, iProcessBlockSize>>1);

        // calc rolloff
        fResult = sfRollOffIdx (&m_pfProcessBuffer[iStartIdx], (iProcessBlockSize>>1)-iStartIdx) * m_fSampleRate / iProcessBlockSize;
        this->WriteResult (kFeatureRolloff * iNumProcessChannels + iCh, fResult, m_ptLocalTimeStamp[iCh]); 

        // calc flux
        fResult = sfFlux (m_pfProcessBuffer, m_ppfFFTHistory[iCh], iStartIdx, iProcessBlockSize>>1);
        this->WriteResult (kFeatureFlux * iNumProcessChannels + iCh, fResult, m_ptLocalTimeStamp[iCh]); 

        // update history buffer for next frame
        memcpy (m_ppfFFTHistory[iCh], m_pfProcessBuffer, sizeof(float)*(iProcessBlockSize>>1));

        // calc power
        zplfRealMul_I (m_pfProcessBuffer, m_pfProcessBuffer, iProcessBlockSize>>1);

        // calc sum
        for (int j = iStartIdx; j < iProcessBlockSize>>1; j++)
            fSum    += m_pfProcessBuffer[j];

        // calc centroid
        memcpy (m_pfHelpBuffer, m_pfLogFreqs, sizeof(float)*(iProcessBlockSize>>1));
        fResult = sfCentroid (m_pfProcessBuffer, m_pfHelpBuffer, fSum, iStartIdx, iProcessBlockSize>>1);
        this->WriteResult (kFeatureCentroid * iNumProcessChannels + iCh, fResult, m_ptLocalTimeStamp[iCh]); 

        // calc spread
        memcpy (m_pfHelpBuffer, m_pfLogFreqs, sizeof(float)*(iProcessBlockSize>>1));
        fResult = sfSpread (m_pfProcessBuffer, m_pfHelpBuffer, fResult, fSum, iStartIdx, iProcessBlockSize>>1);
        this->WriteResult (kFeatureSpread * iNumProcessChannels + iCh, fResult, m_ptLocalTimeStamp[iCh]); 
    }

    return FEAPI_kNoError;
}

FEAPI_Error_t      CSpectralFeatures::ProcessPlugin (const float **ppfInputBuffer, const FEAPI_TimeStamp_t *ptTimeStamps, int iNumberOfFrames)
{
    bool bDownmixToMono = (m_pfParameters[kParamChannelMode] == 0)? true : false;
    int iCh,
        iIdx,
        iProcessBlockSize   = (int)(m_pfParameters[kParamBlockSize]),
        iHopSize            = (int)(m_pfParameters[kParamHopSize]*0.001F * m_fSampleRate + .1F),
        iFramesRequired     = (m_pfParameters[kParamBlockSize] > iHopSize) ? (int)(m_pfParameters[kParamBlockSize]) : iHopSize,
        iStartIdx           = (int)(m_pfParameters[kParamLowFreqBound] / m_fSampleRate * iProcessBlockSize),
        iNumFramesLeft      = iNumberOfFrames,
        iNumInputChannels   = this->GetPluginNumOfInputs (),
        iNumProcessChannels = this->GetPluginNumOfResults ()/kNumFeatures, // either 1 or num of channels...,
        iSamplesInBuffer    = 0;

    if (!m_bIsInitialized)
        return FEAPI_kUnspecifiedError;

    // do time stamp handling, in both cases: no/defined time stamp
    if (ptTimeStamps)
    {
        for (iCh = 0; iCh < iNumInputChannels; iCh++)
            m_ptLocalTimeStamp[iCh] = ptTimeStamps[iCh] + iNumberOfFrames/m_fSampleRate;
    }
    else
    {
        for (iCh = 0; iCh < iNumInputChannels; iCh++)
            m_ptLocalTimeStamp[iCh]    += iNumberOfFrames/m_fSampleRate;
    }

    // if there are sufficient frames to process, do it!
    //while (m_ppCRingBuffer[0]->GetSamplesInBuffer () + iNumFramesLeft >= iProcessBlockSize)
    while (m_ppCRingBuffer[0]->GetSamplesInBuffer () + iNumFramesLeft >= iFramesRequired)
    {
        // check if we have to downmix to mono or not
        if (bDownmixToMono)
        {
            int iLength = (iHopSize < iNumFramesLeft) ? iHopSize : iNumFramesLeft;
            iNumProcessChannels = 1;
            // downmix and write to buffer, decr numframesleft
            memcpy (m_pfProcessBuffer, &ppfInputBuffer[0][iNumberOfFrames - iNumFramesLeft], sizeof(float) * iLength);
            for (iCh = 1; iCh < iNumInputChannels; iCh++)
            {
                const float *pfBuffer = &ppfInputBuffer[iCh][iNumberOfFrames - iNumFramesLeft];

                for (iIdx = 0; iIdx < iLength; iIdx++)
                    m_pfProcessBuffer[iIdx] += pfBuffer[iIdx];
            }

            // scale downmixed signal
            for (iIdx = 0; iIdx < iLength; iIdx++)
                m_pfProcessBuffer[iIdx] *= 1.0F/iNumInputChannels;

            m_ppCRingBuffer[0]->PutPostInc (m_pfProcessBuffer, iLength);
        }
        else
        {
            for (iCh = 0; iCh < iNumInputChannels; iCh++)
                m_ppCRingBuffer[iCh]->PutPostInc (&ppfInputBuffer[iCh][iNumberOfFrames - iNumFramesLeft], (iHopSize < iNumFramesLeft) ? iHopSize : iNumFramesLeft);
        }

        // decrement number of frames left in ppfInputBuffer
        iNumFramesLeft     -= (iHopSize < iNumFramesLeft) ? iHopSize : iNumFramesLeft;

        // get the current number of sample in ring buffer
        iSamplesInBuffer    = m_ppCRingBuffer[0]->GetSamplesInBuffer ();

        // if there are not enough sample in ring buffer, go on (note that this is not really possible...)
        if (iSamplesInBuffer < iProcessBlockSize)
            continue;

        // now do the processing
        for (iCh = 0; iCh < iNumProcessChannels; iCh++)
        {
            int     j;
            float   fSum  = 0,
                    fResult;

            // adjust time stamp
            m_ptLocalTimeStamp[iCh]  = ptTimeStamps[iCh] + iNumberOfFrames/m_fSampleRate - (iSamplesInBuffer+iNumFramesLeft)/m_fSampleRate;
    
            // get data from ring buffer and increment read pointer
            m_ppCRingBuffer[iCh]->GetOff (m_pfProcessBuffer, iProcessBlockSize, 0);
            m_ppCRingBuffer[iCh]->SetReadPos (m_ppCRingBuffer[iCh]->GetReadPos () + iHopSize);

            // calc fft
            m_pFFTInstance->zplfFFT (m_pfProcessBuffer, m_pfProcessBuffer);

            // calc abs
            zplfCompAbs (m_pfProcessBuffer, m_pfProcessBuffer, iProcessBlockSize>>1);

            // calc rolloff
            fResult = sfRollOffIdx (&m_pfProcessBuffer[iStartIdx], (iProcessBlockSize>>1)-iStartIdx) * m_fSampleRate / iProcessBlockSize;
            this->WriteResult (kFeatureRolloff * iNumProcessChannels + iCh, fResult, m_ptLocalTimeStamp[iCh]); 

            // calc flux
            fResult = sfFlux (m_pfProcessBuffer, m_ppfFFTHistory[iCh], iStartIdx, iProcessBlockSize>>1);
            this->WriteResult (kFeatureFlux * iNumProcessChannels + iCh, fResult, m_ptLocalTimeStamp[iCh]); 

            // update history buffer for next frame
            memcpy (m_ppfFFTHistory[iCh], m_pfProcessBuffer, sizeof(float)*(iProcessBlockSize>>1));

            // calc power
            zplfRealMul_I (m_pfProcessBuffer, m_pfProcessBuffer, (iProcessBlockSize>>1));

            // mpeg-7 specific low frequencies:
            for (j = 0; j < m_iMPEG7SetZero+1; j++)
                fSum    += m_pfProcessBuffer[j];
            for (j = 0; j < m_iMPEG7SetZero; j++)
                m_pfProcessBuffer[j]    = 0.0F;
            m_pfProcessBuffer[m_iMPEG7SetZero]  = fSum;

            // calc sum
            fSum = 0;
            for (j = iStartIdx; j < iProcessBlockSize>>1; j++)
                fSum    += m_pfProcessBuffer[j];
            
            // calc centroid
            memcpy (m_pfHelpBuffer, m_pfLogFreqs, sizeof(float)*(iProcessBlockSize>>1));
            fResult = sfCentroid (m_pfProcessBuffer, m_pfHelpBuffer, fSum, iStartIdx, iProcessBlockSize>>1);
            this->WriteResult (kFeatureCentroid * iNumProcessChannels + iCh, fResult, m_ptLocalTimeStamp[iCh]); 

            // calc spread
            memcpy (m_pfHelpBuffer, m_pfLogFreqs, sizeof(float)*(iProcessBlockSize>>1));
            fResult = sfSpread (m_pfProcessBuffer, m_pfHelpBuffer, fResult, fSum, iStartIdx, iProcessBlockSize>>1);
            this->WriteResult (kFeatureSpread * iNumProcessChannels + iCh, fResult, m_ptLocalTimeStamp[iCh]); 
            
            // adjust time stamp
            m_ptLocalTimeStamp[iCh]  = m_ptLocalTimeStamp[iCh] + iHopSize/m_fSampleRate;
        }
    }

    // if there are frames left in ppfInputBuffer, handle them here
    if (iNumFramesLeft > 0)
    {
        // write remaining frames to ringbuffer (distinguish downmix or not..., decr numframesleft)
        if (bDownmixToMono)
        {
            // downmix and write to buffer
            memcpy (m_pfProcessBuffer, &ppfInputBuffer[0][iNumberOfFrames - iNumFramesLeft], sizeof(float) * iNumFramesLeft);
            for (iCh = 1; iCh < iNumInputChannels; iCh++)
            {
                const float *pfBuffer = &ppfInputBuffer[iCh][iNumberOfFrames - iNumFramesLeft];

                for (iIdx = 0; iIdx < iNumFramesLeft; iIdx++)
                    m_pfProcessBuffer[iIdx] += pfBuffer[iIdx];
            }
            // scale downmixed signal
            for (iIdx = 0; iIdx < iHopSize; iIdx++)
                m_pfProcessBuffer[iIdx] *= 1.0F/iNumInputChannels;

            m_ppCRingBuffer[0]->PutPostInc (m_pfProcessBuffer, iNumFramesLeft);
        }
        else
        {
            for (iCh = 0; iCh < iNumInputChannels; iCh++)
                m_ppCRingBuffer[iCh]->PutPostInc (&ppfInputBuffer[iCh][iNumberOfFrames - iNumFramesLeft], iNumFramesLeft);
        }
    }

    return FEAPI_kNoError;
}

int         CSpectralFeatures::GetPluginSizeOfResult (int iResultIndex)
{
    if ((iResultIndex >= this->GetPluginNumOfResults ()) || (iResultIndex < 0))
        return -1;

    if (m_ppResults[iResultIndex][0].bHoldsResult == true)
        return 1;
    else
        return 0;
}


FEAPI_Error_t      CSpectralFeatures::GetPluginResult (int iResultIndex, float *pfResult, FEAPI_TimeStamp_t *ptTimeStamp)
{
    if ((iResultIndex >= this->GetPluginNumOfResults ()) || (iResultIndex < 0))
        return FEAPI_kUnspecifiedError;
    
    if (m_ppResults[iResultIndex][0].bHoldsResult == false)
        return FEAPI_kUnspecifiedError;

    pfResult[0]     = m_ppResults[iResultIndex][0].fResult;
    ptTimeStamp[0]  = m_ppResults[iResultIndex][0].tTimeStamp;

    memmove (&m_ppResults[iResultIndex][0], &m_ppResults[iResultIndex][1], (m_iSizeOfResultBuffer - 1)*sizeof(InternalResults_t));
    m_ppResults[iResultIndex][m_iSizeOfResultBuffer-1].bHoldsResult = false;

    return FEAPI_kNoError;
}


FEAPI_Error_t      CSpectralFeatures::ResetPlugin ()
{
    for (int iCh = 0; iCh < this->GetPluginNumOfInputs (); iCh++)
    {
        m_ppCRingBuffer[iCh]->Reset ();
        m_ptLocalTimeStamp[iCh] = 0;
    }
    return FEAPI_kNoError;
}


float        CSpectralFeatures::GetPluginProperty ( FEAPI_PluginProperty_t ePluginProperty)
{
    switch (ePluginProperty)
    {
    case FEAPI_kMinSampleRate:
        {
            return 1;
        }
    case FEAPI_kMaxSampleRate:
        {
            return 1e38F;
        }
    case FEAPI_kMinChannels:
        {
            return 1;
        }
    case FEAPI_kMaxChannels:
        {
            return (float)((1<<30)-1);
        }
    case FEAPI_kMinFrameSize:
        {
            return 1;
        }
    case FEAPI_kMaxFrameSize:
        {
            return (float)((1<<30)-1);
        }
    case FEAPI_kOptFrameSize:
        {
            return floorf(m_pfParameters[kParamHopSize] * 0.001F * m_fSampleRate + .1F);
        }
    default:
        {
            // this shall never happen ...
            return -1;
        }
    }
    return -1;
}

void CSpectralFeatures::WriteResult (int iResultIdx, float fValue, FEAPI_TimeStamp_t tTimeStamp)
{
    int     iCurrentIdx = 0;

    ZASSERT (!m_ppResults);
    
    for (iCurrentIdx = 0; iCurrentIdx < m_iSizeOfResultBuffer; iCurrentIdx++)
    {
        ZASSERT (!m_ppResults[iCurrentIdx]);
        if (m_ppResults[iResultIdx][iCurrentIdx].bHoldsResult == false)
            break;
    }
    if (iCurrentIdx == m_iSizeOfResultBuffer)
    {
        // alloc new memory
        m_iSizeOfResultBuffer   <<= 1;
        for (int i = 0; i < this->GetPluginNumOfResults (); i++)
        {
            InternalResults_t *pTmp = new InternalResults_t[m_iSizeOfResultBuffer];
            memcpy (pTmp, m_ppResults[i], (m_iSizeOfResultBuffer>>1) * sizeof(InternalResults_t));
            memset (&pTmp[(m_iSizeOfResultBuffer>>1)], 0, (m_iSizeOfResultBuffer>>1) * sizeof(InternalResults_t));
            delete [] m_ppResults[i];
            m_ppResults[i]          = 0;
            m_ppResults[i]          = pTmp;
        }
    }

    m_ppResults[iResultIdx][iCurrentIdx].bHoldsResult  = true;
    m_ppResults[iResultIdx][iCurrentIdx].fResult       = fValue;
    m_ppResults[iResultIdx][iCurrentIdx].tTimeStamp    = tTimeStamp;

    return;
}

int CSpectralFeatures::CalcFreqTable ()
{
    // don't worry about the magic frequency values... these are from MPEG-7
    
    int i,
        iProcessBlockSize   =  (((int)(m_pfParameters[kParamBlockSize]+.1F))>>1),
        iStartIdx           = (int)floorf ( 62.5F * (iProcessBlockSize<<1) / m_fSampleRate)+1;
    float   fInvLog2        = 1.0F / logf(2.0F),
            fInvBlockSize   = 1.0F / (iProcessBlockSize<<1);

    for (i = 0; i < iStartIdx; i++)
        m_pfLogFreqs[i] = fInvLog2 * logf (31.25F*0.001F);

    for (i = iStartIdx; i < iProcessBlockSize; i++)
        m_pfLogFreqs[i] = fInvLog2 * logf (i * m_fSampleRate * 0.001F * fInvBlockSize);

    return iStartIdx-1;
}

// entry points
#ifdef __cplusplus                                                      
extern "C" {                                                            
#endif                                                              

FEAPI_ENTRY_POINTS(CSpectralFeatures)

#ifdef __cplusplus                                                  
}                                                               
#endif

---