sound4.impactfm.cl.h

Go to the documentation of this file.

 
#pragma once
 
#ifdef __unix__
    #include <sys/types.h>
    #define IMPACTFM_DECL       __attribute__ ((visibility ("default")))
#elif defined(_WIN32) || defined(WIN32)
    #include <windows.h>
    #ifdef BUILDING_IMPACTFM_DLL
        #define IMPACTFM_DECL   __declspec(dllexport)
    #else
        #define IMPACTFM_DECL   __declspec(dllimport)
    #endif
    #ifdef _MSC_VER
        #pragma warning(disable : 4996)
    #endif
#elif defined(__APPLE__)
    #include <sys/types.h>
    #define IMPACTFM_DECL       __attribute__ ((visibility ("default")))
#endif
#include <stdint.h>
 
#define IMPACTFM_HAS_WEBSERVER 1
#define IMPACTFM_HAS_CLOUDBUS 0
 
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
 
// --------------------------------------------------------------
#define IMPACTFM_AUDIOFRAME_COUNT      64
#define IMPACTFM_CHANNEL_COUNT          2
#define IMPACTFM_AUDIO_INPUT_COUNT      1
#define IMPACTFM_AUDIO_OUTPUT_COUNT     1
#define IMPACTFM_SAMPLE_RATE            48000
 
struct SOUND4_ProcessInfo {
    size_t struct_size;         
    const char *name;           
    const char *prefix;         
    const char *shortname;      
    const char *version;        
};
 
IMPACTFM_DECL const struct SOUND4_ProcessInfo* SOUND4_GetProcessInfo();
 
IMPACTFM_DECL const char *impactfm_GetVersion();
 
IMPACTFM_DECL unsigned int impactfm_GetChunkSizeInFrames();
 
IMPACTFM_DECL unsigned int* impactfm_GetPossibleChunkSizeInFrames();
 
IMPACTFM_DECL unsigned int impactfm_GetChannelCount();
 
IMPACTFM_DECL unsigned int impactfm_GetAudioInputCount();
 
IMPACTFM_DECL unsigned int impactfm_GetAudioOutputCount();
 
IMPACTFM_DECL unsigned int impactfm_GetSampleRate();
 
enum impactfm_LogSeverity {
    none     = 0,      
    fatal    = 1,      
    error    = 2,      
    warning  = 3,      
    info     = 4,      
    verbose  = 5,      
    verbose2 = 6,      
    verbose3 = 7,      
    verbose4 = 8,      
    verbose5 = 9,      
};
 
typedef void (*impactfm_loggerfn) (enum impactfm_LogSeverity, const char *);
 
IMPACTFM_DECL void impactfm_SetLoggerCallback( impactfm_loggerfn logger );
 
IMPACTFM_DECL void impactfm_SetLogSeverity( enum impactfm_LogSeverity severity );
 
// --------------------------------------------------------------
// --------------------------------------------------------------
struct impactfm_CInstance;
 
struct impactfm_CParameters;
 
IMPACTFM_DECL struct impactfm_CParameters *impactfm_NewParameters();
 
IMPACTFM_DECL void impactfm_FreeParameters(struct impactfm_CParameters *params);
 
IMPACTFM_DECL void impactfm_SetParameter(struct impactfm_CParameters *params, const char *name, const char *value);
 
IMPACTFM_DECL const char *impactfm_GetParameter(struct impactfm_CParameters *params, const char *name);
 
IMPACTFM_DECL void impactfm_FreeParameterValue(const char *value);
 
IMPACTFM_DECL struct impactfm_CInstance *impactfm_InitProcess(
        const char *LoginKey,
        const char *RadioName,
        const char *Access_Key_ID,
        const char *Access_Key_Secret,
        const char *save_path
    );
 
IMPACTFM_DECL struct impactfm_CInstance *impactfm_InitProcess2(
        const char *LoginKey,
        const char *RadioName,
        const char *Access_Key_ID,
        const char *Access_Key_Secret,
        const char *save_path,
        const struct impactfm_CParameters *parameters
    );
 
IMPACTFM_DECL struct impactfm_CInstance *impactfm_InitProcess3(
        const char *LoginKey,
        const char *RadioName,
        const char *Access_Key_ID,
        const char *Access_Key_Secret,
        const char *save_path,
        const struct impactfm_CParameters *parameters,
        unsigned int frames_per_chunk
    );
 
