FEAPIEntryPoints.h

Go to the documentation of this file.

//     /*! \file FEAPIEntryPoints.h: \brief wrapped C interface of C++-plugin API */
//
//        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.
//

#ifdef WIN32
#define FEAPI_API __declspec(dllexport)                             
#else                                                               
#define FEAPI_API extern                                            
#endif                                                              

#define FEAPI_ENTRY_POINTS(theFEAPIPluginClass)                     \
                                                                    \
                                                                    \
FEAPI_API unsigned int     FEAPI_GetPluginAPIVersion (FEAPI_VersionInfo_t iApiMajorMinorOrSubVersion)        \
{                                                                   \
    return theFEAPIPluginClass::GetPluginAPIVersion (iApiMajorMinorOrSubVersion);                   \
}                                                                   \
                                                                    \
                                                                    \
FEAPI_API FEAPI_Error_t  FEAPI_GetPluginName (  FEAPI_PluginInstance_t hInstanceHandle,             \
                                                char *pcPluginName) \
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    if (hInstanceHandle == 0)                                       \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
    pCPluginInstance      = (theFEAPIPluginClass*)hInstanceHandle;  \
                                                                    \
    return pCPluginInstance->GetPluginName ( pcPluginName );        \
                                                                    \
}                                                                   \
                                                                    \
                                                                    \
FEAPI_API FEAPI_Error_t  FEAPI_GetPluginVendor (FEAPI_PluginInstance_t hInstanceHandle,             \
                                                char *pcPluginVendor)                               \
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    if (hInstanceHandle == 0)                                       \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
    pCPluginInstance      = (theFEAPIPluginClass*)hInstanceHandle;  \
                                                                    \
    return pCPluginInstance->GetPluginVendor ( pcPluginVendor );    \
                                                                    \
}                                                                   \
                                                                    \
                                                                    \
FEAPI_API FEAPI_Error_t  FEAPI_GetPluginId (    FEAPI_PluginInstance_t hInstanceHandle,             \
                                                char *pcPluginId)   \
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    if (hInstanceHandle == 0)                                       \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
    pCPluginInstance      = (theFEAPIPluginClass*)hInstanceHandle;  \
                                                                    \
    return pCPluginInstance->GetPluginId ( pcPluginId );            \
                                                                    \
}                                                                   \
                                                                    \
                                                                    \
FEAPI_API unsigned int     FEAPI_GetPluginVendorVersion (FEAPI_PluginInstance_t hInstanceHandle,             \
                                                FEAPI_VersionInfo_t iApiMajorMinorOrSubVersion)     \
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    /* check for invalid structure pointer*/                        \
    if (hInstanceHandle == 0)                                       \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
    /* set handle to instance */                                    \
    pCPluginInstance      = (theFEAPIPluginClass*)hInstanceHandle;  \
                                                                    \
    return pCPluginInstance->GetPluginVendorVersion (iApiMajorMinorOrSubVersion);                   \
                                                                    \
}                                                                   \
                                                                    \
                                                                    \
FEAPI_API FEAPI_Error_t  FEAPI_GetPluginDescription (   FEAPI_PluginInstance_t hInstanceHandle,     \
                                                        char *pcPluginDescription)                  \
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    /* check for invalid structure pointer */                       \
    if (hInstanceHandle == 0)                                       \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
    /* set handle to instance */                                    \
    pCPluginInstance      = (theFEAPIPluginClass*)hInstanceHandle;  \
                                                                    \
    return pCPluginInstance->GetPluginDescription ( pcPluginDescription );                          \
                                                                    \
}                                                                   \
                                                                    \
                                                                    \
FEAPI_API FEAPI_Error_t  FEAPI_GetPluginCopyright ( FEAPI_PluginInstance_t hInstanceHandle,         \
                                                    char *pcPluginCopyright)                        \
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    /* check for invalid structure pointer */                       \
    if (hInstanceHandle == 0)                                       \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
    /* set handle to instance */                                    \
    pCPluginInstance      = (theFEAPIPluginClass*)hInstanceHandle;  \
                                                                    \
    return pCPluginInstance->GetPluginCopyright ( pcPluginCopyright );                              \
                                                                    \
}                                                                   \
                                                                    \
                                                                    \
FEAPI_API unsigned int     FEAPI_GetPluginNumOfResults (FEAPI_PluginInstance_t hInstanceHandle)              \
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    /* check for invalid structure pointer */                       \
    if (hInstanceHandle == 0)                                       \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
    /* set handle to instance */                                    \
    pCPluginInstance      = (theFEAPIPluginClass*)hInstanceHandle;  \
                                                                    \
    return pCPluginInstance->GetPluginNumOfResults ( );             \
                                                                    \
}                                                                   \
                                                                    \
                                                                    \
