sound4cl.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <exception>
#include <thread>
#include <functional>
#include <memory>
#include <array>
#include <assert.h>
#include <stdexcept>
#include <filesystem>
#include <string.h>
 
#ifdef __unix__
    #include <dlfcn.h>
#elif defined(_WIN32)
    #include <libloaderapi.h>
#else
    #error "Unsupported OS"
#endif
 
#include "sound4cl_cdef.h"
 
    // bridge C callbacks to CPresetLoader
    extern "C" {
        static char *sound4cl_custom_reader(const fs_char *filename, void* userdata);
        static void sound4cl_custom_reader_free(char *content, void* userdata);
        static int sound4cl_custom_writer(const fs_char *filename, const char *content, void* userdata);
        static int sound4cl_custom_exists(const fs_char *filename, void* userdata);
        static fs_char** sound4cl_custom_getall(void* userdata);
        static void sound4cl_custom_getall_free(fs_char** all, void* userdata);
        static int sound4cl_custom_remove(const fs_char *filename, void* userdata);
        static int sound4cl_custom_rename(const fs_char *from, const fs_char *to, void* userdata);
    };
 
namespace sound4 {
 
    namespace helper {
        #ifdef _WIN32
        static inline std::string WStringToUTF8(const std::wstring& wstr) {
            if (wstr.empty()) return {};
            int size = WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), NULL, 0, NULL, NULL);
            std::string str(size, 0);
            WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), &str[0], size, NULL, NULL);
            return str;
        }
        static inline std::wstring UTF8ToWString(const std::string& str) {
            if (str.empty()) return std::wstring();
            int size = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), NULL, 0);
            std::wstring wstr(size, 0);
            MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), &wstr[0], size);
            return wstr;
        }
        #endif // _WIN32
 
            template<typename T>
        struct SampleFormat {
        };
            template<>
        struct SampleFormat<int16_t> {
            const sound4cl_SampleFormat format = S16_NATIVE;
        };
            template<>
        struct SampleFormat<int32_t> {
            const sound4cl_SampleFormat format = S32_NATIVE;
        };
            template<>
        struct SampleFormat<float> {
            const sound4cl_SampleFormat format = F32_NATIVE;
        };
 
        // Storage definition, depending on OS
        #ifdef __unix__
            using DynLib_t = void *;
            using DynFunc_t = void *;
        #else
            using DynLib_t = HMODULE;
            using DynFunc_t = FARPROC;
        #endif
 
            template <typename T>
        class DynFuncHolder {
        private:
            DynFunc_t m_ptr = NULL;
        public:
            DynFuncHolder() = default;
            DynFuncHolder(DynFunc_t a_ptr) : m_ptr(a_ptr) {}
            operator bool() const { return (m_ptr!=NULL); }
            bool IsOk() const { return m_ptr!=NULL; }
            operator T* () const { return reinterpret_cast<T*>(m_ptr); }
        };
 
        class CDynLoader {
            private:
                DynLib_t m_lib {};
            public:
                CDynLoader() = default;
                CDynLoader(CDynLoader&&) = default;
                // No copy allowed
                CDynLoader(const CDynLoader&) = delete;
                CDynLoader& operator=(CDynLoader const&) = delete;
                operator bool() const {
                    return (m_lib!=NULL);
                }
                bool IsOk() const {
                    return (m_lib!=NULL);
                }
                #ifdef __unix__
                    void Close() {
                        if (IsOk()) {
                            #ifndef __SANITIZE_ADDRESS__ // avoid unloading to keep call stack
                            dlclose(m_lib);
                            #endif // __SANITIZE_ADDRESS__
                            m_lib=NULL;
                        }
                    }
                    bool Load(const std::filesystem::path& dynlib)
                    {
                        Close();
                        m_lib=dlopen(dynlib.c_str(), RTLD_NOW|RTLD_LOCAL);
                        return IsOk();
                    }
                        template <typename T>
                    DynFuncHolder<T> GetSymbol(const std::string& name) {
                        auto ptr=dlsym(m_lib, name.c_str());
                        if (!ptr) {
                            throw std::runtime_error("Missing function in library");
                        }
                        return DynFuncHolder<T>(ptr);
                    }
                        template <typename T>
                    DynFuncHolder<T> GetSymbol_safe(const std::string& name) {
                        auto ptr=dlsym(m_lib, name.c_str());
                        return DynFuncHolder<T>(ptr);
                    }
                    static std::filesystem::path GetThisLibraryPath(void) {
                        static Dl_info info;
                        if (! dladdr((void *) GetThisLibraryPath, & info)) return {};
                        auto rp=realpath(info.dli_fname, NULL);
                        std::filesystem::path p(rp);
                        free(rp);
                        return p;
                    }
                #else
                    bool Load(const std::filesystem::path& dynlib, uint32_t loadflags = LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR|LOAD_LIBRARY_SEARCH_APPLICATION_DIR|LOAD_LIBRARY_SEARCH_USER_DIRS|LOAD_LIBRARY_SEARCH_SYSTEM32)
                    {
                        Close();
                        m_lib=LoadLibraryExW(dynlib.c_str(), NULL, loadflags);
                        return IsOk();
                    }
                    void Close() {
                        if (IsOk()) {
                            // NOTE: On Windows, FreeLibrary may create a lot of troubles, should use FreeLibraryAndExitThread but...
                            // So define SOUND4_CALL_FREELIBRARY before including this file if you really want to unload the library dynamically
                            #if defined(SOUND4_CALL_FREELIBRARYANDEXITTHREAD)
                                FreeLibraryAndExitThread(m_lib, 0);
                            #elif defined(SOUND4_CALL_FREELIBRARY)
                                FreeLibrary(m_lib);
                            #endif // SOUND4_CALL_FREELIBRARY
                            m_lib=NULL;
                        }
                    }
                        template <typename T>
                    DynFuncHolder<T> GetSymbol(const std::string& name) {
                        auto ptr=GetProcAddress(m_lib, name.c_str());
                        if (!ptr) {
                            throw std::runtime_error("Missing function in library");
                        }
                        return DynFuncHolder<T>(ptr);
                    }
                        template <typename T>
                    DynFuncHolder<T> GetSymbol_safe(const std::string& name) {
                        auto ptr=GetProcAddress(m_lib, name.c_str());
                        return DynFuncHolder<T>(ptr);
                    }
                    static std::filesystem::path GetThisLibraryPath(void) {
                        static wchar_t path[MAX_PATH]={};
                        HMODULE hm = NULL;
                        if (GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | 
                                GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
                                (LPCWSTR) &GetThisLibraryPath, &hm)) 
                        {
                            if (GetModuleFileNameW(hm, path, MAX_PATH) > 0) {
                                return std::filesystem::path(path);
                            }
                        }
                        return {};
                    }
                #endif
                virtual ~CDynLoader() {
                    Close();
                }
        }; // class CDynLoader
    }; // namespace helper
 
 
    using LogSeverity = sound4cl_LogSeverity;
    const LogSeverity none     = (LogSeverity) sound4cl_none;
    const LogSeverity fatal    = (LogSeverity) sound4cl_fatal;
    const LogSeverity error    = (LogSeverity) sound4cl_error;
    const LogSeverity warning  = (LogSeverity) sound4cl_warning;
    const LogSeverity info     = (LogSeverity) sound4cl_info;
    const LogSeverity verbose  = (LogSeverity) sound4cl_verbose;
    const LogSeverity verbose2 = (LogSeverity) sound4cl_verbose2;
    const LogSeverity verbose3 = (LogSeverity) sound4cl_verbose3;
    const LogSeverity verbose4 = (LogSeverity) sound4cl_verbose4;
    const LogSeverity verbose5 = (LogSeverity) sound4cl_verbose5;
 
    using log_cb_t = std::function<void(LogSeverity,const std::string&)>;
 
    static log_cb_t _log_cb;
    extern "C" {
        static inline void _log_cb_c(LogSeverity severity, const char *c_msg) {
            _log_cb(severity, std::string(c_msg));
        }
    }
 
    class CProcessor {
    private:
        helper::CDynLoader m_lib;
        bool m_bOK = false;
        std::string m_prefix; // The prefix of functions, depends on the library (cloud_, impact_...)
    protected:
        friend class CBus;
        friend class CInstance;
 
        // All those wrapped functions have the same signature as there C sound4cl_XXX
        helper::DynFuncHolder< decltype(sound4cl_GetVersion             ) > fnGetVersion             ;
        helper::DynFuncHolder< decltype(sound4cl_GetChunkSizeInFrames   ) > fnGetChunkSizeInFrames   ;
        helper::DynFuncHolder< decltype(sound4cl_GetChannelCount        ) > fnGetChannelCount        ;
        helper::DynFuncHolder< decltype(sound4cl_GetAudioInputCount     ) > fnGetAudioInputCount     ;
        helper::DynFuncHolder< decltype(sound4cl_GetAudioOutputCount    ) > fnGetAudioOutputCount    ;
        helper::DynFuncHolder< decltype(sound4cl_GetSampleRate          ) > fnGetSampleRate          ;
        helper::DynFuncHolder< decltype(sound4cl_SetLoggerCallback      ) > fnSetLoggerCallback      ;
        helper::DynFuncHolder< decltype(sound4cl_SetLogSeverity         ) > fnSetLogSeverity         ;
        helper::DynFuncHolder< decltype(sound4cl_NewParameters          ) > fnNewParameters          ;
        helper::DynFuncHolder< decltype(sound4cl_FreeParameters         ) > fnFreeParameters         ;
        helper::DynFuncHolder< decltype(sound4cl_SetParameter           ) > fnSetParameter           ;
        helper::DynFuncHolder< decltype(sound4cl_GetParameter           ) > fnGetParameter           ;
        helper::DynFuncHolder< decltype(sound4cl_FreeParameterValue     ) > fnFreeParameterValue     ;
        helper::DynFuncHolder< decltype(sound4cl_InitProcess            ) > fnInitProcess            ;
        helper::DynFuncHolder< decltype(sound4cl_InitProcess2           ) > fnInitProcess2           ;
        helper::DynFuncHolder< decltype(sound4cl_TerminateProcess       ) > fnTerminateProcess       ;
        helper::DynFuncHolder< decltype(sound4cl_ExitProcess            ) > fnExitProcess            ;
        helper::DynFuncHolder< decltype(sound4cl_StartUpdateThread      ) > fnStartUpdateThread      ;
        helper::DynFuncHolder< decltype(sound4cl_StopUpdateThread       ) > fnStopUpdateThread       ;
        helper::DynFuncHolder< decltype(sound4cl_WaitUpdateThreadReady  ) > fnWaitUpdateThreadReady  ;
        helper::DynFuncHolder< decltype(sound4cl_ProcessAudio           ) > fnProcessAudio           ;
        helper::DynFuncHolder< decltype(sound4cl_ProcessAudio_Planar    ) > fnProcessAudio_Planar    ;
        helper::DynFuncHolder< decltype(sound4cl_GetBufferIn            ) > fnGetBufferIn            ;
        helper::DynFuncHolder< decltype(sound4cl_GetBufferOut           ) > fnGetBufferOut           ;
        helper::DynFuncHolder< decltype(sound4cl_GetEstimatedDelay      ) > fnGetEstimatedDelay      ;
        helper::DynFuncHolder< decltype(sound4cl_GetFormatName          ) > fnGetFormatName          ;
        helper::DynFuncHolder< decltype(sound4cl_GetFormatFromName      ) > fnGetFormatFromName      ;
        helper::DynFuncHolder< decltype(sound4cl_GetBytesFromFormat     ) > fnGetBytesFromFormat     ;
        helper::DynFuncHolder< decltype(sound4cl_GetMaxPacketFrame      ) > fnGetMaxPacketFrame      ;
        helper::DynFuncHolder< decltype(sound4cl_AddAudio               ) > fnAddAudio               ;
        helper::DynFuncHolder< decltype(sound4cl_AddPadAudio            ) > fnAddPadAudio            ;
        helper::DynFuncHolder< decltype(sound4cl_GetOutputCount         ) > fnGetOutputCount         ;
        helper::DynFuncHolder< decltype(sound4cl_GetAudio               ) > fnGetAudio               ;
        helper::DynFuncHolder< decltype(sound4cl_AudioConvertFrom       ) > fnAudioConvertFrom       ;
        helper::DynFuncHolder< decltype(sound4cl_AudioConvertTo         ) > fnAudioConvertTo         ;
        helper::DynFuncHolder< decltype(sound4cl_StereoToMono           ) > fnStereoToMono           ;
        helper::DynFuncHolder< decltype(sound4cl_MonoToStereo           ) > fnMonoToStereo           ;
        helper::DynFuncHolder< decltype(sound4cl_AudioMonoFromLiveStereo) > fnAudioMonoFromLiveStereo;
        helper::DynFuncHolder< decltype(sound4cl_AudioMonoToLiveStereo  ) > fnAudioMonoToLiveStereo  ;
        helper::DynFuncHolder< decltype(sound4cl_NewClient              ) > fnNewClient              ;
        helper::DynFuncHolder< decltype(sound4cl_DeleteClient           ) > fnDeleteClient           ;
        helper::DynFuncHolder< decltype(sound4cl_ProcessJson            ) > fnProcessJson            ;
        helper::DynFuncHolder< decltype(sound4cl_FreeJsonAnswer         ) > fnFreeJsonAnswer         ;
        helper::DynFuncHolder< decltype(sound4cl_SaveState              ) > fnSaveState              ;
 
        // only for processes supporting webserver
        helper::DynFuncHolder< decltype(sound4cl_Webserver_tcp          ) > fnWebserver_tcp          ;
        helper::DynFuncHolder< decltype(sound4cl_Webserver_tcp2         ) > fnWebserver_tcp2         ;
        helper::DynFuncHolder< decltype(sound4cl_Webserver              ) > fnWebserver              ;
        helper::DynFuncHolder< decltype(sound4cl_Webserver_Stop         ) > fnWebserver_Stop         ;
        helper::DynFuncHolder< decltype(sound4cl_Webserver_Status       ) > fnWebserver_Status       ;
 
        // added 2023-03-22
        helper::DynFuncHolder< decltype(sound4cl_StereoToMono_Planar    ) > fnStereoToMono_Planar    ;
        helper::DynFuncHolder< decltype(sound4cl_MonoToStereo_Planar    ) > fnMonoToStereo_Planar    ;
 
        // added 2023-05-22
        helper::DynFuncHolder< decltype(sound4cl_SetMetadata            ) > fnSetMetadata            ;
        helper::DynFuncHolder< decltype(sound4cl_GetMetadataInfos       ) > fnGetMetadataInfos       ;
        helper::DynFuncHolder< decltype(sound4cl_FreeMetadataInfos      ) > fnFreeMetadataInfos      ;
 
        // added 2023-06-20
        helper::DynFuncHolder< decltype(sound4cl_SetPresetManager                ) > fnSetPresetManager      ;
        helper::DynFuncHolder< decltype(sound4cl_PresetManager_InformChange      ) > fnPresetManager_InformChange      ;
 
        // added 2023-09-21
        helper::DynFuncHolder< decltype(sound4cl_GetPossibleChunkSizeInFrames    ) > fnGetPossibleChunkSizeInFrames   ;
        helper::DynFuncHolder< decltype(sound4cl_GetProcessChunkFrames           ) > fnGetProcessChunkFrames   ;
        helper::DynFuncHolder< decltype(sound4cl_InitProcess3                    ) > fnInitProcess3           ;
 
        // added 2023-06-26, only for processes supporting bus
        helper::DynFuncHolder< decltype(sound4cl_NewBus                 ) > fnNewBus      ;
        helper::DynFuncHolder< decltype(sound4cl_FreeBus                ) > fnFreeBus      ;
        helper::DynFuncHolder< decltype(sound4cl_SetInstanceBus         ) > fnSetInstanceBus      ;
 
        // added 2024-02-19
        helper::DynFuncHolder< decltype(sound4cl_SetMetadataMulti       ) > fnSetMetadataMulti         ;
 
        // added 2024-05-23
        helper::DynFuncHolder< decltype(sound4cl_Webserver_SetAppHealth    ) > fnWebserver_SetAppHealth      ;
        helper::DynFuncHolder< decltype(sound4cl_Webserver_GetAppHealth    ) > fnWebserver_GetAppHealth      ;
        helper::DynFuncHolder< decltype(sound4cl_Webserver_FreeString      ) > fnWebserver_FreeString        ;
 
            template <typename T>
        helper::DynFuncHolder<T> GetPrefixSymbol(const std::string& name) {
            std::string prefix_name = m_prefix+name;
            return m_lib.GetSymbol<T>(prefix_name);
        }
 
    public:
        CProcessor() = default;
 
        bool Load(const std::filesystem::path& filepath) {
            m_lib.Close();
            // If a path is given, use it directly and do not try other path
            if (filepath.has_parent_path() && !m_lib.Load(filepath)) {
                return false;
            } else if (!m_lib.IsOk()) {
                auto thisdir=helper::CDynLoader::GetThisLibraryPath().parent_path();
                auto filename = filepath.filename();
                #ifndef _WIN32
                // Linux: if in a bin directory, try ../lib first
                if (!m_lib.IsOk() && thisdir.filename()=="bin") {
                    auto libdir = thisdir.parent_path() / "lib";
                    m_lib.Load(libdir / filename);
                }
                #endif // !_WIN32
                if (!m_lib.IsOk()) {
                    // Search in the same directory this code is in
                    m_lib.Load(thisdir / filename);
                }
                if (!m_lib.IsOk()) {
                    // Try current path
                    m_lib.Load(std::filesystem::current_path() / filename);
                }
                if (!m_lib.IsOk()) {
                    return false;
                }
            }
            // Get information from the library itself
            try {
                auto GetInfo = m_lib.GetSymbol< decltype(sound4cl_SOUND4_GetProcessInfo             ) >("SOUND4_GetProcessInfo"   );
                auto info = GetInfo();
                m_prefix = info->prefix;
            } catch (std::runtime_error& ) {
                // Compatibility: search in known libraries without this function
                #ifdef _WIN32
                    std::string filename = helper::WStringToUTF8(filepath.stem());
                #else // !_WIN32
                    std::string filename = filepath.stem();
                    // remove lib prefix
                    filename=filename.substr(3);
                #endif // ! _WIN32
                if (filename=="sound4.x1.cloud") {
                    m_prefix="cloudx1_";
                } else if (filename=="sound4.impact.cl") {
                    m_prefix="impact_";
                } else if (filename=="sound4.bigvoice.cl") {
                    m_prefix="bigvoice_";
                } else {
                    return false;
                }
            }
 
            // Load all C functions
            try {
                fnGetVersion              = GetPrefixSymbol< decltype(sound4cl_GetVersion             ) >("GetVersion"             );
                fnGetChunkSizeInFrames    = GetPrefixSymbol< decltype(sound4cl_GetChunkSizeInFrames   ) >("GetChunkSizeInFrames"   );
                fnGetChannelCount         = GetPrefixSymbol< decltype(sound4cl_GetChannelCount        ) >("GetChannelCount"        );
                fnGetAudioInputCount      = GetPrefixSymbol< decltype(sound4cl_GetAudioInputCount     ) >("GetAudioInputCount"     );
                fnGetAudioOutputCount     = GetPrefixSymbol< decltype(sound4cl_GetAudioOutputCount    ) >("GetAudioOutputCount"    );
                fnGetSampleRate           = GetPrefixSymbol< decltype(sound4cl_GetSampleRate          ) >("GetSampleRate"          );
                fnSetLoggerCallback       = GetPrefixSymbol< decltype(sound4cl_SetLoggerCallback      ) >("SetLoggerCallback"      );
                fnSetLogSeverity          = GetPrefixSymbol< decltype(sound4cl_SetLogSeverity         ) >("SetLogSeverity"         );
                fnNewParameters           = GetPrefixSymbol< decltype(sound4cl_NewParameters          ) >("NewParameters"          );
                fnFreeParameters          = GetPrefixSymbol< decltype(sound4cl_FreeParameters         ) >("FreeParameters"         );
                fnSetParameter            = GetPrefixSymbol< decltype(sound4cl_SetParameter           ) >("SetParameter"           );
                fnGetParameter            = GetPrefixSymbol< decltype(sound4cl_GetParameter           ) >("GetParameter"           );
                fnFreeParameterValue      = GetPrefixSymbol< decltype(sound4cl_FreeParameterValue     ) >("FreeParameterValue"     );
                fnInitProcess             = GetPrefixSymbol< decltype(sound4cl_InitProcess            ) >("InitProcess"            );
                fnInitProcess2            = GetPrefixSymbol< decltype(sound4cl_InitProcess2           ) >("InitProcess2"           );
                fnTerminateProcess        = GetPrefixSymbol< decltype(sound4cl_TerminateProcess       ) >("TerminateProcess"       );
                fnExitProcess             = GetPrefixSymbol< decltype(sound4cl_ExitProcess            ) >("ExitProcess"            );
                fnStartUpdateThread       = GetPrefixSymbol< decltype(sound4cl_StartUpdateThread      ) >("StartUpdateThread"      );
                fnStopUpdateThread        = GetPrefixSymbol< decltype(sound4cl_StopUpdateThread       ) >("StopUpdateThread"       );
                fnWaitUpdateThreadReady   = GetPrefixSymbol< decltype(sound4cl_WaitUpdateThreadReady  ) >("WaitUpdateThreadReady"  );
                fnProcessAudio            = GetPrefixSymbol< decltype(sound4cl_ProcessAudio           ) >("ProcessAudio"           );
                fnProcessAudio_Planar     = GetPrefixSymbol< decltype(sound4cl_ProcessAudio_Planar    ) >("ProcessAudio_Planar"    );
                fnGetBufferIn             = GetPrefixSymbol< decltype(sound4cl_GetBufferIn            ) >("GetBufferIn"            );
                fnGetBufferOut            = GetPrefixSymbol< decltype(sound4cl_GetBufferOut           ) >("GetBufferOut"           );
                fnGetEstimatedDelay       = GetPrefixSymbol< decltype(sound4cl_GetEstimatedDelay      ) >("GetEstimatedDelay"      );
                fnGetFormatName           = GetPrefixSymbol< decltype(sound4cl_GetFormatName          ) >("GetFormatName"          );
                fnGetFormatFromName       = GetPrefixSymbol< decltype(sound4cl_GetFormatFromName      ) >("GetFormatFromName"      );
                fnGetBytesFromFormat      = GetPrefixSymbol< decltype(sound4cl_GetBytesFromFormat     ) >("GetBytesFromFormat"     );
                fnGetMaxPacketFrame       = GetPrefixSymbol< decltype(sound4cl_GetMaxPacketFrame      ) >("GetMaxPacketFrame"      );
                fnAddAudio                = GetPrefixSymbol< decltype(sound4cl_AddAudio               ) >("AddAudio"               );
                fnAddPadAudio             = GetPrefixSymbol< decltype(sound4cl_AddPadAudio            ) >("AddPadAudio"            );
                fnGetOutputCount          = GetPrefixSymbol< decltype(sound4cl_GetOutputCount         ) >("GetOutputCount"         );
                fnGetAudio                = GetPrefixSymbol< decltype(sound4cl_GetAudio               ) >("GetAudio"               );
                fnAudioConvertFrom        = GetPrefixSymbol< decltype(sound4cl_AudioConvertFrom       ) >("AudioConvertFrom"       );
                fnAudioConvertTo          = GetPrefixSymbol< decltype(sound4cl_AudioConvertTo         ) >("AudioConvertTo"         );
                fnStereoToMono            = GetPrefixSymbol< decltype(sound4cl_StereoToMono           ) >("StereoToMono"           );
                fnMonoToStereo            = GetPrefixSymbol< decltype(sound4cl_MonoToStereo           ) >("MonoToStereo"           );
                fnAudioMonoFromLiveStereo = GetPrefixSymbol< decltype(sound4cl_AudioMonoFromLiveStereo) >("AudioMonoFromLiveStereo");
                fnAudioMonoToLiveStereo   = GetPrefixSymbol< decltype(sound4cl_AudioMonoToLiveStereo  ) >("AudioMonoToLiveStereo"  );
                fnNewClient               = GetPrefixSymbol< decltype(sound4cl_NewClient              ) >("NewClient"              );
                fnDeleteClient            = GetPrefixSymbol< decltype(sound4cl_DeleteClient           ) >("DeleteClient"           );
                fnProcessJson             = GetPrefixSymbol< decltype(sound4cl_ProcessJson            ) >("ProcessJson"            );
                fnFreeJsonAnswer          = GetPrefixSymbol< decltype(sound4cl_FreeJsonAnswer         ) >("FreeJsonAnswer"         );
                fnSaveState               = GetPrefixSymbol< decltype(sound4cl_SaveState              ) >("SaveState"              );
            } catch (std::runtime_error& ) {
                return false;
            }
            // Webserver : not for all projects
            try {
                fnWebserver_tcp           = GetPrefixSymbol< decltype(sound4cl_Webserver_tcp          ) >("Webserver_tcp"          );
                fnWebserver_tcp2          = GetPrefixSymbol< decltype(sound4cl_Webserver_tcp2         ) >("Webserver_tcp2"         );
                fnWebserver               = GetPrefixSymbol< decltype(sound4cl_Webserver              ) >("Webserver"              );
                fnWebserver_Stop          = GetPrefixSymbol< decltype(sound4cl_Webserver_Stop         ) >("Webserver_Stop"         );
                fnWebserver_Status        = GetPrefixSymbol< decltype(sound4cl_Webserver_Status       ) >("Webserver_Status"       );
            } catch (std::runtime_error& ) {
                // Ignored, handler will take care
            }
            // Stereo/Mono conversion : must be present
            try {
                // added 2023-03-22
                fnStereoToMono_Planar     = GetPrefixSymbol< decltype(sound4cl_StereoToMono_Planar    ) >("StereoToMono_Planar"    );
                fnMonoToStereo_Planar     = GetPrefixSymbol< decltype(sound4cl_MonoToStereo_Planar    ) >("MonoToStereo_Planar"    );
 
            } catch (std::runtime_error& ) {
                return false;
            }
            // C functions allowed to be missing
            try {
                // added 2023-05-22
                fnSetMetadata             = GetPrefixSymbol< decltype(sound4cl_SetMetadata            ) >("SetMetadata"            );
                fnGetMetadataInfos        = GetPrefixSymbol< decltype(sound4cl_GetMetadataInfos       ) >("GetMetadataInfos"       );
                fnFreeMetadataInfos       = GetPrefixSymbol< decltype(sound4cl_FreeMetadataInfos      ) >("FreeMetadataInfos"      );
                // added 2023-06-20
                fnSetPresetManager            = GetPrefixSymbol< decltype(sound4cl_SetPresetManager               ) >("SetPresetManager"              );
                fnPresetManager_InformChange  = GetPrefixSymbol< decltype(sound4cl_PresetManager_InformChange     ) >("PresetManager_InformChange"    );
 
                // added 2023-09-21
                fnGetPossibleChunkSizeInFrames = GetPrefixSymbol< decltype(sound4cl_GetPossibleChunkSizeInFrames  ) >("GetPossibleChunkSizeInFrames"  );
                fnGetProcessChunkFrames        = GetPrefixSymbol< decltype(sound4cl_GetProcessChunkFrames         ) >("GetProcessChunkFrames"         );
                fnInitProcess3                 = GetPrefixSymbol< decltype(sound4cl_InitProcess3                  ) >("InitProcess3"                  );
            }  catch (std::runtime_error& ) {
                // Ignored, handler will take care
            }
 
            // bus: not for all projects
            try {
                // added 2023-06-26
                fnNewBus                  = GetPrefixSymbol< decltype(sound4cl_NewBus                 ) >("NewBus"                 );
                fnFreeBus                 = GetPrefixSymbol< decltype(sound4cl_FreeBus                ) >("FreeBus"                );
                fnSetInstanceBus          = GetPrefixSymbol< decltype(sound4cl_SetInstanceBus         ) >("SetInstanceBus"         );
            }  catch (std::runtime_error& ) {
                // Ignored, handler will take care
            }
 
            // Other optional
            try {
                // added 2024-02-19
                fnSetMetadataMulti        = GetPrefixSymbol< decltype(sound4cl_SetMetadataMulti       ) >("SetMetadataMulti"       );
 
            }  catch (std::runtime_error& ) {
                // Ignored, handler will take care
            }
 
            // Other optional, web server only
            try {
                // added 2024-05-23
                fnWebserver_SetAppHealth    = GetPrefixSymbol< decltype(sound4cl_Webserver_SetAppHealth    ) >("Webserver_SetAppHealth"     );
                fnWebserver_GetAppHealth    = GetPrefixSymbol< decltype(sound4cl_Webserver_GetAppHealth    ) >("Webserver_GetAppHealth"     );
                fnWebserver_FreeString      = GetPrefixSymbol< decltype(sound4cl_Webserver_FreeString      ) >("Webserver_FreeString"       );
            }  catch (std::runtime_error& ) {
                // Ignored, handler will take care
            }
 
            m_bOK=true;
            return true;
        }
        bool IsOk() const {
            return m_bOK;
        }
 
        void AudioConvertFrom(const uint8_t *payload, float *output, size_t nSpl, sound4cl_SampleFormat fmt)
            { fnAudioConvertFrom(payload, output, nSpl, fmt); }
        void AudioConvertTo(const float *input, uint8_t *payload, size_t nSpl, sound4cl_SampleFormat fmt)
            { fnAudioConvertTo(input, payload, nSpl, fmt); }
        void StereoToMono(const float *input, float *output, size_t nSpl)
            { fnStereoToMono(input, output, nSpl); }
        void MonoToStereo(const float *input, float *output, size_t nSpl)
            { fnMonoToStereo(input, output, nSpl); }
        void StereoToMono_Planar(const float *inputL, const float *inputR, float *output, size_t nSpl)
            { fnStereoToMono_Planar(inputL, inputR, output, nSpl); }
        void MonoToStereo_Planar(const float *input, float *outputL, float *outputR, size_t nSpl)
            { fnMonoToStereo_Planar(input, outputL, outputR, nSpl); }
        void AudioMonoFromLiveStereo(const uint8_t *payload, float *output)
            { fnAudioMonoFromLiveStereo(payload, output); }
        void AudioMonoToLiveStereo(const float *input, uint8_t *payload) 
            { fnAudioMonoToLiveStereo(input, payload); }
 
        std::string GetVersion()
            { return std::string(fnGetVersion()); }
 
        unsigned int GetChunkSizeInFrames()
            { return fnGetChunkSizeInFrames(); }
 
        std::vector<unsigned int> GetPossibleChunkSizeInFrames()
            {
                std::vector<unsigned int> list;
                if (fnGetPossibleChunkSizeInFrames) {
                    for (unsigned int* src=fnGetPossibleChunkSizeInFrames();*src;src++) {
                        list.push_back(*src);
                    }
                } else {
                    list.push_back(fnGetChunkSizeInFrames());
                }
                return list;
            }
 
        unsigned int GetChannelCount()
            { return fnGetChannelCount(); }
 
        unsigned int GetAudioInputCount()
            { return fnGetAudioInputCount(); }
 
        unsigned int GetAudioOutputCount()
            { return fnGetAudioOutputCount(); }
 
        unsigned int GetSampleRate()
            { return fnGetSampleRate(); }
 
        std::string GetFormatName( const sound4cl_SampleFormat fmt)
            { return std::string(fnGetFormatName(fmt)); }
 
        sound4cl_SampleFormat GetFormatFromName( const std::string& name)
            { return fnGetFormatFromName(name.c_str()); }
 
        unsigned int GetBytesFromFormat( const sound4cl_SampleFormat fmt)
            { return fnGetBytesFromFormat(fmt); }
 
        void SetLogSeverity(LogSeverity severity)
            { fnSetLogSeverity(severity); }
 
        void SetLoggerCallback(log_cb_t cb)
            { _log_cb=cb; fnSetLoggerCallback(&_log_cb_c); }
    };
 
    class CBus {
        public:
            CBus(CProcessor& dynlib)
                : m_dynlib(dynlib)
                {
                    if (m_dynlib.fnNewBus) {
                        m_bus=m_dynlib.fnNewBus();
                    }
                } 
            ~CBus()
                {
                    if (m_bus && m_dynlib.fnFreeBus) {
                        m_dynlib.fnFreeBus(m_bus);
                    }
                    m_bus = nullptr;
                }
            sound4cl_CBus *Get() const { return m_bus; }
        private:
            CProcessor& m_dynlib;
            sound4cl_CBus *m_bus;
    };
 
    class CPresetLoader {
    public:
        CPresetLoader() = default;
        virtual ~CPresetLoader() = default;
 
        virtual bool IsReadOnly() = 0;
        virtual bool Exists(const std::filesystem::path &name) = 0;
        virtual bool Remove(const std::filesystem::path &name) = 0;
        virtual bool Rename(const std::filesystem::path &from, const std::filesystem::path &to) = 0;
        virtual std::vector<std::filesystem::path> GetAll() = 0;
        virtual std::string Read(const std::filesystem::path &filename) = 0;
        virtual bool Write(const std::filesystem::path &filename, const std::string &content) =0;
    };
    using PresetChange_Kind = sound4cl_PresetChange_Kind;
 
    class CInstance {
    public:
        CInstance(CProcessor& dynlib)
        : m_dynlib(dynlib) 
            {
                params = m_dynlib.fnNewParameters();
                if (!params) throw std::bad_alloc();
            }
        // non-copyable
        CInstance( const CInstance& ) = delete;
        CInstance& operator=( const CInstance& ) = delete;
        ~CInstance()
            {
                Stop();
                if (params) m_dynlib.fnFreeParameters(params);
            }
       bool IsOk() const { return instance!=nullptr; }
        void SetParam(const std::string& name, const std::string& value)
            {
                assert(params);
                m_dynlib.fnSetParameter(params, name.c_str(), value.c_str());
            }
        std::string GetParam(const std::string& name)
            {
                assert(params);
                auto c_value=m_dynlib.fnGetParameter(params, name.c_str());
                std::string ret(c_value);
                m_dynlib.fnFreeParameterValue(c_value);
                return ret;
            }
 
        void SetBus(const CBus& bus) {
            assert(params);
            if (m_dynlib.fnSetInstanceBus) {
                m_dynlib.fnSetInstanceBus(params,bus.Get());
            }
        }
 
        void SetPresetManager(CPresetLoader *preset_manager)
            {
                if (!preset_manager) return;
                if (!m_dynlib.fnSetPresetManager) return;
                assert(params);
                m_dynlib.fnSetPresetManager(params,
                    sound4cl_custom_reader,
                    sound4cl_custom_reader_free,
                    sound4cl_custom_writer,
                    sound4cl_custom_exists,
                    sound4cl_custom_getall,
                    sound4cl_custom_getall_free,
                    sound4cl_custom_remove,
                    sound4cl_custom_rename,
                    preset_manager->IsReadOnly(),
                    preset_manager
                );
            }
 
        bool Create(const std::string& LoginKey, const std::string& RadioName, const std::string& Access_Key_ID, const std::string& Access_Key_Secret, const std::filesystem::path& save_path, int json_port = 0, unsigned int frames_per_chunk=0)
            {
                assert(!instance);
                std::string l_save_path;
                if (!save_path.empty()) {
                    l_save_path = save_path.u8string();
                }
                if (frames_per_chunk==0) {
                    frames_per_chunk=m_dynlib.GetChunkSizeInFrames();
                }
                if (m_dynlib.fnInitProcess3) {
                    instance = m_dynlib.fnInitProcess3(LoginKey.c_str(), RadioName.c_str(), Access_Key_ID.c_str(), Access_Key_Secret.c_str(), l_save_path.c_str(), params, frames_per_chunk);
                } else if (frames_per_chunk!=m_dynlib.GetChunkSizeInFrames()) {
                    return false;
                } else {
                    instance = m_dynlib.fnInitProcess2(LoginKey.c_str(), RadioName.c_str(), Access_Key_ID.c_str(), Access_Key_Secret.c_str(), l_save_path.c_str(), params);
                }
                if (!instance) return false;
                if (!init_metadata.empty()) {
                    for (auto&& [key,value]: init_metadata) {
                        m_dynlib.fnSetMetadata(instance, key.c_str(), value.c_str());
                    }
                    init_metadata.clear();
                }
                update_thread = std::thread([this, json_port](){
                    OnUpdateThreadStart();
                    m_dynlib.fnStartUpdateThread(instance, json_port);
                    OnUpdateThreadStop();
                });
                int timeout=5000;
                #ifdef DEBUG
                    timeout=60*1000; // For debugger pauses
                #endif
                if (m_dynlib.fnWaitUpdateThreadReady(instance, timeout)<0) {
                    return false;
                }
                return true;
            }
 
        unsigned int GetChunkFrames() {
            if (instance && m_dynlib.fnGetProcessChunkFrames) {
                return m_dynlib.fnGetProcessChunkFrames(instance);
            }
            return m_dynlib.fnGetChunkSizeInFrames();
        }
 
        void PresetManager_InformChange(const std::filesystem::path& relative_path, PresetChange_Kind change_kind)
            {
                if (m_dynlib.fnPresetManager_InformChange) {
                    m_dynlib.fnPresetManager_InformChange(instance, relative_path.c_str(), (sound4cl_PresetChange_Kind) change_kind);
                }
            }
 
        void SetMetadata(const std::string& key, const char* value)
            {
                if (m_dynlib.fnSetMetadata) {
                    if (instance) {
                        m_dynlib.fnSetMetadata(instance, key.c_str(), value);
                    } else {
                        init_metadata.push_back( {key, value} );
                    }
                }
            }
 
 
        void SetMetadataMulti(const std::unordered_map<std::string, const char*>& list)
            {
                if (instance) {
                    if (m_dynlib.fnSetMetadataMulti) {
                        typedef const char* pchar;
                        pchar* keyvalue=new pchar[2*list.size()+1];
                        size_t n=0;
                        for (auto&& [key,value]: list) {
                            keyvalue[2*n+0]=key.c_str();
                            keyvalue[2*n+1]=value;
                            n++;
                        }
                        keyvalue[2*n+0]=nullptr;
                        
                        sound4cl_SetMetadataMulti(instance, keyvalue);
 
                        delete[] keyvalue;
                    } else {
                        for (auto&& [key,value]: list) {
                            SetMetadata(key, value);
                        }
                    }
                } else {
                    for (auto&& [key,value]: list) {
                        if (value) {
                            init_metadata.push_back( {key, value} );
                        }
                    }
                }
            }
 
        std::vector< std::tuple<std::string,std::string> > GetMetadataInfos()
            {
                std::vector< std::tuple<std::string,std::string> > values;
                if (m_dynlib.fnGetMetadataInfos) {
                    const char** c_values = m_dynlib.fnGetMetadataInfos(instance);
                    if (c_values) {
                        for (const char** c_value=c_values; *c_value; ) {
                            std::string key(*c_value);
                            c_value++;
                            if (*c_value) {
                                std::string descr(*c_value);
                                c_value++;
                                values.push_back( {key,descr} );
                            }
                        }
                        m_dynlib.fnFreeMetadataInfos(instance, c_values);
                    }
                }
                return values;
            }
 
        // Can be overloaded, called at start of UpdateThread in the thread
        virtual void OnUpdateThreadStart() {}
        // Can be overloaded to call at end of UpdateThread in the thread
        virtual void OnUpdateThreadStop() {}
 
        bool StartWebServer(int http_port, int https_port=0)
            {
                assert(instance);
                assert(webserver==SOUND4_INVALID_WEBSERVER_ID);
                if (!m_dynlib.fnWebserver) {
                    return false;
                }
                webserver = m_dynlib.fnWebserver(http_port,https_port,instance);
                if (webserver==SOUND4_INVALID_WEBSERVER_ID) {
                    return false;
                }
                int web_status=m_dynlib.fnWebserver_Status(webserver);
                if (http_port && (web_status & SOUND4_WEBSERVER_HTTP_OK) == 0) {
                    return false;
                }
                if (https_port && (web_status & SOUND4_WEBSERVER_HTTPS_OK) == 0) {
                    return false;
                }
                return true;
            }
        void StopWebServer()
            {
                if (!m_dynlib.fnWebserver_Stop) return;
                if (webserver != SOUND4_INVALID_WEBSERVER_ID) {
                    m_dynlib.fnWebserver_Stop(webserver, 1000);
                    webserver = SOUND4_INVALID_WEBSERVER_ID;
                }
            }
 
        void SetWebServerAppHealth(int httpcode, const std::string& contenttype, const std::string& content)
            {
                assert(instance);
                if (!m_dynlib.fnWebserver_SetAppHealth) return;
                m_dynlib.fnWebserver_SetAppHealth(instance, httpcode, contenttype.c_str(), content.c_str());
            }
        void GetWebServerAppHealth(int &httpcode, std::string& contenttype, std::string& content)
            {
                assert(instance);
                if (!m_dynlib.fnWebserver_GetAppHealth) return;
                char* c_contenttype=nullptr;
                char* c_content=nullptr;
                m_dynlib.fnWebserver_GetAppHealth(instance, &httpcode, &c_contenttype, &c_content);
                contenttype=c_contenttype;
                content=c_content;
                m_dynlib.fnWebserver_FreeString(c_contenttype);
                m_dynlib.fnWebserver_FreeString(c_content);
            }
        int Terminate()
            {
                if (!instance) return 0;
                return m_dynlib.fnTerminateProcess(instance);
            }
 
        void Stop()
            {
                if (!instance) return;
                StopWebServer();
                if (update_thread.joinable()) {
                    m_dynlib.fnStopUpdateThread(instance); // this will exit the update thread
                    update_thread.join();
                }
                m_dynlib.fnExitProcess(instance);
                instance=nullptr;
            }
 
        unsigned int GetEstimatedDelay()
            {
                assert(instance);
                return m_dynlib.fnGetEstimatedDelay(instance);
            }
 
        float* GetBufferIn()
            {
                assert(instance);
                return m_dynlib.fnGetBufferIn(instance);
 
            }
        float* GetBufferOut()
            {
                assert(instance);
                return m_dynlib.fnGetBufferOut(instance);
            }
        void ProcessAudio()
            {
                assert(instance);
                m_dynlib.fnProcessAudio(instance, m_dynlib.fnGetBufferIn(instance), m_dynlib.fnGetBufferOut(instance));
            }
        // void ProcessAudio_Planar(const std::array< const std::array<const float,ChunkFrames>, InputChannels>& input, std::array< std::array<float,ChunkFrames>, OutputChannels>& output)
        void ProcessAudio_Planar(float const * const *input, float * const *output)
            {
                assert(instance);
                m_dynlib.fnProcessAudio_Planar(instance, input, output);
            }
 
            template<typename T>
        std::vector<T> ProcessAnyAudio(const std::vector<T> input)
            {
                assert(instance);
                std::vector<T> output;
                unsigned int out_offset=0;
                unsigned int in_offset=0;
                unsigned int todo = input.size();
                while (todo>0) {
                    unsigned int left = AddAudio(&input[in_offset], todo);
                    unsigned int out_avail = m_dynlib.fnGetOutputCount(instance);
                    output.resize(out_offset + out_avail);
                    GetAudio(&output[out_offset], out_avail);
                    out_offset+=out_avail;
                    in_offset += todo-left;
                    todo=left;
                }
                return output;
            }
 
        class CClient {
            public:
                CClient(sound4cl_CInstance* instance, CProcessor& dynlib)
                : m_dynlib(dynlib)
                    {
                        assert(instance);
                        client=m_dynlib.fnNewClient(instance);
                        if (!client) throw std::bad_alloc();
                    }
                // non-copyable
                CClient( const CInstance& ) = delete;
                CClient& operator=( const CInstance& ) = delete;
                ~CClient()
                    {
                        if (client) {
                            m_dynlib.fnDeleteClient(client);
                            client=nullptr;
                        }
                    }
                std::string ProcessJson(const std::string &request, bool *NeedSave = nullptr)
                    {
                        assert(client);
                        int need_save=0;
                        const char *canswer = m_dynlib.fnProcessJson(client, request.c_str(), &need_save);
                        if (!canswer) return {};
                        std::string answer(canswer);
                        m_dynlib.fnFreeJsonAnswer (canswer);
                        if (NeedSave) {
                            *NeedSave=(need_save!=0);
                        }
                        return answer;
                    }
            private:
                CProcessor& m_dynlib;
                sound4cl_CClientInstance *client = nullptr;
        };
        std::shared_ptr<CClient> NewClient()
            {
                assert(instance);
                return std::make_shared<CClient>(instance, m_dynlib);
            }
 
    protected:
            template<typename T>
        unsigned int AddAudio(const T* payload, unsigned int nFrame)
            {
                assert(instance);
                return m_dynlib.fnAddAudio(instance, reinterpret_cast<const T*>(payload), nFrame, helper::SampleFormat<T>::format);
            }
            template<typename T>
        unsigned int GetAudio(T* payload, unsigned int max_nFrame)
            {
                assert(instance);
                return m_dynlib.fnGetAudio(instance, reinterpret_cast<T*>(payload), max_nFrame, helper::SampleFormat<T>::format);
            }
 
    private:
        CProcessor& m_dynlib;
        sound4cl_CParameters* params = nullptr;
        sound4cl_CInstance* instance = nullptr;
        std::thread update_thread;
        std::vector< std::pair<std::string,std::string> > init_metadata;
        uint64_t webserver = SOUND4_INVALID_WEBSERVER_ID;
    };
 
}; // namespace sound4
 
 
// bridge C callbacks to CPresetLoader
extern "C" {
    static char *sound4cl_custom_reader(const fs_char *filename, void* userdata) {
        sound4::CPresetLoader *preset_loader=reinterpret_cast<sound4::CPresetLoader*>(userdata);
        std::string content=preset_loader->Read(filename);
        return strdup(content.c_str());
    }
    static void sound4cl_custom_reader_free(char *content, void* userdata) {
        if (!content) return;
        free(content);
    }
    static int sound4cl_custom_writer(const fs_char *filename, const char *content, void* userdata) {
        sound4::CPresetLoader *preset_loader=reinterpret_cast<sound4::CPresetLoader*>(userdata);
        auto res=preset_loader->Write(filename,content);
        return res?0:-1;
    }
    static int sound4cl_custom_exists(const fs_char *filename, void* userdata) {
        sound4::CPresetLoader *preset_loader=reinterpret_cast<sound4::CPresetLoader*>(userdata);
        auto res=preset_loader->Exists(filename);
        return res?0:-1;
    }
    static fs_char** sound4cl_custom_getall(void* userdata) {
        sound4::CPresetLoader *preset_loader=reinterpret_cast<sound4::CPresetLoader*>(userdata);
        auto res=preset_loader->GetAll();
        fs_char**all=(fs_char**)malloc((res.size()+1)*sizeof(const fs_char*));
        for (size_t n=0;n<res.size();n++) {
            all[n]=fs_strdup(res[n].c_str());
        }
        all[res.size()]=nullptr;
        return all;
    }
    static void sound4cl_custom_getall_free(fs_char** all, void* userdata) {
        if (!all) return;
        for (fs_char** one=all;*one;one++) {
            free(*one);
        }
        free(all);
    }
    static int sound4cl_custom_remove(const fs_char *filename, void* userdata) {
        sound4::CPresetLoader *preset_loader=reinterpret_cast<sound4::CPresetLoader*>(userdata);
        auto res=preset_loader->Remove(filename);
        return res?0:-1;
    }
    static int sound4cl_custom_rename(const fs_char *from, const fs_char *to, void* userdata) {
        sound4::CPresetLoader *preset_loader=reinterpret_cast<sound4::CPresetLoader*>(userdata);
        auto res=preset_loader->Rename(from,to);
        return res?0:-1;
    }
    
};