FEAPIExamplePluginZeroCrossings.cpp

Go to the documentation of this file.

//     /*! \file FEAPIExamplePluginZeroCrossings.cpp: \brief implementation of the CZeroCrossings 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 "FEAPIExamplePluginZeroCrossings.h"
#include "FEAPIEntryPoints.h"

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

#define kDefaultNumOfResults    8

#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        "ZeroCrossings"
#define _MY_PLUGIN_VENDOR      "zplane.development"
#define _MY_PLUGIN_DESCRIPTION "This PlugIn calculates the relative number of zero crossings per channel. A zero crossing is a sign change of two neibourghed samples."
#define _MY_PLUGIN_COPYRIGHT   "(c) 2005 by zplane.development"
#define _MY_PLUGIN_ID          "zplZeroCrossings"


// defines for description of result
#define kFeatureIndex          0
#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

#define kParam1Index                    0
#define kParam1Name                     "Analysis Block Length"
#define kParam1Unit                     "Frames"
#define kParam1Description              "Length of analysis window for one result"
#define kParam1RangeMin                 4
#define kParam1RangeMax                 (float)((1<<30)-1)
#define kParam1DefaultValue             1024
#define kParam1QuantizedTo              4
#define kParam1IsChangeableInRealTime   false

#define kParam2Index                    1
#define kParam2Name                     "Analysis Hop-Size"
#define kParam2Unit                     "ms"
#define kParam2Description              "Distance between two analysis block beginnings"
#define kParam2RangeMin                 1
#define kParam2RangeMax                 (float)((1<<30)-1)
#define kParam2DefaultValue             10
#define kParam2QuantizedTo              -1
#define kParam2IsChangeableInRealTime   false

#define kParam3Index                    2
#define kParam3Name                     "Individual Channels or Sum Channel"
#define kParam3Unit                     ""
#define kParam3Description              "Determines wether the calculation should be done on the sum of all input channels ('0') or on each individual channel ('1')"
#define kParam3RangeMin                 0
#define kParam3RangeMax                 1
#define kParam3DefaultValue             0
#define kParam3QuantizedTo              1
#define kParam3IsChangeableInRealTime   false

enum MyParameters_t
{
    kBlockSize      = 0,
    kHopSize        = 1,
    kChannelMode    = 2,

    kNumParameters
};

CZeroCrossings::CZeroCrossings () : CFeatureExtractBase()
{

    zplVecLibDispatcher ();
    
    m_ppCRingBuffer         = 0;
    m_ppResults             = 0;
    m_pfProcessBuffer       = 0;
    m_ptLocalTimeStamp      = 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_afParameters[kBlockSize]  = kParam1DefaultValue;
    m_afParameters[kHopSize]    = kParam2DefaultValue;
    m_afParameters[kChannelMode]= kParam3DefaultValue;
}


CZeroCrossings::~CZeroCrossings ()
{
    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;

    zplfFree (m_pfProcessBuffer);
}


