sound4.impact.cl_dyn.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
 
// Needed to have function declarations
#include "sound4.impact.cl.h"
 
 
#ifdef _WIN32
    #include <stringapiset.h>
    #include <wchar.h>
    #define fs_strdup wcsdup
#else // !_WIN32
    #define fs_strdup strdup
#endif // !_WIN32
 
// bridge C callbacks to CPresetLoader
extern "C" {
    static char *impact_custom_reader(const fs_char *filename, void* userdata);
    static void impact_custom_reader_free(char *content, void* userdata);
    static int impact_custom_writer(const fs_char *filename, const char *content, void* userdata);
    static int impact_custom_exists(const fs_char *filename, void* userdata);
    static fs_char** impact_custom_getall(void* userdata);
    static void impact_custom_getall_free(fs_char** all, void* userdata);
    static int impact_custom_remove(const fs_char *filename, void* userdata);
    static int impact_custom_rename(const fs_char *from, const fs_char *to, void* userdata);
};
 
namespace sound4 {
namespace impact {
namespace dyn {
 
    namespace helper {
        // 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
 
    class CDynLib {
    private:
        helper::CDynLoader m_lib;
        bool m_bOK = false;
    public:
        CDynLib() = default;
 
        // All those wrapped functions have the same signature as there C impact_XXX
        helper::DynFuncHolder< decltype(impact_GetVersion             ) > GetVersion             ;
        helper::DynFuncHolder< decltype(impact_GetChunkSizeInFrames   ) > GetChunkSizeInFrames   ;
        helper::DynFuncHolder< decltype(impact_GetChannelCount        ) > GetChannelCount        ;
        helper::DynFuncHolder< decltype(impact_GetAudioInputCount     ) > GetAudioInputCount     ;
        helper::DynFuncHolder< decltype(impact_GetAudioOutputCount    ) > GetAudioOutputCount    ;
        helper::DynFuncHolder< decltype(impact_GetSampleRate          ) > GetSampleRate          ;
        helper::DynFuncHolder< decltype(impact_SetLoggerCallback      ) > SetLoggerCallback      ;
        helper::DynFuncHolder< decltype(impact_SetLogSeverity         ) > SetLogSeverity         ;
        helper::DynFuncHolder< decltype(impact_NewParameters          ) > NewParameters          ;
        helper::DynFuncHolder< decltype(impact_FreeParameters         ) > FreeParameters         ;
        helper::DynFuncHolder< decltype(impact_SetParameter           ) > SetParameter           ;
        helper::DynFuncHolder< decltype(impact_GetParameter           ) > GetParameter           ;
        helper::DynFuncHolder< decltype(impact_FreeParameterValue     ) > FreeParameterValue     ;
        helper::DynFuncHolder< decltype(impact_InitProcess            ) > InitProcess            ;
        helper::DynFuncHolder< decltype(impact_InitProcess2           ) > InitProcess2           ;
        helper::DynFuncHolder< decltype(impact_TerminateProcess       ) > TerminateProcess       ;
        helper::DynFuncHolder< decltype(impact_ExitProcess            ) > ExitProcess            ;
        helper::DynFuncHolder< decltype(impact_StartUpdateThread      ) > StartUpdateThread      ;
        helper::DynFuncHolder< decltype(impact_StopUpdateThread       ) > StopUpdateThread       ;
        helper::DynFuncHolder< decltype(impact_WaitUpdateThreadReady  ) > WaitUpdateThreadReady  ;
        helper::DynFuncHolder< decltype(impact_ProcessAudio           ) > ProcessAudio           ;
        helper::DynFuncHolder< decltype(impact_ProcessAudio_Planar    ) > ProcessAudio_Planar    ;
        helper::DynFuncHolder< decltype(impact_GetBufferIn            ) > GetBufferIn            ;
        helper::DynFuncHolder< decltype(impact_GetBufferOut           ) > GetBufferOut           ;
        helper::DynFuncHolder< decltype(impact_GetEstimatedDelay      ) > GetEstimatedDelay      ;
        helper::DynFuncHolder< decltype(impact_GetFormatName          ) > GetFormatName          ;
        helper::DynFuncHolder< decltype(impact_GetFormatFromName      ) > GetFormatFromName      ;
        helper::DynFuncHolder< decltype(impact_GetBytesFromFormat     ) > GetBytesFromFormat     ;
        helper::DynFuncHolder< decltype(impact_GetMaxPacketFrame      ) > GetMaxPacketFrame      ;
        helper::DynFuncHolder< decltype(impact_AddAudio               ) > AddAudio               ;
        helper::DynFuncHolder< decltype(impact_AddPadAudio            ) > AddPadAudio            ;
        helper::DynFuncHolder< decltype(impact_GetOutputCount         ) > GetOutputCount         ;
        helper::DynFuncHolder< decltype(impact_GetAudio               ) > GetAudio               ;
        helper::DynFuncHolder< decltype(impact_AudioConvertFrom       ) > AudioConvertFrom       ;
        helper::DynFuncHolder< decltype(impact_AudioConvertTo         ) > AudioConvertTo         ;
        helper::DynFuncHolder< decltype(impact_StereoToMono           ) > StereoToMono           ;
        helper::DynFuncHolder< decltype(impact_MonoToStereo           ) > MonoToStereo           ;
        helper::DynFuncHolder< decltype(impact_AudioMonoFromLiveStereo) > AudioMonoFromLiveStereo;
        helper::DynFuncHolder< decltype(impact_AudioMonoToLiveStereo  ) > AudioMonoToLiveStereo  ;
        helper::DynFuncHolder< decltype(impact_NewClient              ) > NewClient              ;
        helper::DynFuncHolder< decltype(impact_DeleteClient           ) > DeleteClient           ;
        helper::DynFuncHolder< decltype(impact_ProcessJson            ) > ProcessJson            ;
        helper::DynFuncHolder< decltype(impact_FreeJsonAnswer         ) > FreeJsonAnswer         ;
        helper::DynFuncHolder< decltype(impact_SaveState              ) > SaveState              ;
#if IMPACT_HAS_WEBSERVER
        helper::DynFuncHolder< decltype(impact_Webserver_tcp          ) > Webserver_tcp          ;
        helper::DynFuncHolder< decltype(impact_Webserver_tcp2         ) > Webserver_tcp2         ;
        helper::DynFuncHolder< decltype(impact_Webserver              ) > Webserver              ;
        helper::DynFuncHolder< decltype(impact_Webserver_Stop         ) > Webserver_Stop         ;
        helper::DynFuncHolder< decltype(impact_Webserver_Status       ) > Webserver_Status       ;
#endif // IMPACT_HAS_WEBSERVER
 
