sound4.bigvoice.cl-pipe-cxx.cpp

Go to the documentation of this file.

 
#include <unistd.h>
#include <iostream>
#include <strings.h>
#include <sys/types.h>
#include <filesystem>
#if defined(_WIN32) || defined(WIN32)
    #include <io.h>
    #include <fcntl.h>
#endif
 
#include "sound4.bigvoice.cl.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::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::InputSampleSize, stdin) != sound4::bigvoice::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::OutputSampleSize, stdout) != sound4::bigvoice::OutputSampleSize) {
            std::cerr << "Failed to write audio output" << std::endl;
            stopthread=true;
        }
    }
}
 
void Usage(const char *progname)
{
    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;;
    std::cerr << std::endl;
    std::cerr << "Example:"<< std::endl;
    std::cerr << "ffmpeg -re -i file.wav -ar "<<sound4::bigvoice::GetSampleRate()<<" -ac "<<sound4::bigvoice::GetChannelCount()<<" -f f32le - | "<<progname<<" | ffplay -f f32le -ar "<<sound4::bigvoice::GetSampleRate()<<" -ac "<<sound4::bigvoice::GetChannelCount()<<" -i -" << std::endl;;
    #if defined(_WIN32) || defined(WIN32)
        std::cerr << "ffmpeg -f dshow -i audio=\"Microphone\" -ar "<<sound4::bigvoice::GetSampleRate()<<" -ac "<<sound4::bigvoice::GetChannelCount()<<" -f f32le - | "<<progname<<" | ffplay -f f32le -ar "<<sound4::bigvoice::GetSampleRate()<<" -ac "<<sound4::bigvoice::GetChannelCount()<<" -i -" << std::endl;;
    #else 
        std::cerr << "ffmpeg -f pulse -i default -ar "<<sound4::bigvoice::GetSampleRate()<<" -ac "<<sound4::bigvoice::GetChannelCount()<<" -f f32le - | "<<progname<<" | ffplay -f f32le -ar "<<sound4::bigvoice::GetSampleRate()<<" -ac "<<sound4::bigvoice::GetChannelCount()<<" -i -" << std::endl;;
    #endif
}
 
void MyLogger(sound4::bigvoice::LogSeverity severity,const std::string& msg)
{
    std::cerr << msg << std::endl;
}
 
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];
 
    if (argc>1) {
        if ((strcasecmp(argv[1],"-h")==0) || (strcasecmp(argv[1],"--help")==0)) {
            Usage(progname);
            return 0;
        }
    }
    if (LoginKey.empty() || RadioName.empty() || KeyId.empty() || AccessKey.empty()) {
        std::cerr << "Missing credentials in environment" << std::endl;
        Usage(progname);
        return 1;
    }
    std::filesystem::path store_path;
    if (!store_path_str.empty()) {
        std::error_code ec;
        store_path = std::filesystem::path(store_path_str);
        if (!std::filesystem::exists(store_path,ec) || !std::filesystem::is_directory(store_path,ec)) {
            std::cerr << "Storage folder '"<<store_path.c_str()<<"' is not a valid directory" << std::endl;
            Usage(progname);
            return 1;
        }
    }
 
    sound4::bigvoice::SetLogSeverity(verbose5);
    sound4::bigvoice::SetLoggerCallback(MyLogger);
 
    sound4::bigvoice::CInstance instance;
    instance.SetParam("ADMIN_USER","admin");
    instance.SetParam("ADMIN_SECRET","admin");
 
    std::cerr << "Creating" << std::endl;
    if (!instance.Create(LoginKey, RadioName, KeyId, AccessKey, store_path)) {
        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;
}