FEAPIExamplePluginFindMax.cpp

Go to the documentation of this file.

//     /*! \file FEAPIExamplePluginFindMax.cpp: \brief implementation of the CFindAbsoluteMax class. */
//
//        Copyright (c) 2004-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 <cstdlib>

#include "FEAPI.h"
#include "FEAPIExamplePluginFindMax.h"
#include "FEAPIEntryPoints.h"

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


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


// defines for plug in name etc.
#define _MY_PLUGIN_NAME        "zMaxFind"
#define _MY_PLUGIN_VENDOR      "zplane.development"
#define _MY_PLUGIN_DESCRIPTION "This PlugIn searches each input audio data block for its maximum value per channel"
#define _MY_PLUGIN_COPYRIGHT   "(c) 2004-2005 by zplane.development"
#define _MY_PLUGIN_ID          "MaxFindId"


// defines for description of result
#define _FEATURE_NAME           "Absolute Maximum Value"
#define _FEATURE_UNIT           "dBFS"
#define _FEATURE_DESCRIPTION    "The maximum absolute value of channel: %d per input block"
#define _FEATURE_RANGE_MIN      -740
#define _FEATURE_RANGE_MAX      0.0F
#define _FEATURE_QUANTIZED      -1  // value is not quantized
#define _FEATURE_SAMPLERATE     -1  // output sample rate equals input block length


CFindAbsoluteMax::CFindAbsoluteMax () : CFeatureExtractBase()
{
    // set of 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_pfMaxValue        = 0;
    m_pbIHaveResults    = 0;
    m_ptTimeStamp       = 0;
}


CFindAbsoluteMax::~CFindAbsoluteMax ()
{
    // destroy feature vector
    if (m_pfMaxValue)
        delete [] m_pfMaxValue;
    m_pfMaxValue        = 0;

    // destroy time stamp vector
    if (m_ptTimeStamp)
        delete [] m_ptTimeStamp;
    m_ptTimeStamp       = 0;

    // destroy bool vector
    if (m_pbIHaveResults)
        delete [] m_pbIHaveResults;
    m_pbIHaveResults    = 0;
}


FEAPI_Error_t      CFindAbsoluteMax::InitializePlugin (float               fInputSampleRate, 
                                                        int                 iNumberOfAudioChannels,
                                                        int                 iHostApiMajorVersion,
                                                        FEAPI_UserData_t     *pstUserData)
{
    CFeatureExtractBase::InitializePlugin ( fInputSampleRate, 
                                            iNumberOfAudioChannels,
                                            iHostApiMajorVersion,
                                            pstUserData);

    // Set information about the 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)
        );
    }
        
    // Set information about the results
    char acDescription[FEAPI_kMaxDescriptionLength];
    for (int k = 0; k < iNumberOfAudioChannels; ++k) {
        sprintf(acDescription, _FEATURE_DESCRIPTION, k);
        SetPluginResultPinInfo(CPin::SetIndex(k)
            .SetName(_FEATURE_NAME)
            .SetUnit(_FEATURE_UNIT)
            .SetDescription(acDescription)
            .SetRangeMin(_FEATURE_RANGE_MIN)
            .SetRangeMax(_FEATURE_RANGE_MAX)
            .SetQuantizedTo(_FEATURE_QUANTIZED)
            .SetSampleRate(_FEATURE_SAMPLERATE)
        );
    }

    // This plugin does not have any parameter

    // allocate one dimensional result/feature vector
    int iNumberOfResults = GetPluginNumOfResults();
    if (m_pfMaxValue)
        delete m_pfMaxValue;
    m_pfMaxValue        = new float [iNumberOfResults];
    if (m_ptTimeStamp)
        delete m_ptTimeStamp;
    m_ptTimeStamp       = new FEAPI_TimeStamp_t [iNumberOfResults];
    
    // allocate one dimensional result/feature vector
    if (m_pbIHaveResults)
        delete m_pbIHaveResults;
    m_pbIHaveResults    = new bool [iNumberOfResults];

    // initialize bool vector
    for (int i = 0; i < iNumberOfResults; i++)
        m_pbIHaveResults[i] = false;

    return FEAPI_kNoError;
}

FEAPI_Error_t      CFindAbsoluteMax::SetPluginParameter (int iParameterIndex, float fValue)
{
    // we don't have any parameters in this plugin
    return FEAPI_kUnknownError;
}


float       CFindAbsoluteMax::GetPluginParameter (int iParameterIndex)
{
    // we don't have any parameters in this plugin
    return -1;
}


int         CFindAbsoluteMax::GetPluginResultLatency (int iResultIndex)
{
    //<! \todo format???
    return 0;
}


FEAPI_Error_t      CFindAbsoluteMax::ProcessPluginDone ()
{
    // we don't have to do anything special here
    return FEAPI_kNoError;
}

FEAPI_Error_t      CFindAbsoluteMax::ProcessPlugin (const float **ppfInputBuffer, const FEAPI_TimeStamp_t *ptTimeStamps, int iNumberOfFrames)
{
    int iCh,
        iIdx;

    if (!m_bIsInitialized)
        return FEAPI_kUnspecifiedError;

    for (iCh = 0; iCh < GetPluginNumOfInputs(); iCh++)
    {
        m_pfMaxValue[iCh]   = 0.0F;
        for (iIdx = 0; iIdx < iNumberOfFrames; iIdx++)
        {
            float fAbsValue = fabsf (ppfInputBuffer[iCh][iIdx]);
            if (fAbsValue > m_pfMaxValue[iCh])
            {
                m_pfMaxValue[iCh]   = fAbsValue;
                m_ptTimeStamp[iCh]  = ptTimeStamps[iCh];
            }
        }
        m_pbIHaveResults[iCh]       = true;
    }

    return FEAPI_kNoError;
}

int         CFindAbsoluteMax::GetPluginSizeOfResult (int iResultIndex)
{
    if (iResultIndex >= GetPluginNumOfResults())
        return -1;

    if (m_pbIHaveResults[iResultIndex])
        return (sizeof(m_pfMaxValue[iResultIndex])/sizeof(float));
    else
        return 0;
}


FEAPI_Error_t      CFindAbsoluteMax::GetPluginResult (int iResultIndex, float *pfResult, FEAPI_TimeStamp_t *ptTimeStamp)
{
    if ((iResultIndex >= GetPluginNumOfResults()) || (!m_pbIHaveResults[iResultIndex]))
        return FEAPI_kUnknownError;

    if (m_pfMaxValue[iResultIndex] < 1e-37)
        m_pfMaxValue[iResultIndex]  = 1e-37F;
    *pfResult       = 20*logf(m_pfMaxValue[iResultIndex])/logf(10.0F);
 
    *ptTimeStamp    = m_ptTimeStamp[iResultIndex];

    m_pbIHaveResults[iResultIndex]  = false;
    
    return FEAPI_kNoError;
}


FEAPI_Error_t      CFindAbsoluteMax::ResetPlugin ()
{
    int i;

    for (i = 0; i < GetPluginNumOfResults(); i++)
    {
        m_pfMaxValue[i] = 0.0F;
        m_ptTimeStamp[i]= 0.0F;
    }
    return FEAPI_kNoError;
}


float        CFindAbsoluteMax::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(0.01F * m_fSampleRate + .5F);
        }
    default:
        {
            // this shall never happen ...
            return -1;
        }
    }
    return -1;
}


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

FEAPI_ENTRY_POINTS(CFindAbsoluteMax)

#ifdef __cplusplus                                                  
}                                                               
#endif

---