        // added 2023-03-22
        helper::DynFuncHolder< decltype(impact_StereoToMono_Planar    ) > StereoToMono_Planar    ;
        helper::DynFuncHolder< decltype(impact_MonoToStereo_Planar    ) > MonoToStereo_Planar    ;
 
        // added 2023-05-22
        helper::DynFuncHolder< decltype(impact_SetMetadata            ) > SetMetadata            ;
        helper::DynFuncHolder< decltype(impact_GetMetadataInfos       ) > GetMetadataInfos       ;
        helper::DynFuncHolder< decltype(impact_FreeMetadataInfos      ) > FreeMetadataInfos      ;
 
        // added 2023-06-20
        helper::DynFuncHolder< decltype(impact_SetPresetManager                ) > SetPresetManager      ;
        helper::DynFuncHolder< decltype(impact_PresetManager_InformChange      ) > PresetManager_InformChange      ;
 
        // added 2023-09-21
        helper::DynFuncHolder< decltype(impact_GetPossibleChunkSizeInFrames    ) > GetPossibleChunkSizeInFrames   ;
        helper::DynFuncHolder< decltype(impact_GetProcessChunkFrames           ) > GetProcessChunkFrames   ;
        helper::DynFuncHolder< decltype(impact_InitProcess3                    ) > InitProcess3           ;
 
#if IMPACT_HAS_CLOUDBUS
        // added 2023-06-26
        helper::DynFuncHolder< decltype(impact_NewBus                 ) > NewBus      ;
        helper::DynFuncHolder< decltype(impact_FreeBus                ) > FreeBus      ;
        helper::DynFuncHolder< decltype(impact_SetInstanceBus         ) > SetInstanceBus      ;
#endif // IMPACT_HAS_CLOUDBUS
 
        // added 2024-02-19
        helper::DynFuncHolder< decltype(impact_SetMetadataMulti       ) > SetMetadataMulti         ;
 
