FEAPIPluginBase.cpp

Go to the documentation of this file.

//     /*! \file FEAPIPluginBase.cpp: \brief implementation of the CFeatureExtractBase 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.
//
//                      !!!Do never ever edit this file!!!


#include <string>

#include "FEAPI.h"
#include "FEAPIPluginBase.h"

#define _API_MAJOR_VERSION          0x00000001
#define _API_MINOR_VERSION          0x00000000
#define _API_SUB_VERSION            0x00000000


#define _DEFAULT_PLUG_MAJOR_VERSION 0x00000000
#define _DEFAULT_PLUG_MINOR_VERSION 0x00000000
#define _DEFAULT_PLUG_SUB_VERSION   0x00000000


#define _DEFAULT_PLUGIN_NAME        "Default Plugin Name"
#define _DEFAULT_PLUGIN_VENDOR      "Default Plugin Vendor"
#define _DEFAULT_PLUGIN_DESCRIPTION "This is the default plugin description"
#define _DEFAULT_PLUGIN_COPYRIGHT   "(c) default copyright information"
#define _DEFAULT_PLUGIN_ID          "Default Plugin Id"

#define _DEFAULT_NUM_PARAMETERS     0
#define _DEFAULT_NUM_RESULTS        0


static const float MinFloat = - float((1<<30)-1);
static const float MaxFloat = float((1<<30)-1);

// CPin implementation: construction, destruction, and copy

CPin::CPin()
:   m_iIndex(0),
    m_Name(),
    m_Unit(),
    m_Description(),
    m_fRangeMin(MinFloat),                  
    m_fRangeMax(MaxFloat),          
    m_fQuantizedTo(-1),
    m_fSampleRate(-1),
    m_fDefaultValue(0),     
    m_bIsChangeableInRealTime(1)
{
}
    
CPin::CPin(int iIndex)
:   m_iIndex(iIndex),
    m_Name(),
    m_Unit(),
    m_Description(),
    m_fRangeMin(MinFloat),                  
    m_fRangeMax(MaxFloat),          
    m_fQuantizedTo(-1),
    m_fSampleRate(-1),
    m_fDefaultValue(0),     
    m_bIsChangeableInRealTime(1)
{
}

CPin::CPin(const CPin& OtherPin)
{
    if (&OtherPin != this)
        Copy(OtherPin);
}

CPin::~CPin()
{
}

void CPin::Copy(const CPin& OtherPin)
{
    m_iIndex = OtherPin.m_iIndex;
    m_Name = OtherPin.m_Name;
    m_Unit = OtherPin.m_Unit;
    m_Description = OtherPin.m_Description;
    m_fRangeMin = OtherPin.m_fRangeMin;                 
    m_fRangeMax = OtherPin.m_fRangeMax; 
    m_fQuantizedTo = OtherPin.m_fQuantizedTo;
    m_fSampleRate = OtherPin.m_fSampleRate;
    m_fDefaultValue = OtherPin.m_fDefaultValue;
    m_bIsChangeableInRealTime = OtherPin.m_bIsChangeableInRealTime;
}


// CPin implementation: properties common to all kinds of pins

CPin CPin::SetIndex(int iIndex)
{
    return CPin(iIndex);
}

int CPin::GetIndex() const
{
    return m_iIndex;
}

CPin& CPin::SetName(const std::string& Name)
{
    m_Name = Name;
    return *this;
}

const std::string& CPin::GetName() const
{
    return m_Name;
}

CPin& CPin::SetUnit(const std::string& Unit)
{
    m_Unit = Unit;
    return *this;
}

const std::string& CPin::GetUnit() const
{
    return m_Unit;
}

CPin& CPin::SetDescription(const std::string& Description)
{
    m_Description = Description;
    return *this;
}

const std::string& CPin::GetDescription() const
{
    return m_Description;
}

CPin& CPin::SetRangeMin(float fRangeMin)
{
    m_fRangeMin = fRangeMin;
    return *this;
}

float CPin::GetRangeMin() const
{
    return m_fRangeMin;
}

CPin& CPin::SetRangeMax(float fRangeMax)
{
    m_fRangeMax = fRangeMax;
    return *this;
}

