sound4.bigvoice.cl.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>
 
#include "sound4.bigvoice.cl.h"
 
 
// Filesystem path char type
#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 *bigvoice_custom_reader(const fs_char *filename, void* userdata);
    static void bigvoice_custom_reader_free(char *content, void* userdata);
    static int bigvoice_custom_writer(const fs_char *filename, const char *content, void* userdata);
    static int bigvoice_custom_exists(const fs_char *filename, void* userdata);
    static fs_char** bigvoice_custom_getall(void* userdata);
    static void bigvoice_custom_getall_free(fs_char** all, void* userdata);
    static int bigvoice_custom_remove(const fs_char *filename, void* userdata);
    static int bigvoice_custom_rename(const fs_char *from, const fs_char *to, void* userdata);
};
 
namespace sound4 {
namespace bigvoice {
    static constexpr const char *process_name = "SOUND4 BIGVOICE.CL";
    static constexpr const char *process_shortname = "bigvoice";
    using SampleFormat = bigvoice_SampleFormat;
    const size_t ChunkFrames=BIGVOICE_AUDIOFRAME_COUNT;
    const size_t InputChannels=BIGVOICE_CHANNEL_COUNT*BIGVOICE_AUDIO_INPUT_COUNT;
    const size_t OutputChannels=BIGVOICE_CHANNEL_COUNT*BIGVOICE_AUDIO_OUTPUT_COUNT;
    const size_t InputSampleSize=ChunkFrames*InputChannels;
    const size_t OutputSampleSize=ChunkFrames*OutputChannels;
    const size_t SampleRate=BIGVOICE_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 bigvoice_SampleFormat format = S16_NATIVE;
        };
            template<>
        struct SampleFormat<int32_t> {
            const bigvoice_SampleFormat format = S32_NATIVE;
        };
            template<>
        struct SampleFormat<float> {
            const bigvoice_SampleFormat format = F32_NATIVE;
        };
 
        // --------------------------------------------------------------
        static inline void AudioConvertFrom(const uint8_t *payload, float *output, size_t nSpl, bigvoice_SampleFormat fmt) {
            bigvoice_AudioConvertFrom(payload, output, nSpl, fmt);
        }
 
        static inline void AudioConvertTo(const float *input, uint8_t *payload, size_t nSpl, bigvoice_SampleFormat fmt) {
            bigvoice_AudioConvertTo(input, payload, nSpl, fmt);
        }
 
        static inline void StereoToMono(const float *input, float *output, size_t nFrame) {
            bigvoice_StereoToMono(input, output, nFrame);
        }
 
        static inline void MonoToStereo(const float *input, float *output, size_t nFrame) {
            bigvoice_MonoToStereo(input, output, nFrame);
        }
 
        static inline void StereoToMono_Planar(const float *inputL, const float *inputR, float *output, size_t nFrame) {
            bigvoice_StereoToMono_Planar(inputL, inputR, output, nFrame);
        }
 
        static inline void MonoToStereo_Planar(const float *input, float *outputL, float *outputR, size_t nFrame) {
            bigvoice_MonoToStereo_Planar(input, outputL, outputR, nFrame);
        }
 
        static inline void AudioMonoFromLiveStereo(const uint8_t *payload, float *output) {
            bigvoice_AudioMonoFromLiveStereo(payload, output);
        }
 