        bool Load(const std::filesystem::path& path = {}) {
            std::string filename;
            #ifdef __unix__
                filename="libsound4.impact.cl.so";
            #else
                filename="sound4.impact.cl.dll";
            #endif
            m_lib.Close();
            // If a path is given, use it directly and do not try other path
            if (!path.empty() && !m_lib.Load(path / filename)) {
                return false;
            } else if (!m_lib.IsOk()) {
                auto thisdir=helper::CDynLoader::GetThisLibraryPath().parent_path();
                #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;
                }
            }
            // Load all C functions
            try {
                GetVersion              = m_lib.GetSymbol< decltype(impact_GetVersion             ) >("impact_GetVersion"             );
                GetChunkSizeInFrames    = m_lib.GetSymbol< decltype(impact_GetChunkSizeInFrames   ) >("impact_GetChunkSizeInFrames"   );
                GetChannelCount         = m_lib.GetSymbol< decltype(impact_GetChannelCount        ) >("impact_GetChannelCount"        );
                GetAudioInputCount      = m_lib.GetSymbol< decltype(impact_GetAudioInputCount     ) >("impact_GetAudioInputCount"     );
                GetAudioOutputCount     = m_lib.GetSymbol< decltype(impact_GetAudioOutputCount    ) >("impact_GetAudioOutputCount"    );
                GetSampleRate           = m_lib.GetSymbol< decltype(impact_GetSampleRate          ) >("impact_GetSampleRate"          );
                SetLoggerCallback       = m_lib.GetSymbol< decltype(impact_SetLoggerCallback      ) >("impact_SetLoggerCallback"      );
                SetLogSeverity          = m_lib.GetSymbol< decltype(impact_SetLogSeverity         ) >("impact_SetLogSeverity"         );
                NewParameters           = m_lib.GetSymbol< decltype(impact_NewParameters          ) >("impact_NewParameters"          );
                FreeParameters          = m_lib.GetSymbol< decltype(impact_FreeParameters         ) >("impact_FreeParameters"         );
                SetParameter            = m_lib.GetSymbol< decltype(impact_SetParameter           ) >("impact_SetParameter"           );
                GetParameter            = m_lib.GetSymbol< decltype(impact_GetParameter           ) >("impact_GetParameter"           );
                FreeParameterValue      = m_lib.GetSymbol< decltype(impact_FreeParameterValue     ) >("impact_FreeParameterValue"     );
                InitProcess             = m_lib.GetSymbol< decltype(impact_InitProcess            ) >("impact_InitProcess"            );
                InitProcess2            = m_lib.GetSymbol< decltype(impact_InitProcess2           ) >("impact_InitProcess2"           );
                TerminateProcess        = m_lib.GetSymbol< decltype(impact_TerminateProcess       ) >("impact_TerminateProcess"       );
                ExitProcess             = m_lib.GetSymbol< decltype(impact_ExitProcess            ) >("impact_ExitProcess"            );
                StartUpdateThread       = m_lib.GetSymbol< decltype(impact_StartUpdateThread      ) >("impact_StartUpdateThread"      );
                StopUpdateThread        = m_lib.GetSymbol< decltype(impact_StopUpdateThread       ) >("impact_StopUpdateThread"       );
                WaitUpdateThreadReady   = m_lib.GetSymbol< decltype(impact_WaitUpdateThreadReady  ) >("impact_WaitUpdateThreadReady"  );
                ProcessAudio            = m_lib.GetSymbol< decltype(impact_ProcessAudio           ) >("impact_ProcessAudio"           );
                ProcessAudio_Planar     = m_lib.GetSymbol< decltype(impact_ProcessAudio_Planar    ) >("impact_ProcessAudio_Planar"    );
                GetBufferIn             = m_lib.GetSymbol< decltype(impact_GetBufferIn            ) >("impact_GetBufferIn"            );
                GetBufferOut            = m_lib.GetSymbol< decltype(impact_GetBufferOut           ) >("impact_GetBufferOut"           );
                GetEstimatedDelay       = m_lib.GetSymbol< decltype(impact_GetEstimatedDelay      ) >("impact_GetEstimatedDelay"      );
                GetFormatName           = m_lib.GetSymbol< decltype(impact_GetFormatName          ) >("impact_GetFormatName"          );
                GetFormatFromName       = m_lib.GetSymbol< decltype(impact_GetFormatFromName      ) >("impact_GetFormatFromName"      );
                GetBytesFromFormat      = m_lib.GetSymbol< decltype(impact_GetBytesFromFormat     ) >("impact_GetBytesFromFormat"     );
                GetMaxPacketFrame       = m_lib.GetSymbol< decltype(impact_GetMaxPacketFrame      ) >("impact_GetMaxPacketFrame"      );
                AddAudio                = m_lib.GetSymbol< decltype(impact_AddAudio               ) >("impact_AddAudio"               );
                AddPadAudio             = m_lib.GetSymbol< decltype(impact_AddPadAudio            ) >("impact_AddPadAudio"            );
                GetOutputCount          = m_lib.GetSymbol< decltype(impact_GetOutputCount         ) >("impact_GetOutputCount"         );
                GetAudio                = m_lib.GetSymbol< decltype(impact_GetAudio               ) >("impact_GetAudio"               );
                AudioConvertFrom        = m_lib.GetSymbol< decltype(impact_AudioConvertFrom       ) >("impact_AudioConvertFrom"       );
                AudioConvertTo          = m_lib.GetSymbol< decltype(impact_AudioConvertTo         ) >("impact_AudioConvertTo"         );
                StereoToMono            = m_lib.GetSymbol< decltype(impact_StereoToMono           ) >("impact_StereoToMono"           );
                MonoToStereo            = m_lib.GetSymbol< decltype(impact_MonoToStereo           ) >("impact_MonoToStereo"           );
                AudioMonoFromLiveStereo = m_lib.GetSymbol< decltype(impact_AudioMonoFromLiveStereo) >("impact_AudioMonoFromLiveStereo");
                AudioMonoToLiveStereo   = m_lib.GetSymbol< decltype(impact_AudioMonoToLiveStereo  ) >("impact_AudioMonoToLiveStereo"  );
                NewClient               = m_lib.GetSymbol< decltype(impact_NewClient              ) >("impact_NewClient"              );
                DeleteClient            = m_lib.GetSymbol< decltype(impact_DeleteClient           ) >("impact_DeleteClient"           );
                ProcessJson             = m_lib.GetSymbol< decltype(impact_ProcessJson            ) >("impact_ProcessJson"            );
                FreeJsonAnswer          = m_lib.GetSymbol< decltype(impact_FreeJsonAnswer         ) >("impact_FreeJsonAnswer"         );
                SaveState               = m_lib.GetSymbol< decltype(impact_SaveState              ) >("impact_SaveState"              );
#if IMPACT_HAS_WEBSERVER
                Webserver_tcp           = m_lib.GetSymbol< decltype(impact_Webserver_tcp          ) >("impact_Webserver_tcp"          );
                Webserver_tcp2          = m_lib.GetSymbol< decltype(impact_Webserver_tcp2         ) >("impact_Webserver_tcp2"         );
                Webserver               = m_lib.GetSymbol< decltype(impact_Webserver              ) >("impact_Webserver"              );
                Webserver_Stop          = m_lib.GetSymbol< decltype(impact_Webserver_Stop         ) >("impact_Webserver_Stop"         );
                Webserver_Status        = m_lib.GetSymbol< decltype(impact_Webserver_Status       ) >("impact_Webserver_Status"       );
#endif // IMPACT_HAS_WEBSERVER
 
                // added 2023-03-22
                StereoToMono_Planar     = m_lib.GetSymbol< decltype(impact_StereoToMono_Planar    ) >("impact_StereoToMono_Planar"    );
                MonoToStereo_Planar     = m_lib.GetSymbol< decltype(impact_MonoToStereo_Planar    ) >("impact_MonoToStereo_Planar"    );
 
            } catch (std::runtime_error& ) {
                return false;
            }
            // C functions allowed to be missing
            try {
                // added 2023-05-22
                SetMetadata             = m_lib.GetSymbol< decltype(impact_SetMetadata            ) >("impact_SetMetadata"            );
                GetMetadataInfos        = m_lib.GetSymbol< decltype(impact_GetMetadataInfos       ) >("impact_GetMetadataInfos"       );
                FreeMetadataInfos       = m_lib.GetSymbol< decltype(impact_FreeMetadataInfos      ) >("impact_FreeMetadataInfos"      );
                // added 2023-06-20
                SetPresetManager            = m_lib.GetSymbol< decltype(impact_SetPresetManager               ) >("impact_SetPresetManager"              );
                PresetManager_InformChange  = m_lib.GetSymbol< decltype(impact_PresetManager_InformChange     ) >("impact_PresetManager_InformChange"    );
 
                // added 2023-09-21
                GetPossibleChunkSizeInFrames = m_lib.GetSymbol< decltype(impact_GetPossibleChunkSizeInFrames  ) >("impact_GetPossibleChunkSizeInFrames"  );
                GetProcessChunkFrames        = m_lib.GetSymbol< decltype(impact_GetProcessChunkFrames         ) >("impact_GetProcessChunkFrames"         );
                InitProcess3                 = m_lib.GetSymbol< decltype(impact_InitProcess3                  ) >("impact_InitProcess3"                  );
 
#if IMPACT_HAS_CLOUDBUS
                // added 2023-06-26
                NewBus                  = m_lib.GetSymbol< decltype(impact_NewBus                 ) >("impact_NewBus"                 );
                FreeBus                 = m_lib.GetSymbol< decltype(impact_FreeBus                ) >("impact_FreeBus"                );
                SetInstanceBus          = m_lib.GetSymbol< decltype(impact_SetInstanceBus         ) >("impact_SetInstanceBus"         );
#endif // IMPACT_HAS_CLOUDBUS
 
                // added 2024-02-19
                SetMetadataMulti        = m_lib.GetSymbol< decltype(impact_SetMetadataMulti       ) >("impact_SetMetadataMulti"       );
 
            }  catch (std::runtime_error& ) {
                // Ignored, handler will take care
            }
 