FEAPI_API FEAPI_Error_t  FEAPI_GetPluginResultDescription ( FEAPI_PluginInstance_t hInstanceHandle, \
                                                            int iResultIndex,                       \
                                                            FEAPI_SignalDescription_t *pstResultDescription)\
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    /* check for invalid structure pointer  */                      \
    if (hInstanceHandle == 0)                                       \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
    /* set handle to instance       */                              \
    pCPluginInstance      = (theFEAPIPluginClass*)hInstanceHandle;  \
                                                                    \
    return pCPluginInstance->GetPluginResultDescription (   iResultIndex,                           \
                                                    pstResultDescription);                          \
                                                                    \
}                                                                   \
                                                                    \
                                                                    \
FEAPI_API unsigned int     FEAPI_GetPluginNumOfInputs (FEAPI_PluginInstance_t hInstanceHandle)               \
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    /* check for invalid structure pointer*/                        \
    if (hInstanceHandle == 0)                                       \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
    /* set handle to instance   */                                  \
    pCPluginInstance      = (theFEAPIPluginClass*)hInstanceHandle;  \
                                                                    \
    return pCPluginInstance->GetPluginNumOfInputs ();               \
                                                                    \
}                                                                   \
                                                                    \
                                                                    \
FEAPI_API FEAPI_Error_t  FEAPI_GetPluginInputDescription (  FEAPI_PluginInstance_t hInstanceHandle, \
                                                            int iInputIndex,                        \
                                                            FEAPI_SignalDescription_t *pstInputDescription)\
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    if (hInstanceHandle == 0)                                       \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
    pCPluginInstance      = (theFEAPIPluginClass*)hInstanceHandle;  \
                                                                    \
    return pCPluginInstance->GetPluginInputDescription (    iInputIndex,                            \
                                                    pstInputDescription);                           \
                                                                    \
}                                                                   \
                                                                    \
                                                                    \
FEAPI_API unsigned int     FEAPI_GetPluginNumOfParameters (FEAPI_PluginInstance_t hInstanceHandle)           \
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    if (hInstanceHandle == 0)                                       \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
    pCPluginInstance      = (theFEAPIPluginClass*)hInstanceHandle;  \
                                                                    \
    return pCPluginInstance->GetPluginNumOfParameters ( );          \
                                                                    \
}                                                                   \
                                                                    \
                                                                    \
FEAPI_API FEAPI_Error_t  FEAPI_GetPluginParameterDescription (  FEAPI_PluginInstance_t hInstanceHandle,\
                                                                int iParameterIndex,                \
                                                                FEAPI_ParameterDescription_t *pstParameterDescription)\
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    if (hInstanceHandle == 0)                                       \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
    pCPluginInstance      = (theFEAPIPluginClass*)hInstanceHandle;  \
                                                                    \
    return pCPluginInstance->GetPluginParameterDescription (    iParameterIndex,                    \
                                                                pstParameterDescription);           \
                                                                    \
}                                                                   \
                                                                    \
                                                                    \
FEAPI_API FEAPI_Error_t  FEAPI_SetPluginParameter ( FEAPI_PluginInstance_t hInstanceHandle,         \
                                                    int iParameterIndex,                            \
                                                    float fValue)   \
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    if (hInstanceHandle == 0)                                       \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
    pCPluginInstance      = (theFEAPIPluginClass*)hInstanceHandle;  \
                                                                    \
    return pCPluginInstance->SetPluginParameter (   iParameterIndex,\
                                                    fValue);        \
                                                                    \
}                                                                   \
                                                                    \
                                                                    \
FEAPI_API float   FEAPI_GetPluginParameter (    FEAPI_PluginInstance_t hInstanceHandle,             \
                                                int iParameterIndex)\
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    if (hInstanceHandle == 0)                                       \
        return 1e38F;                                               \
                                                                    \
    pCPluginInstance      = ( theFEAPIPluginClass*)hInstanceHandle; \
                                                                    \
    return pCPluginInstance->GetPluginParameter ( iParameterIndex );\
                                                                    \
}                                                                   \
                                                                    \
                                                                    \
                                                                    \
FEAPI_API int FEAPI_GetPluginResultLatency (    FEAPI_PluginInstance_t hInstanceHandle,             \
                                                int iResultIndex)   \
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    if (hInstanceHandle == 0)                                       \
        return 0;                                                   \
                                                                    \
    pCPluginInstance      = (theFEAPIPluginClass*)hInstanceHandle;  \
                                                                    \
    return pCPluginInstance->GetPluginResultLatency (iResultIndex); \
                                                                    \
}                                                                   \
                                                                    \
                                                                    \
FEAPI_API FEAPI_Error_t  FEAPI_ProcessPlugin (  FEAPI_PluginInstance_t hInstanceHandle,             \
                                                const float **ppfInputBuffer,                       \
                                                const FEAPI_TimeStamp_t *pfTimeStamps,              \
                                                int iNumberOfFrames)\
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    if (hInstanceHandle == 0)                                       \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
    pCPluginInstance      = (theFEAPIPluginClass*)hInstanceHandle;  \
                                                                    \
    return pCPluginInstance->ProcessPlugin (    ppfInputBuffer,     \
                                        pfTimeStamps,               \
                                        iNumberOfFrames);           \
                                                                    \
}                                                                   \
                                                                    \
                                                                    \