        static inline void AudioMonoToLiveStereo(const float *input, uint8_t *payload) {
            bigvoice_AudioMonoToLiveStereo(input, payload);
        }
 
    }; // namespace helper
 
    static inline std::string GetVersion()
        {
            return std::string(bigvoice_GetVersion());
        }
 
    static inline unsigned int GetChunkSizeInFrames()
        {
            return bigvoice_GetChunkSizeInFrames();
        }
 
    static inline std::vector<unsigned int> GetPossibleChunkSizeInFrames()
        {
            std::vector<unsigned int> list;
            for (unsigned int* src=bigvoice_GetPossibleChunkSizeInFrames();*src;src++) {
                list.push_back(*src);
            }
            return list;
        }
 
    static inline unsigned int GetChannelCount()
        {
            return bigvoice_GetChannelCount();
        }
 
    static inline unsigned int GetAudioInputCount()
        {
            return bigvoice_GetAudioInputCount();
        }
 
    static inline unsigned int GetAudioOutputCount()
        {
            return bigvoice_GetAudioOutputCount();
        }
 
    static inline unsigned int GetSampleRate()
        {
            return bigvoice_GetSampleRate();
        }
 
    static inline void SanityCheck(bool a_bCheckFrames = true)
    {
        // Do some sanity checks
        if (bigvoice_GetSampleRate()!=BIGVOICE_SAMPLE_RATE) {
            throw std::runtime_error("Bad library sampling rate");
        }
        if (a_bCheckFrames && bigvoice_GetChunkSizeInFrames()!=ChunkFrames) {
            throw std::runtime_error("Bad library frame size");
        }
        if (bigvoice_GetChannelCount()!=BIGVOICE_CHANNEL_COUNT) {
            throw std::runtime_error("Bad library channel count");
        }
        if (bigvoice_GetAudioInputCount()!=BIGVOICE_AUDIO_INPUT_COUNT) {
            throw std::runtime_error("Bad library input count");
        }
        if (bigvoice_GetAudioOutputCount()!=BIGVOICE_AUDIO_OUTPUT_COUNT) {
            throw std::runtime_error("Bad library output count");
        }
    }
 
    static inline std::string GetFormatName(const SampleFormat fmt)
        {
            return std::string(bigvoice_GetFormatName(fmt));
        }
 
    static inline SampleFormat GetFormatFromName(const std::string& name)
        {
            return bigvoice_GetFormatFromName(name.c_str());
        }
 
    static inline unsigned int GetBytesFromFormat(const SampleFormat fmt)
        {
            return bigvoice_GetBytesFromFormat(fmt);
        }
 
    using LogSeverity = bigvoice_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(bigvoice_LogSeverity severity, const char *c_msg) {
            _log_cb(severity, std::string(c_msg));
        }
    }
    static inline void SetLogSeverity(LogSeverity severity)
        {
            bigvoice_SetLogSeverity(severity);
        }
    static inline void SetLoggerCallback(log_cb_t cb)
        {
            _log_cb=cb;
            bigvoice_SetLoggerCallback(&_log_cb_c);
        }
 
#if BIGVOICE_HAS_CLOUDBUS
    class CBus {
        public:
            CBus()
                : m_bus(bigvoice_NewBus()) {}
            ~CBus()
                {
                    bigvoice_FreeBus(m_bus);
                    m_bus = nullptr;
                }
            bigvoice_CBus *Get() const { return m_bus; }
        private:
            bigvoice_CBus *m_bus;
    };
#endif // BIGVOICE_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 = bigvoice_PresetChange_Kind;
 
    class CInstance {
    public:
        CInstance()
            {
                params = bigvoice_NewParameters();
                if (!params) throw std::bad_alloc();
            }
        // non-copyable
        CInstance( const CInstance& ) = delete;
        CInstance& operator=( const CInstance& ) = delete;
        virtual ~CInstance()
            {
                Stop();
                if (params) bigvoice_FreeParameters(params);
            }
       bool IsOk() const { return instance!=nullptr; }
        void SetParam(const std::string& name, const std::string& value)
            {
                assert(params);
                bigvoice_SetParameter(params, name.c_str(), value.c_str());
            }
        std::string GetParam(const std::string& name)
            {
                assert(params);
                auto c_value=bigvoice_GetParameter(params, name.c_str());
                std::string ret(c_value);
                bigvoice_FreeParameterValue(c_value);
                return ret;
            }
 
#if BIGVOICE_HAS_CLOUDBUS
            void SetBus(const CBus& bus) {
                assert(params);
                bigvoice_SetInstanceBus(params,bus.Get());
            }
#endif // BIGVOICE_HAS_CLOUDBUS
 
        void SetPresetManager(CPresetLoader *preset_manager)
            {
                if (!preset_manager) return;
                assert(params);
                bigvoice_SetPresetManager(params,
                    bigvoice_custom_reader,
                    bigvoice_custom_reader_free,
                    bigvoice_custom_writer,
                    bigvoice_custom_exists,
                    bigvoice_custom_getall,
                    bigvoice_custom_getall_free,
                    bigvoice_custom_remove,
                    bigvoice_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=12)
            {
                assert(!instance);
                std::string l_save_path;
                if (!save_path.empty()) {
                    l_save_path = save_path.u8string();
                }
                instance = bigvoice_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);
                if (!instance) return false;
                if (!init_metadata.empty()) {
                    for (auto&& [key,value]: init_metadata) {
                        bigvoice_SetMetadata(instance, key.c_str(), value.c_str());
                    }
                    init_metadata.clear();
                }
                update_thread = std::thread([this, json_port](){
                    OnUpdateThreadStart();
                    bigvoice_StartUpdateThread(instance, json_port);
                    OnUpdateThreadStop();
                });
                int timeout=5000;
                #ifdef DEBUG
                    timeout=60*1000; // For debugger pauses
                #endif
                if (bigvoice_WaitUpdateThreadReady(instance, timeout)<0) {
                    return false;
                }
                return true;
            }
 
        unsigned int GetChunkFrames() {
            if (instance) {
                return bigvoice_GetProcessChunkFrames(instance);
            }
            return 0;
        }
 
        void PresetManager_InformChange(const std::filesystem::path& relative_path, PresetChange_Kind change_kind)
            {
                bigvoice_PresetManager_InformChange(instance, relative_path.c_str(), (bigvoice_PresetChange_Kind) change_kind);
            }
 
        void SetMetadata(const std::string& key, const char* value)
            {
                if (instance) {
                    bigvoice_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) {
                    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;
                    
                    bigvoice_SetMetadataMulti(instance, keyvalue);
 
                    delete[] keyvalue;
                } 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;
                const char** c_values = bigvoice_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} );
                        }
                    }
                    bigvoice_FreeMetadataInfos(instance, c_values);
                }
                return values;
            }
 
        virtual void OnUpdateThreadStart() {}
        virtual void OnUpdateThreadStop() {}
 