            m_bOK=true;
            return true;
        }
        bool IsOk() const {
            return m_bOK;
        }
 
    };
 
    
 
    static constexpr const char *process_name = "SOUND4 IMPACT.CL";
    static constexpr const char *process_shortname = "impact";
    using SampleFormat = impact_SampleFormat;
    const size_t ChunkFrames=IMPACT_AUDIOFRAME_COUNT;
    const size_t InputChannels=IMPACT_CHANNEL_COUNT*IMPACT_AUDIO_INPUT_COUNT;
    const size_t OutputChannels=IMPACT_CHANNEL_COUNT*IMPACT_AUDIO_OUTPUT_COUNT;
    const size_t InputSampleSize=ChunkFrames*InputChannels;
    const size_t OutputSampleSize=ChunkFrames*OutputChannels;
    const size_t SampleRate=IMPACT_SAMPLE_RATE;
 
    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 impact_SampleFormat format = S16_NATIVE;
        };
            template<>
        struct SampleFormat<int32_t> {
            const impact_SampleFormat format = S32_NATIVE;
        };
            template<>
        struct SampleFormat<float> {
            const impact_SampleFormat format = F32_NATIVE;
        };
 
 
        static inline void AudioConvertFrom(CDynLib& dynlib, const uint8_t *payload, float *output, size_t nSpl, impact_SampleFormat fmt) {
            dynlib.AudioConvertFrom(payload, output, nSpl, fmt);
        }
        static inline void AudioConvertTo(CDynLib& dynlib, const float *input, uint8_t *payload, size_t nSpl, impact_SampleFormat fmt) {
            dynlib.AudioConvertTo(input, payload, nSpl, fmt);
        }
        static inline void StereoToMono(CDynLib& dynlib, const float *input, float *output, size_t nSpl) {
            dynlib.StereoToMono(input, output, nSpl);
        }
        static inline void MonoToStereo(CDynLib& dynlib, const float *input, float *output, size_t nSpl) {
            dynlib.MonoToStereo(input, output, nSpl);
        }
        static inline void StereoToMono_Planar(CDynLib& dynlib, const float *inputL, const float *inputR, float *output, size_t nSpl) {
            dynlib.StereoToMono_Planar(inputL, inputR, output, nSpl);
        }
        static inline void MonoToStereo_Planar(CDynLib& dynlib, const float *input, float *outputL, float *outputR, size_t nSpl) {
            dynlib.MonoToStereo_Planar(input, outputL, outputR, nSpl);
        }
        static inline void AudioMonoFromLiveStereo(CDynLib& dynlib, const uint8_t *payload, float *output) {
            dynlib.AudioMonoFromLiveStereo(payload, output);
        }
        static inline void AudioMonoToLiveStereo(CDynLib& dynlib, const float *input, uint8_t *payload) {
            dynlib.AudioMonoToLiveStereo(input, payload);
        }
 
    }; // namespace helper
 