FEAPI_Error_t      CZeroCrossings::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 (); 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);

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


    if (rErr != FEAPI_kNoError)
        return rErr;

    // Set information about the plugin inputs
    char acChannelStr[FEAPI_kMaxDescriptionLength];
    for (iCh = 0; iCh < iNumberOfAudioChannels; ++iCh) {
        sprintf(acChannelStr, "Channel: %d", iCh);
        SetPluginInputPinInfo(CPin::SetIndex(iCh)
            .SetName(acChannelStr)
            .SetUnit("")
            .SetDescription(acChannelStr)
            .SetRangeMin(-1.0f)
            .SetRangeMax(1.0f)
            .SetSampleRate(fInputSampleRate)
        );
    }
        
    // Set information about the plugin results
    //m_iNumberOfResults              = (m_afParameters[kChannelMode] == 0) ? 1 : m_iNumberOfChannels;
    if (m_afParameters[kChannelMode] == 0)
    {
        SetPluginResultPinInfo(CPin::SetIndex(kFeatureIndex)
        .SetName(kFeatureName)
        .SetUnit(kFeatureUnit)
        .SetDescription(kFeatureDescription)
        .SetRangeMin(kFeatureRangeMin)
        .SetRangeMax(kFeatureRangeMax)
        .SetQuantizedTo(kFeatureIsQuantized)
        .SetSampleRate(1000.0F / m_afParameters[kHopSize])
    );
    }
    else
    {
        for (iCh = 0; iCh < iNumberOfAudioChannels; ++iCh) 
        {
            sprintf(acChannelStr, "%s Channel: %d", kFeatureName, iCh);
            SetPluginInputPinInfo(CPin::SetIndex(iCh)
                .SetName(acChannelStr)
                .SetUnit(kFeatureUnit)
                .SetDescription(kFeatureDescription)
                .SetRangeMin(kFeatureRangeMin)
                .SetRangeMax(kFeatureRangeMax)
                .SetSampleRate(1000.0F / m_afParameters[kHopSize])
                );
        }
    }

    // Setting information about the plugin parameters
    SetPluginParameterPinInfo(CPin::SetIndex(kParam1Index)
        .SetName(kParam1Name)
        .SetUnit(kParam1Unit)
        .SetDescription(kParam1Description)
        .SetRangeMin(kParam1RangeMin)
        .SetRangeMax(kParam1RangeMax)
        .SetDefaultValue(kParam1DefaultValue)
        .SetQuantizedTo(kParam1QuantizedTo)
        .SetIsChangeableInRealTime(kParam1IsChangeableInRealTime)
    );

    SetPluginParameterPinInfo(CPin::SetIndex(kParam2Index)
        .SetName(kParam2Name)
        .SetUnit(kParam2Unit)
        .SetDescription(kParam2Description)
        .SetRangeMin(kParam2RangeMin)
        .SetRangeMax(kParam2RangeMax)
        .SetDefaultValue(kParam2DefaultValue)
        .SetQuantizedTo(kParam2QuantizedTo)
        .SetIsChangeableInRealTime(kParam2IsChangeableInRealTime)
    );

    SetPluginParameterPinInfo(CPin::SetIndex(kParam3Index)
        .SetName(kParam3Name)
        .SetUnit(kParam3Unit)
        .SetDescription(kParam3Description)
        .SetRangeMin(kParam3RangeMin)
        .SetRangeMax(kParam3RangeMax)
        .SetDefaultValue(kParam3DefaultValue)
        .SetQuantizedTo(kParam3QuantizedTo)
        .SetIsChangeableInRealTime(kParam3IsChangeableInRealTime)
    );

    // allocate ringbuffers and memory for results and temp memory for processing
    m_pfProcessBuffer   = zplfMalloc ((int)(m_afParameters[kBlockSize]));
    m_ptLocalTimeStamp  = new FEAPI_TimeStamp_t [iNumberOfAudioChannels];
    m_ppCRingBuffer     = new CRingBuffer<float>*[iNumberOfAudioChannels];
    m_ppResults         = new InternalResults_t*[iNumberOfAudioChannels];
    for (iCh = 0; iCh < iNumberOfAudioChannels; iCh++)
    {
        m_ppCRingBuffer[iCh]    = new CRingBuffer<float>((unsigned int)(m_afParameters[kBlockSize])<<1);
        m_ppResults[iCh]        = new InternalResults_t[m_iSizeOfResultBuffer];
        memset (m_ppResults[iCh], 0, sizeof (InternalResults_t) * m_iSizeOfResultBuffer);
    }
    memset (m_ptLocalTimeStamp, 0, sizeof(FEAPI_TimeStamp_t)*iNumberOfAudioChannels);

    return FEAPI_kNoError;
}

FEAPI_Error_t      CZeroCrossings::SetPluginParameter (int iParameterIndex, float fValue)
{
    float   fMinValue,
            fMaxValue;

    if ((iParameterIndex >= this->GetPluginNumOfParameters ()) || (iParameterIndex < 0))
        return FEAPI_kUnspecifiedError;

    // check range
    switch (iParameterIndex)
    {
    case kBlockSize:
        fMinValue   = kParam1RangeMin;
        fMaxValue   = kParam1RangeMax;
        break;
    case kHopSize:
        fMinValue   = kParam2RangeMin;
        fMaxValue   = kParam2RangeMax;
        break;
    case kChannelMode:
        fMinValue   = kParam3RangeMin;
        fMaxValue   = kParam3RangeMax;
        break;
    default:
        return FEAPI_kUnspecifiedError;
    }

    if ((fValue < fMinValue) || (fValue > fMaxValue))
        return FEAPI_kUnspecifiedError;

    m_afParameters[iParameterIndex] = fValue;

    // since all parameters are non-realtime parameters, we can call initialize her for simplicity
    this->InitializePlugin (m_fSampleRate, this->GetPluginNumOfInputs (), 1, 0);
    
    return FEAPI_kUnknownError;
}


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

    return m_afParameters[iParameterIndex];
}


