sound4.impact.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>
 
#ifdef __unix__
 
#elif defined(_WIN32) || defined(WIN32)
    #include <stringapiset.h>
#endif
 
#include "sound4.impact.cl.h"
 
namespace sound4 {
namespace impact {
    static constexpr const char *process_name = "SOUND4 IMPACT.CL";
    static constexpr const char *process_shortname = "impact";
    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;
        };
 
    }; // namespace helper
 
    static inline std::string GetVersion()
        {
            return std::string(impact_GetVersion());
        }
 
    static inline uint GetChunkSizeInFrames()
        {
            return impact_GetChunkSizeInFrames();
        }
 
    static inline uint GetChannelCount()
        {
            return impact_GetChannelCount();
        }
 
    static inline uint GetAudioInputCount()
        {
            return impact_GetAudioInputCount();
        }
 
    static inline uint GetAudioOutputCount()
        {
            return impact_GetAudioOutputCount();
        }
 
    static inline uint GetSampleRate()
        {
            return impact_GetSampleRate();
        }
 
    static inline void SanityCheck()
    {
        // Do some sanity checks
        if (impact_GetSampleRate()!=IMPACT_SAMPLE_RATE) {
            throw std::runtime_error("Bad library sampling rate");
        }
        if (impact_GetChunkSizeInFrames()!=ChunkFrames) {
            throw std::runtime_error("Bad library frame size");
        }
        if (impact_GetChannelCount()!=IMPACT_CHANNEL_COUNT) {
            throw std::runtime_error("Bad library channel count");
        }
        if (impact_GetAudioInputCount()!=IMPACT_AUDIO_INPUT_COUNT) {
            throw std::runtime_error("Bad library input count");
        }
        if (impact_GetAudioOutputCount()!=IMPACT_AUDIO_OUTPUT_COUNT) {
            throw std::runtime_error("Bad library output count");
        }
    }
 
    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(LogSeverity severity)
        {
            impact_SetLogSeverity(severity);
        }
    static inline void SetLoggerCallback(log_cb_t cb)
        {
            _log_cb=cb;
            impact_SetLoggerCallback(&_log_cb_c);
        }
 
    class CInstance {
    public:
        CInstance()
            {
                SanityCheck();
                params = impact_NewParameters();
                if (!params) throw std::bad_alloc();
            }
        // non-copyable
        CInstance( const CInstance& ) = delete;
        CInstance& operator=( const CInstance& ) = delete;
        ~CInstance()
            {
                Stop();
                if (params) impact_FreeParameters(params);
            }
       bool IsOk() const { return instance!=nullptr; }
        void SetParam(const std::string& name, const std::string& value)
            {
                assert(params);
                impact_SetParameter(params, name.c_str(), value.c_str());
            }
        std::string GetParam(const std::string& name)
            {
                assert(params);
                auto c_value=impact_GetParameter(params, name.c_str());
                std::string ret(c_value);
                impact_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 = impact_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](){
                    OnUpdateThreadStart();
                    impact_StartUpdateThread(instance, json_port);
                    OnUpdateThreadStop();
                });
                if (impact_WaitUpdateThreadReady(instance, 5000)<0) {
                    return false;
                }
                return true;
            }
 
        // 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);
                webserver = impact_Webserver(http_port,https_port,instance);
                if (webserver==SOUND4_INVALID_WEBSERVER_ID) {
                    return false;
                }
                int web_status=impact_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) {
                    impact_Webserver_Stop(webserver, 1000);
                    webserver = SOUND4_INVALID_WEBSERVER_ID;
                }
            }
        void Stop()
            {
                if (!instance) return;
                StopWebServer();
                if (update_thread.joinable()) {
                    impact_StopUpdateThread(instance); // this will exit the update thread
                    update_thread.join();
                }
                impact_ExitProcess(instance);
                instance=nullptr;
            }
 
        uint GetEstimatedDelay()
            {
                assert(instance);
                return impact_GetEstimatedDelay(instance);
            }
 
        std::array<float,InputSampleSize>& GetBufferIn()
            {
                assert(instance);
                float *buf=impact_GetBufferIn(instance);
                return reinterpret_cast< std::array<float,InputSampleSize>& >(*buf);
 
            }
        std::array<float,OutputSampleSize>& GetBufferOut()
            {
                assert(instance);
                float *buf= impact_GetBufferOut(instance);
                return reinterpret_cast< std::array<float,OutputSampleSize>& >(*buf);
            }
        void ProcessAudio()
            {
                assert(instance);
                impact_ProcessAudio(instance, impact_GetBufferIn(instance), impact_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);
                impact_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 = impact_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)
                    {
                        assert(instance);
                        client=impact_NewClient(instance);
                        if (!client) throw std::bad_alloc();
                    }
                // non-copyable
                CClient( const CInstance& ) = delete;
                CClient& operator=( const CInstance& ) = delete;
                ~CClient()
                    {
                        if (client) {
                            impact_DeleteClient(client);
                            client=nullptr;
                        }
                    }
                std::string ProcessJson(const std::string &request, bool *NeedSave = nullptr)
                    {
                        assert(client);
                        int need_save=0;
                        const char *canswer = impact_ProcessJson(client, request.c_str(), &need_save);
                        if (!canswer) return {};
                        std::string answer(canswer);
                        impact_FreeJsonAnswer (canswer);
                        if (NeedSave) {
                            *NeedSave=(need_save!=0);
                        }
                        return answer;
                    }
            private:
                impact_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 impact_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 impact_GetAudio(instance, reinterpret_cast<T*>(payload), max_nFrame, helper::SampleFormat<T>::format);
            }
 
    private:
        impact_CParameters* params = nullptr;
        impact_CInstance* instance = nullptr;
        std::thread update_thread;
        uint64_t webserver = SOUND4_INVALID_WEBSERVER_ID;
    };
 
}; // namespace impact
}; // namespace sound4