    static inline std::string GetVersion(CDynLib& dynlib)
        {
            return std::string(dynlib.GetVersion());
        }
 
    static inline unsigned int GetChunkSizeInFrames(CDynLib& dynlib)
        {
            return dynlib.GetChunkSizeInFrames();
        }
 
    static inline std::vector<unsigned int> GetPossibleChunkSizeInFrames(CDynLib& dynlib)
        {
            std::vector<unsigned int> list;
            if (dynlib.GetPossibleChunkSizeInFrames) {
                for (unsigned int* src=dynlib.GetPossibleChunkSizeInFrames();*src;src++) {
                    list.push_back(*src);
                }
            } else {
                list.push_back(64);
            }
            return list;
        }
 
    static inline unsigned int GetChannelCount(CDynLib& dynlib)
        {
            return dynlib.GetChannelCount();
        }
 
    static inline unsigned int GetAudioInputCount(CDynLib& dynlib)
        {
            return dynlib.GetAudioInputCount();
        }
 
    static inline unsigned int GetAudioOutputCount(CDynLib& dynlib)
        {
            return dynlib.GetAudioOutputCount();
        }
 
    static inline unsigned int GetSampleRate(CDynLib& dynlib)
        {
            return dynlib.GetSampleRate();
        }
 
    static inline void SanityCheck(CDynLib& dynlib, bool a_bCheckFrames = true)
    {
        // Do some sanity checks
        if (dynlib.GetSampleRate()!=IMPACT_SAMPLE_RATE) {
            throw std::runtime_error("Bad library sampling rate");
        }
        if (a_bCheckFrames && dynlib.GetChunkSizeInFrames()!=ChunkFrames) {
            throw std::runtime_error("Bad library frame size");
        }
        if (dynlib.GetChannelCount()!=IMPACT_CHANNEL_COUNT) {
            throw std::runtime_error("Bad library channel count");
        }
        if (dynlib.GetAudioInputCount()!=IMPACT_AUDIO_INPUT_COUNT) {
            throw std::runtime_error("Bad library input count");
        }
        if (dynlib.GetAudioOutputCount()!=IMPACT_AUDIO_OUTPUT_COUNT) {
            throw std::runtime_error("Bad library output count");
        }
    }
 