int         CZeroCrossings::GetPluginResultLatency (int iResultIndex)
{
    return (int)m_afParameters[kBlockSize];
}


FEAPI_Error_t      CZeroCrossings::ProcessPluginDone ()
{
    int iNumProcessChannels = this->GetPluginNumOfResults (), // either 1 or num of channels...
        iProcessBlockSize   = (int)(m_afParameters[kBlockSize]),
        iSamplesInBuffer    = m_ppCRingBuffer[0]->GetSamplesInBuffer ();

    for (int iCh = 0; iCh < iNumProcessChannels; iCh++)
    {
        int iTempResult = 0;

        m_ppCRingBuffer[iCh]->GetPostInc (m_pfProcessBuffer, iSamplesInBuffer);
        memset (&m_pfProcessBuffer[iSamplesInBuffer], 0, sizeof(float)*(iProcessBlockSize - iSamplesInBuffer));

        iTempResult = zplfZeroCrossings (m_pfProcessBuffer, iProcessBlockSize);

        m_ptLocalTimeStamp[iCh]  = m_ptLocalTimeStamp[iCh] + m_afParameters[kHopSize]*0.001F;
        this->WriteResult (iCh, iTempResult * 1.0F / iSamplesInBuffer, m_ptLocalTimeStamp[iCh]);
    }

    return FEAPI_kNoError;
}

FEAPI_Error_t      CZeroCrossings::ProcessPlugin (const float **ppfInputBuffer, const FEAPI_TimeStamp_t *ptTimeStamps, int iNumberOfFrames)
{
    bool bDownmixToMono = (m_afParameters[kChannelMode] == 0)? true : false;
    int iCh,
        iIdx,
        iProcessBlockSize   = (int)(m_afParameters[kBlockSize]),
        iHopSize            = (int)(m_afParameters[kHopSize]*0.001F * m_fSampleRate + .5F),
        iNumFramesLeft      = iNumberOfFrames,
        iNumInputChannels   = this->GetPluginNumOfInputs (),
        iNumProcessChannels = this->GetPluginNumOfResults (), // 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)
    {
        // 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 iTempResult = 0;
    
            m_ptLocalTimeStamp[iCh]  = ptTimeStamps[iCh] + iNumberOfFrames/m_fSampleRate - (iSamplesInBuffer+iNumFramesLeft)/m_fSampleRate;

            // get data from ring bufffer and oncrement read pointer
            m_ppCRingBuffer[iCh]->GetOff (m_pfProcessBuffer, iProcessBlockSize, 0);
            m_ppCRingBuffer[iCh]->SetReadPos (m_ppCRingBuffer[iCh]->GetReadPos () + iHopSize);

            // calculation the number of zero crossings: pseudo: length(find((a(1:iBlockSize-1).*a(0:iBlockSize-2)) < 0))
            iTempResult = zplfZeroCrossings (m_pfProcessBuffer, iProcessBlockSize);

            // adjust time stamp and write result to output buffer
            this->WriteResult (iCh, iTempResult * 1.0F / iProcessBlockSize, m_ptLocalTimeStamp[iCh]);
        }
    }

    // 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];
            }
            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         CZeroCrossings::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      CZeroCrossings::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      CZeroCrossings::ResetPlugin ()
{
    for (int iCh = 0; iCh < this->GetPluginNumOfInputs (); iCh++)
    {
        m_ppCRingBuffer[iCh]->Reset ();
        m_ptLocalTimeStamp[iCh] = 0;
    }
    return FEAPI_kNoError;
}


float        CZeroCrossings::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_afParameters[kHopSize] * 0.001F * m_fSampleRate + .5F);
        }
    default:
        {
            // this shall never happen ...
            return -1;
        }
    }
    return -1;
}

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

    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;
}

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

FEAPI_ENTRY_POINTS(CZeroCrossings)

#ifdef __cplusplus                                                  
}                                                               
#endif

---