IMPACTFM_DECL unsigned int impactfm_GetProcessChunkFrames(struct impactfm_CInstance *instance);
 
IMPACTFM_DECL int impactfm_TerminateProcess(struct impactfm_CInstance *instance);
 
IMPACTFM_DECL void impactfm_ExitProcess(struct impactfm_CInstance *instance);
 
#if IMPACTFM_HAS_CLOUDBUS
// --------------------------------------------------------------
struct impactfm_CBus;
 
IMPACTFM_DECL struct impactfm_CBus* impactfm_NewBus();
 
IMPACTFM_DECL void impactfm_FreeBus(struct impactfm_CBus *bus);
 
IMPACTFM_DECL void impactfm_SetInstanceBus(struct impactfm_CParameters *params, struct impactfm_CBus *bus);
 
 
#endif // IMPACTFM_HAS_CLOUDBUS
 
// --------------------------------------------------------------
//   Tracing (Windows only)
// --------------------------------------------------------------
#ifdef _WIN32
#ifndef TLG_HAVE_EVENT_SET_INFORMATION // TraceLoggingProvider.h has not been included
    struct _tlgProvider_t;
    typedef struct _tlgProvider_t const* TraceLoggingHProvider;
#endif // !TLG_HAVE_EVENT_SET_INFORMATION
// --------------------------------------------------------------
IMPACTFM_DECL void impactfm_SetInstanceTracing(struct impactfm_CParameters *params, TraceLoggingHProvider tracing_provider, GUID activity_guid);
 
IMPACTFM_DECL void impactfm_SetInstanceTracingProcessActivity(struct impactfm_CInstance *instance, GUID activity_guid);
 
#endif // _WIN32
 
// --------------------------------------------------------------
// --------------------------------------------------------------
 
// OS dependent filesystem path char type
#ifdef _WIN32
    typedef wchar_t fs_char;
#else // !_WIN32
    typedef char fs_char;
#endif // !_WIN32
 
typedef char * (*impactfm_storage_reader) (const fs_char *filename, void* userdata);
 
typedef void (*impactfm_storage_reader_free) (char *content, void* userdata);
 
typedef int (*impactfm_storage_writer) (const fs_char *filename, const char *content, void* userdata);
 
typedef int (*impactfm_storage_exists) (const fs_char *filename, void* userdata);
 
typedef fs_char** (*impactfm_storage_getall) (void* userdata);
 
typedef void (*impactfm_storage_getall_free) (fs_char**all, void* userdata);
 
typedef int (*impactfm_storage_remove) (const fs_char *filename, void* userdata);
 
typedef int (*impactfm_storage_rename) (const fs_char *from, const fs_char *to, void* userdata);
 
IMPACTFM_DECL void impactfm_SetPresetManager(struct impactfm_CParameters *params
    , impactfm_storage_reader reader, impactfm_storage_reader_free
    , impactfm_storage_writer writer
    , impactfm_storage_exists exists
    , impactfm_storage_getall getall, impactfm_storage_getall_free getall_free
    , impactfm_storage_remove remove
    , impactfm_storage_rename rename
    , int IsReadOnly
    , void* userdata
    );
 
enum impactfm_PresetChange_Kind {
    change_kind_created = 1,    
    change_kind_modified   ,    
    change_kind_deleted    ,    
};
 
IMPACTFM_DECL void impactfm_PresetManager_InformChange(struct impactfm_CInstance *instance, const fs_char *relative_path, enum impactfm_PresetChange_Kind change_kind);
 
// --------------------------------------------------------------
// --------------------------------------------------------------
 
IMPACTFM_DECL void impactfm_SetMetadata(struct impactfm_CInstance *instance, const char* key, const char* value);
 
IMPACTFM_DECL void impactfm_SetMetadataMulti(struct impactfm_CInstance *instance, const char** keyvalue);
 
IMPACTFM_DECL const char** impactfm_GetMetadataInfos(struct impactfm_CInstance *instance);
 
IMPACTFM_DECL void impactfm_FreeMetadataInfos(struct impactfm_CInstance *instance, const char** infos);
 
// --------------------------------------------------------------
// --------------------------------------------------------------
 
IMPACTFM_DECL void impactfm_StartUpdateThread(struct impactfm_CInstance *instance, unsigned int port);
 
IMPACTFM_DECL void impactfm_StopUpdateThread(struct impactfm_CInstance *instance);
 