    static inline std::string GetFormatName(CDynLib& dynlib, const SampleFormat fmt)
        {
            return std::string(dynlib.GetFormatName(fmt));
        }
 
    static inline SampleFormat GetFormatFromName(CDynLib& dynlib, const std::string& name)
        {
            return dynlib.GetFormatFromName(name.c_str());
        }
 
    static inline unsigned int GetBytesFromFormat(CDynLib& dynlib, const SampleFormat fmt)
        {
            return dynlib.GetBytesFromFormat(fmt);
        }
 
    using LogSeverity = impact_LogSeverity;
    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(impact_LogSeverity severity, const char *c_msg) {
            _log_cb(severity, std::string(c_msg));
        }
    }
    static inline void SetLogSeverity(CDynLib& dynlib, LogSeverity severity)
        {
            dynlib.SetLogSeverity(severity);
        }
    static inline void SetLoggerCallback(CDynLib& dynlib, log_cb_t cb)
        {
            _log_cb=cb;
            dynlib.SetLoggerCallback(&_log_cb_c);
        }
 
#if IMPACT_HAS_CLOUDBUS
    class CBus {
        public:
            CBus(CDynLib& dynlib)
                : m_dynlib(dynlib)
                {
                    if (m_dynlib.NewBus) {
                        m_bus=m_dynlib.NewBus();
                    }
                } 
            ~CBus()
                {
                    if (m_bus && m_dynlib.FreeBus) {
                        m_dynlib.FreeBus(m_bus);
                    }
                    m_bus = nullptr;
                }
            impact_CBus *Get() const { return m_bus; }
        private:
            CDynLib& m_dynlib;
            impact_CBus *m_bus;
    };
