sound4.bigvoice.cl-pipe-dyn.cpp

Go to the documentation of this file.

 
#include <unistd.h>
#include <iostream>
#include <strings.h>
#include <sys/types.h>
#include <filesystem>
#include <fstream>
#include <sstream>
#if defined(_WIN32) || defined(WIN32)
    #include <io.h>
    #include <fcntl.h>
#endif
 
#include "sound4.bigvoice.cl_dyn.hpp"
 
// --------------------------------------------------------------
std::string GetEnv(const std::string& name)
{
    char *data=getenv(name.c_str());
    if (!data) return {};
    return std::string(data);
}
 
 
// Reads from stdin, write to stdout
void ProcessLoop(sound4::bigvoice::dyn::CInstance &instance)
{
bool stopthread=false;
 
    #if defined(_WIN32) || defined(WIN32)
        // Windows: The stdin, stdout, and stderr streams always open in text mode by default
        _setmode(_fileno(stdin), _O_BINARY);
        _setmode(_fileno(stdout), _O_BINARY);
    #endif
    
    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;
        }
    }
}
 
void Usage(const char *progname, sound4::bigvoice::dyn::CDynLib &dynlib)
{
    std::cerr << "Usage: " << progname << std::endl;;
    std::cerr << "  Reads audio from stdin and return processed audio in stdout" << std::endl;
    std::cerr << "Environment:"<< std::endl;;
    std::cerr << " - S4STORE_PATH            : path to store config [default: (no storage)]"<< std::endl;;
    std::cerr << " - S4LOGINKEY              : SOUND4 Login key (or S4USERID)"<< std::endl;;
    std::cerr << " - RADIO_NAME              : SOUND4 Radio Name"<< std::endl;;
    std::cerr << " - ACCESS_KEY_ID           : SOUND4 Access Key ID"<< std::endl;;
    std::cerr << " - ACCESS_KEY_SECRET       : SOUND4 Access Key Secret"<< std::endl;;
    if (dynlib.IsOk()) {
        std::cerr << std::endl;
        std::cerr << "Example:"<< std::endl;
        std::cerr << "ffmpeg -re -i file.wav -ar "<<dynlib.GetSampleRate()<<" -ac "<<dynlib.GetChannelCount()<<" -f f32le - | "<<progname<<" | ffplay -f f32le -ar "<<dynlib.GetSampleRate()<<" -ac "<<dynlib.GetChannelCount()<<" -i -" << std::endl;;
        #if defined(_WIN32) || defined(WIN32)
            std::cerr << "ffmpeg -f dshow -i audio=\"Microphone\" -ar "<<dynlib.GetSampleRate()<<" -ac "<<dynlib.GetChannelCount()<<" -f f32le - | "<<progname<<" | ffplay -f f32le -ar "<<dynlib.GetSampleRate()<<" -ac "<<dynlib.GetChannelCount()<<" -i -" << std::endl;;
        #else 
            std::cerr << "ffmpeg -f pulse -i default -ar "<<dynlib.GetSampleRate()<<" -ac "<<dynlib.GetChannelCount()<<" -f f32le - | "<<progname<<" | ffplay -f f32le -ar "<<dynlib.GetSampleRate()<<" -ac "<<dynlib.GetChannelCount()<<" -i -" << std::endl;;
        #endif
    }
}
 
void MyLogger(sound4::bigvoice::dyn::LogSeverity severity,const std::string& msg)
{
    std::cerr << msg << std::endl;
}
 
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;
            if ( !std::filesystem::exists(m_preset_path ) ) {
                return false;
            }
            std::error_code ec;
            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;
            for (const auto & entry : std::filesystem::directory_iterator(m_preset_path.c_str(), std::filesystem::directory_options::skip_permission_denied)) {
                if (entry.is_regular_file()) {
                    list.push_back(entry.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;
        }   
};
 
int main(int argc, const char **argv)
{
#if (BIGVOICE_HAS_WEBSERVER)
    int listen_port = 8080;
#endif // (BIGVOICE_HAS_WEBSERVER)
    auto store_path_str=GetEnv("S4STORE_PATH");
 
    // Get credentials from environment
    auto LoginKey=GetEnv("S4LOGINKEY");
    if (LoginKey.empty()) {
        LoginKey=GetEnv("S4USERID");
    }
    auto RadioName=GetEnv("RADIO_NAME");
    auto KeyId=GetEnv("ACCESS_KEY_ID");
    auto AccessKey=GetEnv("ACCESS_KEY_SECRET");
 
    const char *progname=argv[0];
 
 
    sound4::bigvoice::dyn::CDynLib dynlib;
    if (!dynlib.Load()) {
        std::cerr << "Failed to load processing library" << std::endl;
        return 1;
    }
 
    if (argc>1) {
        if ((strcasecmp(argv[1],"-h")==0) || (strcasecmp(argv[1],"--help")==0)) {
            Usage(progname,dynlib);
            return 0;
        }
    }
    if (LoginKey.empty() || RadioName.empty() || KeyId.empty() || AccessKey.empty()) {
        std::cerr << "Missing credentials in environment" << std::endl;
        Usage(progname,dynlib);
        return 1;
    }
    std::filesystem::path store_path;
    if (!store_path_str.empty()) {
        store_path = std::filesystem::path(store_path_str);
        if (!std::filesystem::exists(store_path) || !std::filesystem::is_directory(store_path)) {
            std::cerr << "Storage folder '"<<store_path.c_str()<<"' is not a valid directory" << std::endl;
            Usage(progname,dynlib);
            return 1;
        }
    }
 
    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");
 
    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);
    }
 
    std::cerr << "Creating" << std::endl;
    if (!instance.Create(LoginKey, RadioName, KeyId, AccessKey, {})) {
        std::cerr << "Failed to create the processing instance" << std::endl;
        return 1;
    }
 
#if (BIGVOICE_HAS_WEBSERVER)
    std::cerr << "Starting web server" << std::endl;
    if (!instance.StartWebServer(listen_port,0)) {
        std::cerr << "Failed to create the web server on port " << listen_port << std::endl;
        return 1;
    }
#endif // (BIGVOICE_HAS_WEBSERVER)
 
    {
        auto client = instance.NewClient();
        auto answer = client->ProcessJson(R"JSON({"get":{"processorname":null}})JSON");
        std::cerr << "Request for processor name returned "<<answer<<std::endl;
    }
 
    ProcessLoop(instance);
 
    std::cerr << "Stopping now" << std::endl;
    instance.Stop();
 
    std::cerr << "End" << std::endl;
    return 0;
}