#if BIGVOICE_HAS_WEBSERVER
        bool StartWebServer(int http_port, int https_port=0)
            {
                assert(instance);
                assert(webserver==SOUND4_INVALID_WEBSERVER_ID);
                webserver = bigvoice_Webserver(http_port,https_port,instance);
                if (webserver==SOUND4_INVALID_WEBSERVER_ID) {
                    return false;
                }
                int web_status=bigvoice_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(int timeout_ms = 1000)
            {
                if (webserver != SOUND4_INVALID_WEBSERVER_ID) {
                    bigvoice_Webserver_Stop(webserver, timeout_ms);
                    webserver = SOUND4_INVALID_WEBSERVER_ID;
                }
            }
 
        void SetWebServerAppHealth(int httpcode, const std::string& contenttype, const std::string& content)
            {
                assert(instance);
                bigvoice_Webserver_SetAppHealth(instance, httpcode, contenttype.c_str(), content.c_str());
            }
        void GetWebServerAppHealth(int &httpcode, std::string& contenttype, std::string& content)
            {
                assert(instance);
                char* c_contenttype=nullptr;
                char* c_content=nullptr;
                bigvoice_Webserver_GetAppHealth(instance, &httpcode, &c_contenttype, &c_content);
                contenttype=c_contenttype;
                content=c_content;
                bigvoice_Webserver_FreeString(c_contenttype);
                bigvoice_Webserver_FreeString(c_content);
        }
#endif // BIGVOICE_HAS_WEBSERVER
 
        int Terminate()
            {
                if (!instance) return 0;
                return bigvoice_TerminateProcess(instance);
            }
 
        void Stop()
            {
                if (!instance) return;
#if BIGVOICE_HAS_WEBSERVER
                StopWebServer();
#endif // BIGVOICE_HAS_WEBSERVER
                if (update_thread.joinable()) {
                    bigvoice_StopUpdateThread(instance); // this will exit the update thread
                    update_thread.join();
                }
                bigvoice_ExitProcess(instance);
                instance=nullptr;
            }
 
        unsigned int GetEstimatedDelay()
            {
                assert(instance);
                return bigvoice_GetEstimatedDelay(instance);
            }
 
        std::array<float,InputSampleSize>& GetBufferIn()
            {
                assert(instance);
                float *buf=bigvoice_GetBufferIn(instance);
                return reinterpret_cast< std::array<float,InputSampleSize>& >(*buf);
 
            }
        std::array<float,OutputSampleSize>& GetBufferOut()
            {
                assert(instance);
                float *buf= bigvoice_GetBufferOut(instance);
                return reinterpret_cast< std::array<float,OutputSampleSize>& >(*buf);
            }
        void ProcessAudio()
            {
                assert(instance);
                bigvoice_ProcessAudio(instance, bigvoice_GetBufferIn(instance), bigvoice_GetBufferOut(instance));
            }
        void ProcessAudio_Planar(float const * const *input, float * const *output)
            {
                assert(instance);
                bigvoice_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 = bigvoice_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(bigvoice_CInstance* instance)
                    {
                        assert(instance);
                        client=bigvoice_NewClient(instance);
                        if (!client) throw std::bad_alloc();
                    }
                // non-copyable
                CClient( const CInstance& ) = delete;
                CClient& operator=( const CInstance& ) = delete;
                ~CClient()
                    {
                        if (client) {
                            bigvoice_DeleteClient(client);
                            client=nullptr;
                        }
                    }
                std::string ProcessJson(const std::string &request, bool *NeedSave = nullptr)
                    {
                        assert(client);
                        int need_save=0;
                        const char *canswer = bigvoice_ProcessJson(client, request.c_str(), &need_save);
                        if (!canswer) return {};
                        std::string answer(canswer);
                        bigvoice_FreeJsonAnswer (canswer);
                        if (NeedSave) {
                            *NeedSave=(need_save!=0);
                        }
                        return answer;
                    }
            private:
                bigvoice_CClientInstance *client = nullptr;
        };
        std::shared_ptr<CClient> NewClient()
            {
                assert(instance);
                return std::make_shared<CClient>(instance);
            }
 
        bool SaveState() {
            assert(instance);
            if (bigvoice_SaveState(instance)!=0) {
                return false;
            }
            return true;
        }
 
    protected:
            template<typename T>
        unsigned int AddAudio(const T* payload, unsigned int nFrame)
            {
                assert(instance);
                return bigvoice_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 bigvoice_GetAudio(instance, reinterpret_cast<T*>(payload), max_nFrame, helper::SampleFormat<T>::format);
            }
 
    private:
        bigvoice_CParameters* params = nullptr;
        bigvoice_CInstance* instance = nullptr;
        std::thread update_thread;
        std::vector< std::pair<std::string,std::string> > init_metadata;
#if BIGVOICE_HAS_WEBSERVER
        uint64_t webserver = SOUND4_INVALID_WEBSERVER_ID;
#endif // BIGVOICE_HAS_WEBSERVER
    };
 
}; // namespace bigvoice
}; // namespace sound4
 