float CPin::GetRangeMax() const
{
    return m_fRangeMax;
}


// CPin implementation: input and result pins

CPin& CPin::SetQuantizedTo(float fQuantizedTo)
{
    m_fQuantizedTo = fQuantizedTo;
    return *this;
}

float CPin::GetQuantizedTo() const
{
    return m_fQuantizedTo;
}

CPin& CPin::SetSampleRate(float fSampleRate)
{
    m_fSampleRate = fSampleRate;
    return *this;
}

float CPin::GetSampleRate() const
{
    return m_fSampleRate;
}


// CPin implementation: parameter pins

CPin& CPin::SetDefaultValue(float fDefaultValue)
{
    m_fDefaultValue = fDefaultValue;
    return *this;
}
    
float CPin::GetDefaultValue() const
{
    return m_fDefaultValue;
}

CPin& CPin::SetIsChangeableInRealTime(int bIsChangeableInRealTime)
{
    m_bIsChangeableInRealTime = bIsChangeableInRealTime;
    return *this;
}
    
int CPin::GetIsChangeableInRealTime() const
{
    return m_bIsChangeableInRealTime;
}


// CFeatureExtractBase

CFeatureExtractBase::CFeatureExtractBase ()
{
    // initialize
    m_fSampleRate           = 0;

    m_bIsInitialized        = false;

    m_cPluginName           = _DEFAULT_PLUGIN_NAME;
    m_cPluginVendor         = _DEFAULT_PLUGIN_VENDOR;
    m_cPluginDescription    = _DEFAULT_PLUGIN_DESCRIPTION;
    m_cPluginId             = _DEFAULT_PLUGIN_ID;
    m_cPluginCopyRight      = _DEFAULT_PLUGIN_COPYRIGHT;

    m_iMajorVersion         = _DEFAULT_PLUG_MAJOR_VERSION;
    m_iMinorVersion         = _DEFAULT_PLUG_MINOR_VERSION;
    m_iSubVersion           = _DEFAULT_PLUG_SUB_VERSION;
}


CFeatureExtractBase::~CFeatureExtractBase ()
{
    m_bIsInitialized    = false;
    
    // Cleaning internal data structures
    m_Inputs.clear();
    m_Results.clear();
    m_Parameters.clear();
}


int  CFeatureExtractBase::GetPluginAPIVersion (FEAPI_VersionInfo_t iApiMajorMinorOrSubVersion)
{
    switch (iApiMajorMinorOrSubVersion)
    {
    case FEAPI_kMajorVersion:
        {
            return _API_MAJOR_VERSION;
        }
    case FEAPI_kMinorVersion:
        {
            return _API_MINOR_VERSION;
        }
    case FEAPI_kSubVersion:
        {
            return _API_SUB_VERSION;
        }
    default:
        {
            // this shall never happen ...
            return 0;
        }
    }
}


FEAPI_Error_t      CFeatureExtractBase::InitializePlugin (  float               fInputSampleRate, 
                                                            int                 iNumberOfAudioChannels,
                                                            int                 iHostApiMajorVersion,
                                                            FEAPI_UserData_t     *pstUserData)
{
    if ((fInputSampleRate <= 0) || (iNumberOfAudioChannels <= 0))
        return FEAPI_kUnspecifiedError;

    m_fSampleRate       = fInputSampleRate;

    m_bIsInitialized    = true;

    return FEAPI_kNoError;
}


FEAPI_Error_t      CFeatureExtractBase::GetPluginName (char *pcPluginName)
{
    if (!pcPluginName)
        return FEAPI_kUnspecifiedError;
    pcPluginName[m_cPluginName.copy (pcPluginName, FEAPI_kMaxNameLength-1)] = '\0';

    return FEAPI_kNoError;
}


FEAPI_Error_t      CFeatureExtractBase::GetPluginVendor (char *pcPluginVendor)
{
    if (!pcPluginVendor)
        return FEAPI_kUnspecifiedError;
    pcPluginVendor[m_cPluginVendor.copy (pcPluginVendor, FEAPI_kMaxNameLength-1)] = '\0';

    return FEAPI_kNoError;
}

