sound4cl-pipe.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 "sound4cl.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::CInstance &instance, sound4::CProcessor &processor)
{
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
    
    size_t input_sample_count = instance.GetChunkFrames() * processor.GetChannelCount();
    size_t output_sample_count = instance.GetChunkFrames() * processor.GetChannelCount();
    while (!stopthread)
    {
        // Read a chunk from stdin
        if (std::fread(instance.GetBufferIn(), sizeof(float), input_sample_count, stdin) != input_sample_count) {
            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(), sizeof(float), output_sample_count, stdout) != output_sample_count) {
            std::cerr << "Failed to write audio output" << std::endl;
            stopthread=true;
        }
    }
}
 
class MyPresetManager : public sound4::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)
{
    int listen_port = 8080;
    auto store_path_str=GetEnv("S4STORE_PATH");
    std::string libname =  "libsound4.x1.cloud.so";
 
 
    // 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];
    for (int n=1;n<argc;n++) {
        std::string arg = argv[n];
        if (arg=="-p" || arg=="--port") {
            if (argc<n+1) {
                std::cerr << "--port needs a number"<< std::endl;
                return 1;       
            }
            n++;
            listen_port=atoi(argv[n]);
        } else if (arg=="-l" || arg=="--lib") {
            if (argc<n+1) {
                std::cerr << "--port needs a number"<< std::endl;
                return 1;       
            }
            n++;
            libname=argv[n];
        } else if (arg=="-h" || arg=="--help") {
            std::cerr << "Usage: " << progname << " [-p port] [-l libname.so]"<<std::endl;;
            std::cerr << "  Reads audio from stdin and return processed audio in stdout" << std::endl;
            std::cerr << "   -l, --lib   : library to load ["<<libname<<"]" << std::endl;
            std::cerr << "   -p, --port  : port for web server ["<<listen_port<<"]" << std::endl;
            std::cerr << 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 48000 -ac 2 -f f32le - | "<<progname<<" | ffplay -f f32le -ar 48000 -ac 2 -i -" << std::endl;;
            #if defined(_WIN32) || defined(WIN32)
            std::cerr << "  ffmpeg -f dshow -i audio=\"Microphone\" -ar 48000 -ac 2 -f f32le - | "<<progname<<" | ffplay -f f32le -ar 48000 -ac 2 -i -" << std::endl;;
            #else 
            std::cerr << "  ffmpeg -f pulse -i default -ar 48000 -ac 2 -f f32le - | "<<progname<<" | ffplay -f f32le -ar 48000 -ac 2 -i -" << std::endl;;
            #endif
            return 0;
        } else {
            std::cerr << "unknown argument '"<<arg<<"'"<< std::endl;
            return 1;       
        }
    }
 
 
    sound4::CProcessor processor;
    if (!processor.Load(libname)) {
        std::cerr << "Failed to load processing library" << std::endl;
        return 1;
    }
 
    if (LoginKey.empty() || RadioName.empty() || KeyId.empty() || AccessKey.empty()) {
        std::cerr << "Missing credentials in environment" << std::endl;
        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;
            return 1;
        }
    }
 
    processor.SetLogSeverity(sound4::verbose5);
    processor.SetLoggerCallback([](sound4::LogSeverity severity,const std::string& msg) {
            std::cerr << msg << std::endl;
        });
 
    sound4::CInstance instance(processor);
    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;
    }
 
    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;
    }
 
    {
        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, processor);
 
    std::cerr << "Stopping now" << std::endl;
    instance.Stop();
 
    std::cerr << "End" << std::endl;
    return 0;
}