// bridge C callbacks to CPresetLoader
extern "C" {
    static char *bigvoice_custom_reader(const fs_char *filename, void* userdata) {
        sound4::bigvoice::CPresetLoader *preset_loader=reinterpret_cast<sound4::bigvoice::CPresetLoader*>(userdata);
        std::string content=preset_loader->Read(filename);
        return strdup(content.c_str());
    }
    static void bigvoice_custom_reader_free(char *content, void* userdata) {
        if (!content) return;
        free(content);
    }
    static int bigvoice_custom_writer(const fs_char *filename, const char *content, void* userdata) {
        sound4::bigvoice::CPresetLoader *preset_loader=reinterpret_cast<sound4::bigvoice::CPresetLoader*>(userdata);
        auto res=preset_loader->Write(filename,content);
        return res?0:-1;
    }
    static int bigvoice_custom_exists(const fs_char *filename, void* userdata) {
        sound4::bigvoice::CPresetLoader *preset_loader=reinterpret_cast<sound4::bigvoice::CPresetLoader*>(userdata);
        auto res=preset_loader->Exists(filename);
        return res?0:-1;
    }
    static fs_char** bigvoice_custom_getall(void* userdata) {
        sound4::bigvoice::CPresetLoader *preset_loader=reinterpret_cast<sound4::bigvoice::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 bigvoice_custom_getall_free(fs_char** all, void* userdata) {
        if (!all) return;
        for (fs_char** one=all;*one;one++) {
            free(*one);
        }
        free(all);
    }
    static int bigvoice_custom_remove(const fs_char *filename, void* userdata) {
        sound4::bigvoice::CPresetLoader *preset_loader=reinterpret_cast<sound4::bigvoice::CPresetLoader*>(userdata);
        auto res=preset_loader->Remove(filename);
        return res?0:-1;
    }
    static int bigvoice_custom_rename(const fs_char *from, const fs_char *to, void* userdata) {
        sound4::bigvoice::CPresetLoader *preset_loader=reinterpret_cast<sound4::bigvoice::CPresetLoader*>(userdata);
        auto res=preset_loader->Rename(from,to);
        return res?0:-1;
    }
    
};