FEAPI_Error_t      CFeatureExtractBase::GetPluginId (char *pcPluginId)
{
    if (!pcPluginId)
        return FEAPI_kUnspecifiedError;
    pcPluginId[m_cPluginId.copy (pcPluginId, FEAPI_kMaxNameLength-1)] = '\0';

    return FEAPI_kNoError;
}

int  CFeatureExtractBase::GetPluginVendorVersion (FEAPI_VersionInfo_t ePluginMajorMinorOrSubVersion)
{
    switch (ePluginMajorMinorOrSubVersion)
    {
    case FEAPI_kMajorVersion:
        {
            return m_iMajorVersion;
        }
    case FEAPI_kMinorVersion:
        {
            return m_iMinorVersion;
        }
    case FEAPI_kSubVersion:
        {
            return m_iSubVersion;
        }
    default:
        {
            // this shall never happen ...
            return -1;
        }
    }
}


FEAPI_Error_t      CFeatureExtractBase::GetPluginDescription (char *pcPluginDescription)
{
    if (!pcPluginDescription)
        return FEAPI_kUnspecifiedError;
    pcPluginDescription[m_cPluginDescription.copy (pcPluginDescription, FEAPI_kMaxDescriptionLength-1)] = '\0';

    return FEAPI_kNoError;
}


FEAPI_Error_t      CFeatureExtractBase::GetPluginCopyright (char *pcPluginCopyright)
{
    if (!pcPluginCopyright)
        return FEAPI_kUnspecifiedError;
    pcPluginCopyright[m_cPluginCopyRight.copy (pcPluginCopyright, FEAPI_kMaxDescriptionLength-1)] = '\0';

    return FEAPI_kNoError;
}


int         CFeatureExtractBase::GetPluginNumOfInputs ()
{   
    return int(m_Inputs.size());
}


FEAPI_Error_t      CFeatureExtractBase::GetPluginInputDescription (int iInputIndex, FEAPI_SignalDescription_t *pstInputDescription)
{
    if (pstInputDescription == 0) return FEAPI_kInvalidPointerError;
    if ((iInputIndex < 0) || (iInputIndex >= GetPluginNumOfInputs())) return FEAPI_kIndexOutOfRangeError;
    
    // The plugin has no inputs or SetInput was not used. In the latter case this function should be overridden in the plugin class.
    if (m_Inputs.empty()) return FEAPI_kUnspecifiedError;  

    pstInputDescription->acName[m_Inputs[iInputIndex].GetName().copy(pstInputDescription->acName, FEAPI_kMaxNameLength - 1)] = '\0';
    pstInputDescription->acUnit[m_Inputs[iInputIndex].GetUnit().copy(pstInputDescription->acUnit, FEAPI_kMaxUnitLength - 1)] = '\0';
    pstInputDescription->acDescription[m_Inputs[iInputIndex].GetDescription().copy(pstInputDescription->acDescription, FEAPI_kMaxDescriptionLength - 1)] = '\0';
    pstInputDescription->fRangeMin = m_Inputs[iInputIndex].GetRangeMin();
    pstInputDescription->fRangeMax = m_Inputs[iInputIndex].GetRangeMax();
    pstInputDescription->fQuantizedTo = m_Inputs[iInputIndex].GetQuantizedTo();
    pstInputDescription->fSampleRate = m_fSampleRate;
    
    return FEAPI_kNoError;
}


int         CFeatureExtractBase::GetPluginNumOfResults ()
{
    return int(m_Results.size());
}


