sound4.x1.cloud.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>
 
#ifdef __unix__
 
#elif defined(_WIN32) || defined(WIN32)
    #include <stringapiset.h>
#endif
 
#include "sound4.x1.cloud.h"
 
namespace sound4 {
namespace cloudx1 {
    static constexpr const char *process_name = "SOUND4 x1.CLOUD";
    static constexpr const char *process_shortname = "x1";
    const size_t ChunkFrames=CLOUDX1_AUDIOFRAME_COUNT;
    const size_t InputChannels=CLOUDX1_CHANNEL_COUNT*CLOUDX1_AUDIO_INPUT_COUNT;
    const size_t OutputChannels=CLOUDX1_CHANNEL_COUNT*CLOUDX1_AUDIO_OUTPUT_COUNT;
    const size_t InputSampleSize=ChunkFrames*InputChannels;
    const size_t OutputSampleSize=ChunkFrames*OutputChannels;
    const size_t SampleRate=CLOUDX1_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 cloudx1_SampleFormat format = S16_NATIVE;
        };
            template<>
        struct SampleFormat<int32_t> {
            const cloudx1_SampleFormat format = S32_NATIVE;
        };
            template<>
        struct SampleFormat<float> {
            const cloudx1_SampleFormat format = F32_NATIVE;
        };
 
    }; // namespace helper
 
    static inline std::string GetVersion()
        {
            return std::string(cloudx1_GetVersion());
        }
 
    static inline uint GetChunkSizeInFrames()
        {
            return cloudx1_GetChunkSizeInFrames();
        }
 
    static inline uint GetChannelCount()
        {
            return cloudx1_GetChannelCount();
        }
 
    static inline uint GetAudioInputCount()
        {
            return cloudx1_GetAudioInputCount();
        }
 
    static inline uint GetAudioOutputCount()
        {
            return cloudx1_GetAudioOutputCount();
        }
 
    static inline uint GetSampleRate()
        {
            return cloudx1_GetSampleRate();
        }
 
    static inline void SanityCheck()
    {
        // Do some sanity checks
        if (cloudx1_GetSampleRate()!=CLOUDX1_SAMPLE_RATE) {
            throw std::runtime_error("Bad library sampling rate");
        }
        if (cloudx1_GetChunkSizeInFrames()!=ChunkFrames) {
            throw std::runtime_error("Bad library frame size");
        }
        if (cloudx1_GetChannelCount()!=CLOUDX1_CHANNEL_COUNT) {
            throw std::runtime_error("Bad library channel count");
        }
        if (cloudx1_GetAudioInputCount()!=CLOUDX1_AUDIO_INPUT_COUNT) {
            throw std::runtime_error("Bad library input count");
        }
        if (cloudx1_GetAudioOutputCount()!=CLOUDX1_AUDIO_OUTPUT_COUNT) {
            throw std::runtime_error("Bad library output count");
        }
    }
 
    using LogSeverity = cloudx1_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(cloudx1_LogSeverity severity, const char *c_msg) {
            _log_cb(severity, std::string(c_msg));
        }
    }
    static inline void SetLogSeverity(LogSeverity severity)
        {
            cloudx1_SetLogSeverity(severity);
        }
    static inline void SetLoggerCallback(log_cb_t cb)
        {
            _log_cb=cb;
            cloudx1_SetLoggerCallback(&_log_cb_c);
        }
 
    class CInstance {
    public:
        CInstance()
            {
                SanityCheck();
                params = cloudx1_NewParameters();
                if (!params) throw std::bad_alloc();
            }
        // non-copyable
        CInstance( const CInstance& ) = delete;
        CInstance& operator=( const CInstance& ) = delete;
        ~CInstance()
            {
                Stop();
                if (params) cloudx1_FreeParameters(params);
            }
       bool IsOk() const { return instance!=nullptr; }
        void SetParam(const std::string& name, const std::string& value)
            {
                assert(params);
                cloudx1_SetParameter(params, name.c_str(), value.c_str());
            }
        std::string GetParam(const std::string& name)
            {
                assert(params);
                auto c_value=cloudx1_GetParameter(params, name.c_str());
                std::string ret(c_value);
                cloudx1_FreeParameterValue(c_value);
                return ret;
            }
        bool Create(const std::string& LoginKey, const std::string& RadioName, const std::string& AWS_Access_ID, const std::string& AWS_Access_Secret, const std::string& save_path, int json_port = 0)
            {
                assert(!instance);
                const char *pSavePath = save_path.empty() ? NULL : save_path.c_str(); // allow no storage
                instance = cloudx1_InitProcess2(LoginKey.c_str(), RadioName.c_str(), AWS_Access_ID.c_str(), AWS_Access_Secret.c_str(), pSavePath, params);
                if (!instance) return false;
                update_thread = std::thread([this, json_port](){
                    cloudx1_StartUpdateThread(instance, json_port);
                });
                if (cloudx1_WaitUpdateThreadReady(instance, 5000)<0) {
                    return false;
                }
                return true;
            }
        bool StartWebServer(int http_port, int https_port=0)
            {
                assert(instance);
                assert(webserver==SOUND4_INVALID_WEBSERVER_ID);
                webserver = cloudx1_Webserver(http_port,https_port,instance);
                if (webserver==SOUND4_INVALID_WEBSERVER_ID) {
                    return false;
                }
                int web_status=cloudx1_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) {
                    cloudx1_Webserver_Stop(webserver, 1000);
                    webserver = SOUND4_INVALID_WEBSERVER_ID;
                }
            }
        void Stop()
            {
                if (!instance) return;
                StopWebServer();
                if (update_thread.joinable()) {
                    cloudx1_StopUpdateThread(instance); // this will exit the update thread
                    update_thread.join();
                }
                cloudx1_ExitProcess(instance);
                instance=nullptr;
            }
 
        uint GetEstimatedDelay()
            {
                assert(instance);
                return cloudx1_GetEstimatedDelay(instance);
            }
 
        std::array<float,InputSampleSize>& GetBufferIn()
            {
                assert(instance);
                float *buf=cloudx1_GetBufferIn(instance);
                return reinterpret_cast< std::array<float,InputSampleSize>& >(*buf);
 
            }
        std::array<float,OutputSampleSize>& GetBufferOut()
            {
                assert(instance);
                float *buf= cloudx1_GetBufferOut(instance);
                return reinterpret_cast< std::array<float,OutputSampleSize>& >(*buf);
            }
        void ProcessAudio()
            {
                assert(instance);
                cloudx1_ProcessAudio(instance, cloudx1_GetBufferIn(instance), cloudx1_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)[InputChannels], float * const (&output)[OutputChannels])
            {
                assert(instance);
                cloudx1_ProcessAudio_Planar(instance, input, output);
            }
 
            template<typename T>
        std::vector<T> ProcessAnyAudio(const std::vector<T> input)
            {
                assert(instance);
                std::vector<T> output;
                uint out_offset=0;
                uint in_offset=0;
                uint todo = input.size();
                while (todo>0) {
                    uint left = AddAudio(&input[in_offset], todo);
                    uint out_avail = cloudx1_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(cloudx1_CInstance* instance)
                    {
                        assert(instance);
                        client=cloudx1_NewClient(instance);
                        if (!client) throw std::bad_alloc();
                    }
                // non-copyable
                CClient( const CInstance& ) = delete;
                CClient& operator=( const CInstance& ) = delete;
                ~CClient()
                    {
                        if (client) {
                            cloudx1_DeleteClient(client);
                            client=nullptr;
                        }
                    }
                std::string ProcessJson(const std::string &request, bool *NeedSave = nullptr)
                    {
                        assert(client);
                        int need_save=0;
                        const char *canswer = cloudx1_ProcessJson(client, request.c_str(), &need_save);
                        if (!canswer) return {};
                        std::string answer(canswer);
                        cloudx1_FreeJsonAnswer (canswer);
                        if (NeedSave) {
                            *NeedSave=(need_save!=0);
                        }
                        return answer;
                    }
            private:
                cloudx1_CClientInstance *client = nullptr;
        };
        std::shared_ptr<CClient> NewClient()
            {
                assert(instance);
                return std::make_shared<CClient>(instance);
            }
 
    protected:
            template<typename T>
        uint AddAudio(const T* payload, uint nFrame)
            {
                assert(instance);
                return cloudx1_AddAudio(instance, reinterpret_cast<const T*>(payload), nFrame, helper::SampleFormat<T>::format);
            }
            template<typename T>
        uint GetAudio(T* payload, uint max_nFrame)
            {
                assert(instance);
                return cloudx1_GetAudio(instance, reinterpret_cast<T*>(payload), max_nFrame, helper::SampleFormat<T>::format);
            }
 
    private:
        cloudx1_CParameters* params = nullptr;
        cloudx1_CInstance* instance = nullptr;
        std::thread update_thread;
        uint64_t webserver = SOUND4_INVALID_WEBSERVER_ID;
    };
 
}; // namespace cloudx1
}; // namespace sound4