FEAPIPluginBase.h

Go to the documentation of this file.

//     /*! \file FEAPIPluginBase.h: \brief interface 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!!!

#if !defined(FEAPI_PLUGIN_BASE_HEADER_INCLUDED__)
#define FEAPI_PLUGIN_BASE_HEADER_INCLUDED__


#include <map>


class CPin
{

// Constructors and destructor

public: 
    CPin(const CPin& OtherPin);

    static CPin SetIndex(int iIndex);

    virtual ~CPin();


// Properties common to all kinds of pins

public:

    int GetIndex() const;

    CPin& SetName(const std::string& Name);

    const std::string& GetName() const;

    CPin& SetUnit(const std::string& Unit);

    const std::string& GetUnit() const;

    CPin& SetDescription(const std::string& Description);

    const std::string& GetDescription() const;

    CPin& SetRangeMin(float fRangeMin);
 
    float GetRangeMin() const;

    CPin& SetRangeMax(float fRangeMax);

    float GetRangeMax() const;


// Properties common to input and result pins only

public:

    CPin& SetSampleRate(float fSampleRate);

    float GetSampleRate() const;

    CPin& SetQuantizedTo(float fQuantizedTo);

    float GetQuantizedTo() const;


// Properties of parameter pins only

public:

    CPin& SetDefaultValue(float fDefaultValue);
    
    float GetDefaultValue() const;

    CPin& SetIsChangeableInRealTime(int bIsChangeableInRealTime);
    
    int GetIsChangeableInRealTime() const;

protected:

    CPin();

    CPin(int iIndex);

    void Copy(const CPin& OtherPin);

private:
    int m_iIndex;                       
    std::string m_Name;                 
    std::string m_Unit;                 
    std::string m_Description;          
    float m_fRangeMin;                  
    float m_fRangeMax;                  
    float m_fQuantizedTo;               
    float m_fSampleRate;                
    float m_fDefaultValue;              
    int m_bIsChangeableInRealTime;      

    // Friend classes
    friend class std::map<int, CPin>;
};


typedef std::map<int, CPin> PinMap;

class CFeatureExtractBase
{
public:

    CFeatureExtractBase ();
    
    virtual ~CFeatureExtractBase ();


    // method declaration


    static int                 GetPluginAPIVersion (FEAPI_VersionInfo_t eApiMajorMinorOrSubVersion);



    FEAPI_Error_t              InitializePlugin (   float               fInputSampleRate, 
                                                    int                 iNumberOfAudioChannels,
                                                    int                 iHostApiMajorVersion,
                                                    FEAPI_UserData_t     *pstUserData);

    FEAPI_Error_t              GetPluginName (     char *pcPluginName);

    FEAPI_Error_t              GetPluginVendor (   char *pcPluginVendor);

    virtual float              GetPluginProperty (  FEAPI_PluginProperty_t ePluginProperty) = 0;

    FEAPI_Error_t              GetPluginId (   char *pcPluginId);

    int                        GetPluginVendorVersion (FEAPI_VersionInfo_t ePluginMajorMinorOrSubVersion);

    FEAPI_Error_t              GetPluginDescription (char *pcPluginDescription);

    FEAPI_Error_t              GetPluginCopyright (char *pcPluginCopyright);

    int                        GetPluginNumOfInputs ();

    virtual FEAPI_Error_t      GetPluginInputDescription (  int                         iInputIndex, 
                                                            FEAPI_SignalDescription_t   *pstInputDescription);

    int                        GetPluginNumOfResults ();


    virtual FEAPI_Error_t      GetPluginResultDescription ( int                         iResultIndex, 
                                                            FEAPI_SignalDescription_t   *pstResultDescription);

    int                        GetPluginNumOfParameters ();

    virtual FEAPI_Error_t      GetPluginParameterDescription (  int                         iParameterIndex, 
                                                                FEAPI_ParameterDescription_t *pstParameterDescription);

    virtual FEAPI_Error_t      SetPluginParameter ( int     iParameterIndex, 
                                                    float   fValue);

    virtual float              GetPluginParameter (  int iParameterIndex);

    virtual FEAPI_Error_t      ProcessPlugin (  const FEAPI_Signal_t    **ppfInputBuffer, 
                                                const FEAPI_TimeStamp_t *ptFEAPI_TimeStamp,
                                                int                     iNumberOfFrames) = 0;


    virtual FEAPI_Error_t      ProcessPluginDone ();


    virtual int                GetPluginSizeOfResult (int iResultIndex) = 0;

    virtual FEAPI_Error_t      GetPluginResult (int                 iResultIndex, 
                                                float               *pfResult,
                                                FEAPI_TimeStamp_t   *ptFEAPI_TimeStamp) = 0;

    virtual int                GetPluginResultLatency (int iResultIndex);

    virtual FEAPI_Error_t      ResetPlugin ();


// Helper methods
protected:
    
    void SetPluginInputPinInfo(const CPin& PinInfo);

    void SetPluginResultPinInfo(const CPin& PinInfo);
    
    void SetPluginParameterPinInfo(const CPin& PinInfo);
    
protected:

    // member variables

    float   m_fSampleRate;                  

    int     m_iMajorVersion,                
            m_iMinorVersion,                
            m_iSubVersion;                  

    bool    m_bIsInitialized;           

    std::string m_cPluginName,           
                m_cPluginVendor,         
                m_cPluginId,             
                m_cPluginDescription,    
                m_cPluginCopyRight;      


    PinMap m_Inputs;            
    PinMap m_Results;           
    PinMap m_Parameters;        

};

#endif // #if !defined(FEAPI_PLUGIN_BASE_HEADER_INCLUDED__)

---