FEAPI_Error_t      CFeatureExtractBase::GetPluginResultDescription (int iResultIndex, FEAPI_SignalDescription_t *pstResultDescription)
{
    if (pstResultDescription == 0) return FEAPI_kInvalidPointerError;
    if ((iResultIndex < 0) || (iResultIndex >= GetPluginNumOfResults())) return FEAPI_kIndexOutOfRangeError;
    
    // The plugin has no results or SetResult was not used. In the latter case this function should be overridden in the plugin class.
    if (m_Results.empty()) return FEAPI_kUnspecifiedError;

    pstResultDescription->acName[m_Results[iResultIndex].GetName().copy(pstResultDescription->acName, FEAPI_kMaxNameLength - 1)] = '\0';
    pstResultDescription->acUnit[m_Results[iResultIndex].GetUnit().copy(pstResultDescription->acUnit, FEAPI_kMaxUnitLength - 1)] = '\0';
    pstResultDescription->acDescription[m_Results[iResultIndex].GetDescription().copy(pstResultDescription->acDescription, FEAPI_kMaxDescriptionLength - 1)] = '\0';
    pstResultDescription->fRangeMin = m_Results[iResultIndex].GetRangeMin();
    pstResultDescription->fRangeMax = m_Results[iResultIndex].GetRangeMax();
    pstResultDescription->fQuantizedTo = m_Results[iResultIndex].GetQuantizedTo();
    pstResultDescription->fSampleRate = m_Results[iResultIndex].GetSampleRate();
    
    return FEAPI_kNoError;
}


int         CFeatureExtractBase::GetPluginNumOfParameters ()
{
    return int(m_Parameters.size());
}


FEAPI_Error_t      CFeatureExtractBase::GetPluginParameterDescription (int iParameterIndex, FEAPI_ParameterDescription_t *pstParameterDescription)
{
    if (pstParameterDescription == 0) return FEAPI_kInvalidPointerError;
    if ((iParameterIndex < 0) || (iParameterIndex >= GetPluginNumOfParameters())) return FEAPI_kIndexOutOfRangeError;
    
    // The plugin has no parameters or SetParameter was not used. In the latter case this function should be overridden in the plugin class.    
    if (m_Parameters.empty()) return FEAPI_kUnspecifiedError;

    pstParameterDescription->acName[m_Parameters[iParameterIndex].GetName().copy(pstParameterDescription->acName, FEAPI_kMaxNameLength - 1)] = '\0';
    pstParameterDescription->acUnit[m_Parameters[iParameterIndex].GetUnit().copy(pstParameterDescription->acUnit, FEAPI_kMaxUnitLength - 1)] = '\0';
    pstParameterDescription->acDescription[m_Parameters[iParameterIndex].GetDescription().copy(pstParameterDescription->acDescription, FEAPI_kMaxDescriptionLength - 1)] = '\0';
    pstParameterDescription->fRangeMin = m_Parameters[iParameterIndex].GetRangeMin();
    pstParameterDescription->fRangeMax = m_Parameters[iParameterIndex].GetRangeMax();
    pstParameterDescription->fDefaultValue = m_Parameters[iParameterIndex].GetDefaultValue();
    pstParameterDescription->fQuantizedTo = m_Parameters[iParameterIndex].GetQuantizedTo();
    pstParameterDescription->bIsChangeableInRealTime = m_Parameters[iParameterIndex].GetIsChangeableInRealTime();
    
    return FEAPI_kNoError;
}


FEAPI_Error_t      CFeatureExtractBase::SetPluginParameter (int iParameterIndex, float fValue)
{
    // inherit me!
    return FEAPI_kUnknownError;
}


float       CFeatureExtractBase::GetPluginParameter (int iParameterIndex)
{
    // inherit me!
    return -1;
}


FEAPI_Error_t      CFeatureExtractBase::ProcessPluginDone ()
{
    // inherit me!
    return FEAPI_kNoError;
}


int         CFeatureExtractBase::GetPluginResultLatency (int iResultIndex)
{
    // inherit me!
    return 0; 
}


FEAPI_Error_t      CFeatureExtractBase::ResetPlugin ()
{
    // inherit me!
    return FEAPI_kNoError;
}


// CFeatureExtractBase implementation: helper methods
    
void CFeatureExtractBase::SetPluginInputPinInfo(const CPin& PinInfo)
{
    m_Inputs[PinInfo.GetIndex()] = PinInfo;
}

void CFeatureExtractBase::SetPluginResultPinInfo(const CPin& PinInfo)
{
    m_Results[PinInfo.GetIndex()] = PinInfo;
}
    
void CFeatureExtractBase::SetPluginParameterPinInfo(const CPin& PinInfo)
{
    m_Parameters[PinInfo.GetIndex()] = PinInfo;
}

---