Sample using C++ interface wrapper with dynamic library loading

C++ example (dynamic link) See full example cpp/sound4.bigvoice.cl-pipe-dyn.cpp.

Dynamic loading

    sound4::bigvoice::dyn::CDynLib dynlib;
    if (!dynlib.Load()) {
        std::cerr << "Failed to load processing library" << std::endl;
        return 1;
    }

Setup and sanity checks

    sound4::bigvoice::dyn::SetLogSeverity(dynlib, verbose5);
    sound4::bigvoice::dyn::SetLoggerCallback(dynlib, MyLogger);
 
    sound4::bigvoice::dyn::CInstance instance(dynlib);
    instance.SetParam("ADMIN_USER","admin");
    instance.SetParam("ADMIN_SECRET","admin");

Sample to create the processing instance

    if (!instance.Create(LoginKey, RadioName, KeyId, AccessKey, {})) {
        std::cerr << "Failed to create the processing instance" << std::endl;
        return 1;
    }

Communicating with the instance

See also

jsonsyntax

        auto client = instance.NewClient();
        auto answer = client->ProcessJson(R"JSON({"get":{"processorname":null}})JSON");
        std::cerr << "Request for processor name returned "<<answer<<std::endl;

Starting a web-server

    if (!instance.StartWebServer(listen_port,0)) {
        std::cerr << "Failed to create the web server on port " << listen_port << std::endl;
        return 1;
    }

Sample processing loop

    while (!stopthread)
    {
        // Read a chunk from stdin
        if (std::fread(instance.GetBufferIn().data(), sizeof(float), sound4::bigvoice::dyn::InputSampleSize, stdin) != sound4::bigvoice::dyn::InputSampleSize) {
            std::cerr << "ProcessLoop: input stopped"<< std::endl;
            stopthread=true;
            break;
        }
        if (stopthread) break;
        // Process it
        instance.ProcessAudio();
        // Write it to stdout
        if (fwrite(instance.GetBufferOut().data(), sizeof(float), sound4::bigvoice::dyn::OutputSampleSize, stdout) != sound4::bigvoice::dyn::OutputSampleSize) {
            std::cerr << "Failed to write audio output" << std::endl;
            stopthread=true;
        }
    }

Custom preset manager

class MyPresetManager : public sound4::bigvoice::dyn::CPresetLoader {
public:
    MyPresetManager() = default;
    virtual ~MyPresetManager() = default;
 
    bool SetupPath(const std::filesystem::path& a_preset_path)
        {
            m_preset_path=a_preset_path;
            std::error_code ec;
            if ( !std::filesystem::exists(m_preset_path,ec ) ) {
                return false;
            }
            if ( !std::filesystem::is_directory(m_preset_path, ec) ) {
                return false;
            }
            return true;
        }
    virtual bool IsReadOnly() override { return false; };
    virtual bool Exists(const std::filesystem::path &name) override
        {
            std::error_code ec;
            return std::filesystem::exists(GetRealPath(name), ec);
        }
    virtual bool Remove(const std::filesystem::path &name) override
        {
            std::error_code ec;
            return std::filesystem::remove(GetRealPath(name), ec);
        }
    virtual bool Rename(const std::filesystem::path &from, const std::filesystem::path &to) override
        {
            std::error_code ec;
            std::filesystem::rename(GetRealPath(from), GetRealPath(to), ec);
            return (!ec);
        }
    virtual std::vector<std::filesystem::path> GetAll() override
        {
            std::vector<std::filesystem::path> list;
            std::error_code ec;
            for (auto it = std::filesystem::directory_iterator(m_preset_path.c_str(), std::filesystem::directory_options::skip_permission_denied, ec);
                !ec && it != std::filesystem::directory_iterator{};
                 it.increment(ec) ) 
            {
                if (it->is_regular_file(ec)) {
                    list.push_back(it->path().lexically_relative(m_preset_path));
                }
            }
            return list;
        }
    virtual std::string Read(const std::filesystem::path &filename) override
        {
            std::ifstream f(GetRealPath(filename));
            if ( f.fail() ) {
                return std::string();
            }
            std::ostringstream ss;
            ss << f.rdbuf();
            return ss.str();
        }   
    virtual bool Write(const std::filesystem::path &filename, const std::string &content) override
        {
            std::ofstream f(GetRealPath(filename));
            if ( f.fail() ) {
                return false;
            }
            f << content;
            if ( f.fail() ) {
                return false;
            }
            return true;
        }
private:
    std::filesystem::path m_preset_path;
    std::filesystem::path GetRealPath(const std::filesystem::path &name)
        {
            return m_preset_path / name;
        }   
};

Custom preset manager loading

    MyPresetManager preset_manager;
    if (!store_path.empty()) {
        if (!preset_manager.SetupPath(store_path)) {
            std::cerr << "Failed to setup the custom preset manager on path " << store_path.c_str() << std::endl;
            return 1;       
        }
        instance.SetPresetManager(&preset_manager);
    }