IMPACTFM_DECL int impactfm_WaitUpdateThreadReady(struct impactfm_CInstance *instance, int milliseconds);
 
// --------------------------------------------------------------
// --------------------------------------------------------------
IMPACTFM_DECL void impactfm_ProcessAudio(struct impactfm_CInstance *instance, const float *input, float *output );
 
IMPACTFM_DECL void impactfm_ProcessAudio_Planar(struct impactfm_CInstance *instance
    , float const * const *input
    , float * const *output);
 
IMPACTFM_DECL float *impactfm_GetBufferIn(struct impactfm_CInstance *instance);
 
IMPACTFM_DECL float *impactfm_GetBufferOut(struct impactfm_CInstance *instance);
 
IMPACTFM_DECL unsigned int impactfm_GetEstimatedDelay(struct impactfm_CInstance *instance);
 
// --------------------------------------------------------------
// --------------------------------------------------------------
struct SOUND4_AuxiliaryOutputInfos {
    char *id;             
    char *description;    
    unsigned int sample_rate;   
    unsigned int channel_count; 
    const float *buffer;        
};
 
IMPACTFM_DECL struct SOUND4_AuxiliaryOutputInfos** impactfm_GetAuxiliaryAudioOutputInfos(struct impactfm_CInstance *instance);
 
IMPACTFM_DECL void impactfm_FreeAuxiliaryAudioInfos(struct SOUND4_AuxiliaryOutputInfos** infos);
 
IMPACTFM_DECL int impactfm_ActivateAuxiliaryAudioID(struct impactfm_CInstance *instance, const char* id);
 
IMPACTFM_DECL unsigned int impactfm_GetAuxiliaryAudioEstimatedDelay(struct impactfm_CInstance *instance, const char* id);
 
// --------------------------------------------------------------
// --------------------------------------------------------------
    #ifdef _MSC_VER
        #define __BYTE_ORDER__  REG_DWORD
        #define __ORDER_LITTLE_ENDIAN__ REG_DWORD_LITTLE_ENDIAN
        #define __ORDER_BIG_ENDIAN__    REG_DWORD_BIG_ENDIAN
    #endif
 
enum impactfm_SampleFormat {
    INVALID_FORMAT=0,       
    S16_LE,                 
    S16_BE,                 
    S24_LE,                 
    S24_BE,                 
    S32_LE,                 
    S32_BE,                 
    F32_LE,                 
    F32_BE,                 
 
    // Native definitions, only links to the physical ones
    #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
        S16_NATIVE=S16_LE,  
        S24_NATIVE=S24_LE,  
        S32_NATIVE=S32_LE,  
        F32_NATIVE=F32_LE,  
    #else
        S16_NATIVE=S16_BE,  
        S24_NATIVE=S24_BE,  
        S32_NATIVE=S32_BE,  
        F32_NATIVE=F32_BE,  
    #endif
};
 
IMPACTFM_DECL const char *impactfm_GetFormatName(const enum impactfm_SampleFormat fmt);
 
IMPACTFM_DECL enum impactfm_SampleFormat impactfm_GetFormatFromName(const char *name);
 
IMPACTFM_DECL unsigned int impactfm_GetBytesFromFormat(const enum impactfm_SampleFormat fmt);
 
 
IMPACTFM_DECL unsigned int impactfm_GetMaxPacketFrame(struct impactfm_CInstance *instance);
 
IMPACTFM_DECL unsigned int impactfm_AddAudio(struct impactfm_CInstance *instance, const uint8_t *payload, unsigned int nFrame, enum impactfm_SampleFormat fmt );
 
IMPACTFM_DECL unsigned int impactfm_AddPadAudio(struct impactfm_CInstance *instance);
 
IMPACTFM_DECL unsigned int impactfm_GetOutputCount(struct impactfm_CInstance *instance);
 
IMPACTFM_DECL unsigned int impactfm_GetAudio(struct impactfm_CInstance *instance, uint8_t *payload, unsigned int max_nFrame, enum impactfm_SampleFormat fmt );
 
// --------------------------------------------------------------
// --------------------------------------------------------------
IMPACTFM_DECL void impactfm_AudioConvertFrom(const uint8_t *payload, float *output, size_t nSpl, enum impactfm_SampleFormat fmt);
 