#endif // IMPACT_HAS_CLOUDBUS
 
    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 = impact_PresetChange_Kind;
 
    class CInstance {
    public:
        CInstance(CDynLib& dynlib)
        : m_dynlib(dynlib) 
            {
                params = m_dynlib.NewParameters();
                if (!params) throw std::bad_alloc();
            }
        // non-copyable
        CInstance( const CInstance& ) = delete;
        CInstance& operator=( const CInstance& ) = delete;
        ~CInstance()
            {
                Stop();
                if (params) m_dynlib.FreeParameters(params);
            }
       bool IsOk() const { return instance!=nullptr; }
        void SetParam(const std::string& name, const std::string& value)
            {
                assert(params);
                m_dynlib.SetParameter(params, name.c_str(), value.c_str());
            }
        std::string GetParam(const std::string& name)
            {
                assert(params);
                auto c_value=m_dynlib.GetParameter(params, name.c_str());
                std::string ret(c_value);
                m_dynlib.FreeParameterValue(c_value);
                return ret;
            }
#if IMPACT_HAS_CLOUDBUS
            void SetBus(const CBus& bus) {
                assert(params);
                if (m_dynlib.SetInstanceBus) {
                    m_dynlib.SetInstanceBus(params,bus.Get());
                }
            }
#endif // IMPACT_HAS_CLOUDBUS
 
        void SetPresetManager(CPresetLoader *preset_manager)
            {
                if (!preset_manager) return;
                if (!m_dynlib.SetPresetManager) return;
                assert(params);
                m_dynlib.SetPresetManager(params,
                    impact_custom_reader,
                    impact_custom_reader_free,
                    impact_custom_writer,
                    impact_custom_exists,
                    impact_custom_getall,
                    impact_custom_getall_free,
                    impact_custom_remove,
                    impact_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=64)
            {
                assert(!instance);
                std::string l_save_path;
                if (!save_path.empty()) {
                    l_save_path = save_path.u8string();
                }
                if (m_dynlib.InitProcess3) {
                    instance = m_dynlib.InitProcess3(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!=64) {
                    return false;
                } else {
                    instance = m_dynlib.InitProcess2(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.SetMetadata(instance, key.c_str(), value.c_str());
                    }
                    init_metadata.clear();
                }
                update_thread = std::thread([this, json_port](){
                    OnUpdateThreadStart();
                    m_dynlib.StartUpdateThread(instance, json_port);
                    OnUpdateThreadStop();
                });
                int timeout=5000;
                #ifdef DEBUG
                    timeout=60*1000; // For debugger pauses
                #endif
                if (m_dynlib.WaitUpdateThreadReady(instance, timeout)<0) {
                    return false;
                }
                return true;
            }
 
        unsigned int GetChunkFrames() {
            if (instance && m_dynlib.GetProcessChunkFrames) {
                return m_dynlib.GetProcessChunkFrames(instance);
            }
            return 64;
        }
 
        void PresetManager_InformChange(const std::filesystem::path& relative_path, PresetChange_Kind change_kind)
            {
                if (m_dynlib.PresetManager_InformChange) {
                    m_dynlib.PresetManager_InformChange(instance, relative_path.c_str(), (impact_PresetChange_Kind) change_kind);
                }
            }
 
        void SetMetadata(const std::string& key, const char* value)
            {
                if (m_dynlib.SetMetadata) {
                    if (instance) {
                        m_dynlib.SetMetadata(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.SetMetadataMulti) {
                        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;
                        
                        impact_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.GetMetadataInfos) {
                    const char** c_values = m_dynlib.GetMetadataInfos(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.FreeMetadataInfos(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() {}
 
#if IMPACT_HAS_WEBSERVER
        bool StartWebServer(int http_port, int https_port=0)
            {
                assert(instance);
                assert(webserver==SOUND4_INVALID_WEBSERVER_ID);
                webserver = m_dynlib.Webserver(http_port,https_port,instance);
                if (webserver==SOUND4_INVALID_WEBSERVER_ID) {
                    return false;
                }
                int web_status=m_dynlib.Webserver_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 (webserver != SOUND4_INVALID_WEBSERVER_ID) {
                    m_dynlib.Webserver_Stop(webserver, 1000);
                    webserver = SOUND4_INVALID_WEBSERVER_ID;
                }
            }
#endif // IMPACT_HAS_WEBSERVER
 
        int Terminate()
            {
                if (!instance) return 0;
                return m_dynlib.TerminateProcess(instance);
            }
 
        void Stop()
            {
                if (!instance) return;
#if IMPACT_HAS_WEBSERVER
                StopWebServer();
#endif // IMPACT_HAS_WEBSERVER
                if (update_thread.joinable()) {
                    m_dynlib.StopUpdateThread(instance); // this will exit the update thread
                    update_thread.join();
                }
                m_dynlib.ExitProcess(instance);
                instance=nullptr;
            }
 
        unsigned int GetEstimatedDelay()
            {
                assert(instance);
                return m_dynlib.GetEstimatedDelay(instance);
            }
 
        std::array<float,InputSampleSize>& GetBufferIn()
            {
                assert(instance);
                float *buf=m_dynlib.GetBufferIn(instance);
                return reinterpret_cast< std::array<float,InputSampleSize>& >(*buf);
 
            }
        std::array<float,OutputSampleSize>& GetBufferOut()
            {
                assert(instance);
                float *buf= m_dynlib.GetBufferOut(instance);
                return reinterpret_cast< std::array<float,OutputSampleSize>& >(*buf);
            }
        void ProcessAudio()
            {
                assert(instance);
                m_dynlib.ProcessAudio(instance, m_dynlib.GetBufferIn(instance), m_dynlib.GetBufferOut(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.ProcessAudio_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.GetOutputCount(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(impact_CInstance* instance, CDynLib& dynlib)
                : m_dynlib(dynlib)
                    {
                        assert(instance);
                        client=m_dynlib.NewClient(instance);
                        if (!client) throw std::bad_alloc();
                    }
                // non-copyable
                CClient( const CInstance& ) = delete;
                CClient& operator=( const CInstance& ) = delete;
                ~CClient()
                    {
                        if (client) {
                            m_dynlib.DeleteClient(client);
                            client=nullptr;
                        }
                    }
                std::string ProcessJson(const std::string &request, bool *NeedSave = nullptr)
                    {
                        assert(client);
                        int need_save=0;
                        const char *canswer = m_dynlib.ProcessJson(client, request.c_str(), &need_save);
                        if (!canswer) return {};
                        std::string answer(canswer);
                        m_dynlib.FreeJsonAnswer (canswer);
                        if (NeedSave) {
                            *NeedSave=(need_save!=0);
                        }
                        return answer;
                    }
            private:
                CDynLib& m_dynlib;
                impact_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.AddAudio(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.GetAudio(instance, reinterpret_cast<T*>(payload), max_nFrame, helper::SampleFormat<T>::format);
            }
 
    private:
        CDynLib& m_dynlib;
        impact_CParameters* params = nullptr;
        impact_CInstance* instance = nullptr;
        std::thread update_thread;
        std::vector< std::pair<std::string,std::string> > init_metadata;
#if IMPACT_HAS_WEBSERVER
        uint64_t webserver = SOUND4_INVALID_WEBSERVER_ID;
#endif // IMPACT_HAS_WEBSERVER
    };
 
}; // namespace dyn
}; // namespace impact
}; // namespace sound4
 
 
// bridge C callbacks to CPresetLoader
extern "C" {
    static char *impact_custom_reader(const fs_char *filename, void* userdata) {
        sound4::impact::dyn::CPresetLoader *preset_loader=reinterpret_cast<sound4::impact::dyn::CPresetLoader*>(userdata);
        std::string content=preset_loader->Read(filename);
        return strdup(content.c_str());
    }
    static void impact_custom_reader_free(char *content, void* userdata) {
        if (!content) return;
        free(content);
    }
    static int impact_custom_writer(const fs_char *filename, const char *content, void* userdata) {
        sound4::impact::dyn::CPresetLoader *preset_loader=reinterpret_cast<sound4::impact::dyn::CPresetLoader*>(userdata);
        auto res=preset_loader->Write(filename,content);
        return res?0:-1;
    }
    static int impact_custom_exists(const fs_char *filename, void* userdata) {
        sound4::impact::dyn::CPresetLoader *preset_loader=reinterpret_cast<sound4::impact::dyn::CPresetLoader*>(userdata);
        auto res=preset_loader->Exists(filename);
        return res?0:-1;
    }
    static fs_char** impact_custom_getall(void* userdata) {
        sound4::impact::dyn::CPresetLoader *preset_loader=reinterpret_cast<sound4::impact::dyn::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 impact_custom_getall_free(fs_char** all, void* userdata) {
        if (!all) return;
        for (fs_char** one=all;*one;one++) {
            free(*one);
        }
        free(all);
    }
    static int impact_custom_remove(const fs_char *filename, void* userdata) {
        sound4::impact::dyn::CPresetLoader *preset_loader=reinterpret_cast<sound4::impact::dyn::CPresetLoader*>(userdata);
        auto res=preset_loader->Remove(filename);
        return res?0:-1;
    }
    static int impact_custom_rename(const fs_char *from, const fs_char *to, void* userdata) {
        sound4::impact::dyn::CPresetLoader *preset_loader=reinterpret_cast<sound4::impact::dyn::CPresetLoader*>(userdata);
        auto res=preset_loader->Rename(from,to);
        return res?0:-1;
    }
    
};