FEAPI_API FEAPI_Error_t  FEAPI_ProcessPluginDone (FEAPI_PluginInstance_t hInstanceHandle)           \
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    if (hInstanceHandle == 0)                                       \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
    pCPluginInstance      = (theFEAPIPluginClass*)hInstanceHandle;  \
                                                                    \
    return pCPluginInstance->ProcessPluginDone ( );                 \
                                                                    \
}                                                                   \
                                                                    \
                                                                    \
                                                                    \
FEAPI_API int     FEAPI_GetPluginSizeOfResult ( FEAPI_PluginInstance_t hInstanceHandle,             \
                                                int iResultIndex)   \
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    if (hInstanceHandle == 0)                                       \
        return -1;                                                  \
                                                                    \
    pCPluginInstance      = (theFEAPIPluginClass*)hInstanceHandle;  \
                                                                    \
    return pCPluginInstance->GetPluginSizeOfResult ( iResultIndex );\
                                                                    \
}                                                                   \
                                                                    \
                                                                    \
FEAPI_API FEAPI_Error_t FEAPI_GetPluginResult ( FEAPI_PluginInstance_t hInstanceHandle,             \
                                                int iResultIndex,   \
                                                float *pfResult,    \
                                                FEAPI_TimeStamp_t *ptTimeStamp)                     \
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    if (hInstanceHandle == 0)                                       \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
    pCPluginInstance      = (theFEAPIPluginClass*)hInstanceHandle;  \
                                                                    \
    return pCPluginInstance->GetPluginResult (  iResultIndex,       \
                                        pfResult,                   \
                                        ptTimeStamp);               \
                                                                    \
}                                                                   \
                                                                    \
                                                                    \
FEAPI_API float FEAPI_GetPluginProperty (   FEAPI_PluginInstance_t hInstanceHandle,                 \
                                            FEAPI_PluginProperty_t ePluginProperty,                 \
                                            float  fValue)          \
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    if (hInstanceHandle == 0)                                       \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
    pCPluginInstance      = (theFEAPIPluginClass*)hInstanceHandle;  \
                                                                    \
    return pCPluginInstance->GetPluginProperty (  ePluginProperty); \
                                                                    \
}                                                                   \
                                                                    \
                                                                    \
                                                                    \
FEAPI_API FEAPI_Error_t  FEAPI_ResetPlugin (FEAPI_PluginInstance_t hInstanceHandle)                 \
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    if (hInstanceHandle == 0)                                       \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
    pCPluginInstance      = (theFEAPIPluginClass*)hInstanceHandle;  \
                                                                    \
    return pCPluginInstance->ResetPlugin ( );                       \
                                                                    \
}                                                                   \
                                                                    \
                                                                    \
FEAPI_API FEAPI_Error_t FEAPI_InitializePlugin (FEAPI_PluginInstance_t hInstanceHandle,             \
                                                float fInputSampleRate,                             \
                                                int iNumberOfAudioChannels,                         \
                                                int iHostApiMajorVersion,                           \
                                                FEAPI_UserData_t *pstUserData)                      \
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    if (hInstanceHandle == 0)                                       \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
    pCPluginInstance      = (theFEAPIPluginClass*)hInstanceHandle;  \
                                                                    \
    /* check for correct API major version*/                        \
    if (iHostApiMajorVersion != CFeatureExtractBase::GetPluginAPIVersion (FEAPI_kMajorVersion))     \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
                                                                    \
    return pCPluginInstance->InitializePlugin (   fInputSampleRate, \
                                                iNumberOfAudioChannels,                             \
                                                iHostApiMajorVersion,                               \
                                                pstUserData);       \
}                                                                   \
                                                                    \
                                                                    \
FEAPI_API FEAPI_Error_t FEAPI_CreatePluginInstance ( FEAPI_PluginInstance_t *phInstanceHandle)      \
{                                                                   \
    theFEAPIPluginClass   *pCPluginInstance     = 0;                \
                                                                    \
    if (phInstanceHandle == 0)                                      \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
    /* create new FEAPI_in instance */                              \
    pCPluginInstance  = new theFEAPIPluginClass ();                 \
                                                                    \
    if (pCPluginInstance == 0)                                      \
        return FEAPI_kUnspecifiedError;                             \
    else                                                            \
    {                                                               \
        *phInstanceHandle      = (void*) pCPluginInstance;          \
    }                                                               \
                                                                    \
    return FEAPI_kNoError;                                          \
}                                                                   \
                                                                    \
FEAPI_API FEAPI_Error_t   FEAPI_DestroyPluginInstance (FEAPI_PluginInstance_t *phInstanceHandle)        \
{                                                                   \
    theFEAPIPluginClass  *pCPluginInstance  = (theFEAPIPluginClass*) *phInstanceHandle;                 \
                                                                    \
    if (pCPluginInstance == 0)                                      \
        return FEAPI_kUnspecifiedError;                             \
                                                                    \
    delete pCPluginInstance;                                        \
                                                                    \
    /* reset instance handle    */                                  \
    *phInstanceHandle   = 0;                                        \
                                                                    \
    return FEAPI_kNoError;                                          \
                                                                    \
}

---