IMPACTFM_DECL void impactfm_AudioConvertTo(const float *input, uint8_t *payload, size_t nSpl, enum impactfm_SampleFormat fmt);
 
IMPACTFM_DECL void impactfm_StereoToMono(const float *input, float *output, size_t nFrame);
 
IMPACTFM_DECL void impactfm_MonoToStereo(const float *input, float *output, size_t nFrame);
 
IMPACTFM_DECL void impactfm_StereoToMono_Planar(const float *inputL, const float *inputR, float *output, size_t nFrame);
 
IMPACTFM_DECL void impactfm_MonoToStereo_Planar(const float *input, float *outputL, float *outputR, size_t nFrame);
 
IMPACTFM_DECL void impactfm_AudioMonoFromLiveStereo(const uint8_t *payload, float *output);
 
IMPACTFM_DECL void impactfm_AudioMonoToLiveStereo(const float *input, uint8_t *payload);
 
struct impactfm_CAudioConverter;
 
enum impactfm_ConverterTargetMode {
    ConverterTargetMode_AsInput = 0,    
    ConverterTargetMode_Mono,           
    ConverterTargetMode_Stereo,         
    ConverterTargetMode_StereoToMono,   
    ConverterTargetMode_MonoToStereo,   
};
 
IMPACTFM_DECL struct impactfm_CAudioConverter* impactfm_GetAudioConverter(enum impactfm_SampleFormat fmt, size_t nFrame
    , size_t payl_ch, size_t payl_ch_offset
    , enum impactfm_ConverterTargetMode target_mode);
 
IMPACTFM_DECL void impactfm_FreeAudioConverter(struct impactfm_CAudioConverter *converter);
 
IMPACTFM_DECL void impactfm_AudioConverter_From(struct impactfm_CAudioConverter *converter, const uint8_t *payload, float *output);
 
IMPACTFM_DECL void impactfm_AudioConverter_To(struct impactfm_CAudioConverter *converter, const float *input, uint8_t *payload);
 
// --------------------------------------------------------------
// --------------------------------------------------------------
struct impactfm_CClientInstance;
 
IMPACTFM_DECL struct impactfm_CClientInstance *impactfm_NewClient(struct impactfm_CInstance *instance);
 
IMPACTFM_DECL void impactfm_DeleteClient(struct impactfm_CClientInstance *client);
 
IMPACTFM_DECL const char *impactfm_ProcessJson(struct impactfm_CClientInstance *client, const char *json_str, int *need_save);
 
IMPACTFM_DECL void impactfm_FreeJsonAnswer(const char *json_str);
 
IMPACTFM_DECL int impactfm_SaveState(struct impactfm_CInstance *instance);
 
#if IMPACTFM_HAS_WEBSERVER
// --------------------------------------------------------------
// --------------------------------------------------------------
IMPACTFM_DECL uint64_t impactfm_Webserver_tcp(unsigned int listenport, unsigned int listenport_secure, const char *socket_ip, unsigned int socket_port);
 
// --------------------------------------------------------------
IMPACTFM_DECL uint64_t impactfm_Webserver_tcp2(unsigned int listenport, unsigned int listenport_secure, const char *socket_ip, unsigned int socket_port, const struct impactfm_CParameters *parameters);
 
IMPACTFM_DECL uint64_t impactfm_Webserver(unsigned int listenport, unsigned int listenport_secure, struct impactfm_CInstance *instance);
 
IMPACTFM_DECL int impactfm_Webserver_Stop(uint64_t id, int timeout_ms);
 
IMPACTFM_DECL int impactfm_Webserver_Status(uint64_t id);
 
IMPACTFM_DECL void impactfm_Webserver_SetAppHealth(struct impactfm_CInstance *instance, int httpcode, const char *contenttype, const char *content);
 
IMPACTFM_DECL void impactfm_Webserver_GetAppHealth(struct impactfm_CInstance *instance, int* httpcode, char** contenttype, char** content);
 
IMPACTFM_DECL void impactfm_Webserver_FreeString(char *str);
 
#define SOUND4_INVALID_WEBSERVER_ID            ((uint64_t)-1)
 
#define SOUND4_WEBSERVER_HTTP_OK               (1<<0)
#define SOUND4_WEBSERVER_HTTPS_OK              (1<<1)
 
#endif // IMPACTFM_HAS_WEBSERVER
 
#ifdef __cplusplus
} // extern "C"
#endif // __cplusplus