sound4.x1.cloud-pipe.cpp

Go to the documentation of this file.

 
#include <unistd.h>
#include <iostream>
#include <strings.h>
#include <sys/types.h>
#include <thread>           // NOTE: needs pthread link
// Choose good filesystem version depending on compiler.
#if __has_include(<filesystem>)
    #include <filesystem>
#else //if __cpp_lib_experimental_filesystem
    // We need the alias from std::experimental::filesystem to std::filesystem
    #include <experimental/filesystem>
    namespace std {
        namespace filesystem = experimental::filesystem;
    }
#endif
#if defined(_WIN32) || defined(WIN32)
    #include <io.h>
    #include <fcntl.h>
    #include <stringapiset.h>   // UTF-8 conversion
#endif
#include <sound4.x1.cloud.h>
 
#define SAMPLE_RATE       48000
#define CHUNK_SIZE        64
#define CHANNEL_COUNT     2
 
// Reads from stdin, write to stdout
void ProcessLoop(struct cloudx1_CInstance *pInstance)
{
bool stopthread=false;
alignas(64) float audio_in[CHUNK_SIZE*CHANNEL_COUNT];
alignas(64) float audio_out[CHUNK_SIZE*CHANNEL_COUNT];
 
    #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(&audio_in[0], sizeof(float), CHUNK_SIZE*CHANNEL_COUNT, stdin) != CHUNK_SIZE*CHANNEL_COUNT) {
            std::cerr << "ProcessLoop: input stopped"<< std::endl;
            stopthread=true;
            break;
        }
        if (stopthread) break;
        // Process it
        cloudx1_ProcessAudio(pInstance, audio_in, audio_out);
        // Write it to stdout
        if (fwrite(&audio_out[0], sizeof(float), CHUNK_SIZE*CHANNEL_COUNT, stdout) != CHUNK_SIZE*CHANNEL_COUNT) {
            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: ./state]"<< 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 "<<SAMPLE_RATE<<" -ac "<<CHANNEL_COUNT<<" -f f32le - | "<<progname<<" | ffplay -f f32le -ar "<<SAMPLE_RATE<<" -ac "<<CHANNEL_COUNT<<" -i -" << std::endl;;
    #if defined(_WIN32) || defined(WIN32)
        std::cerr << "ffmpeg -f dshow -i audio=\"Microphone\" -ar "<<SAMPLE_RATE<<" -ac "<<CHANNEL_COUNT<<" -f f32le - | "<<progname<<" | ffplay -f f32le -ar "<<SAMPLE_RATE<<" -ac "<<CHANNEL_COUNT<<" -i -" << std::endl;;
    #else 
        std::cerr << "ffmpeg -f pulse -i default -ar "<<SAMPLE_RATE<<" -ac "<<CHANNEL_COUNT<<" -f f32le - | "<<progname<<" | ffplay -f f32le -ar "<<SAMPLE_RATE<<" -ac "<<CHANNEL_COUNT<<" -i -" << std::endl;;
    #endif
}
 
void MyLogger(cloudx1_LogSeverity severe [[maybe_unused]], const char *str)
{
    std::cerr << str << std::endl;
}
 
 
int main(int argc, char *const argv[])
{
    struct cloudx1_CInstance *pInstance = NULL;
    const char *store_path_str=getenv("S4STORE_PATH");
    // Get credentials from environment
    char *pLoginKey=getenv("S4LOGINKEY");
    if (!pLoginKey) {
        pLoginKey=getenv("S4USERID");
    }
    char *pRadioName=getenv("RADIO_NAME");
    char *pKeyId=getenv("ACCESS_KEY_ID");
    char *pAccessKey=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 (!pLoginKey || !pRadioName || !pKeyId || !pAccessKey) {
        std::cerr << "Missing credentials in environment" << std::endl;
        Usage(progname);
        return 1;
    }
    std::filesystem::path fs_store_path;
    if (!store_path_str || store_path_str[0]==0) {
        fs_store_path=std::filesystem::current_path() / "state";
    } else {
        fs_store_path = std::filesystem::path(store_path_str);
    }
    if (!std::filesystem::exists(fs_store_path) || !std::filesystem::is_directory(fs_store_path)) {
        std::cerr << "Storage folder '"<<fs_store_path.c_str()<<"' is not a valid directory" << std::endl;
        Usage(progname);
        return 1;
    }
    std::string store_path;
    #ifdef _WIN32
    {
        // Convert path to UTF-8
        std::wstring wstr(fs_store_path.wstring());
        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);
        store_path=str;
    }
    #else // !_WIN32
        store_path=fs_store_path;
    #endif // !_WIN32
 
    // Optional: Use our own logging, instead of default color output to stderr.
    //cloudx1_SetLoggerCallback(&MyLogger);
    
    //cloudx1_SetLogSeverity(cloudx1_LogSeverity::info);
    cloudx1_SetLogSeverity(cloudx1_LogSeverity::verbose5);
 
    std::cerr << "Process version: " << cloudx1_GetVersion() << std::endl;
    // Do some sanity checks
    if (cloudx1_GetSampleRate()!=SAMPLE_RATE) {
      std::cerr << "Bad library sampling rate, expecting '"<<SAMPLE_RATE<<"' but has "<< cloudx1_GetSampleRate() << std::endl;
      return 1;
    }
    if (cloudx1_GetChunkSizeInFrames()!=CHUNK_SIZE) {
      std::cerr << "Bad library frame size, expecting '"<<CHUNK_SIZE<<"' but has "<< cloudx1_GetChunkSizeInFrames() << std::endl;
      return 1;
    }
    if (cloudx1_GetChannelCount()!=CHANNEL_COUNT) {
      std::cerr << "Bad library channel count, expecting '"<<CHANNEL_COUNT<<"' but has "<< cloudx1_GetChannelCount() << std::endl;
      return 1;
    }
 
    // Setup parameters
    struct cloudx1_CParameters *params = cloudx1_NewParameters();
    // Optional: activate web authentication, set admin password
    // This creates the authentication only for a new storage path
    cloudx1_SetParameter(params,"ADMIN_USER", "admin");
    cloudx1_SetParameter(params,"ADMIN_SECRET", "admin");
    
    // Create the processing instance
    pInstance=cloudx1_InitProcess2(pLoginKey,pRadioName,pKeyId,pAccessKey,store_path.c_str(), params);
    cloudx1_FreeParameters(params);
    if (!pInstance) {
      std::cerr << "Failed to create the process instance"<< std::endl;
      return 1;
    }
 
    // Start the update thread, without JSON server (low priority)
    std::thread updater([pInstance](){
       // will returned when stopped or destroyed
       std::cerr << "cloudx1_StartUpdateThread (no json port)" << std::endl;
       cloudx1_StartUpdateThread(pInstance, 0);
       std::cerr << "cloudx1_StartUpdateThread END" << std::endl;
     });
 
    // This is not mandatory, but better be sure we are ready right now
    std::cerr << "Waiting update thread" << std::endl;
    if (cloudx1_WaitUpdateThreadReady(pInstance, 5000)<0) {
        std::cerr << "Timeout to create the process instance"<< std::endl;
    }
    std::cerr << "Waiting update thread DONE" << std::endl;
 
#if (CLOUDX1_HAS_WEBSERVER)
    // Starts a web server, listening on port http://localhost:8080, https://localhost:8443
    std::cerr << "Starting web server" << std::endl;
    int listenport= 8080;
    int listenport_secure= 8443;
    uint64_t webserver= SOUND4_INVALID_WEBSERVER_ID;
    if (listenport || listenport_secure) {
        webserver = cloudx1_Webserver(listenport,listenport_secure,pInstance);
        if (webserver==SOUND4_INVALID_WEBSERVER_ID) {
            std::cerr << "Starting web server FAILED" << std::endl;
        } else {
            int web_status=cloudx1_Webserver_Status(webserver);
            if (listenport) {
                if (web_status & SOUND4_WEBSERVER_HTTP_OK) {
                    std::cerr << "Web server listening on port " << listenport;
                } else {
                    std::cerr << "Web server failed to listen on port " << listenport;
                }
            }
            if (listenport_secure) {
                if (web_status & SOUND4_WEBSERVER_HTTPS_OK) {
                    std::cerr << "Web server listening on secure port " << listenport_secure;
                } else {
                    std::cerr << "Web server failed to listen on secure port " << listenport_secure;
                }
            }
            std::cerr << "Starting web server DONE" << std::endl;
        }
    }
#endif // (CLOUDX1_HAS_WEBSERVER)
     
     // Force load a factory preset now
     // Could be used instead of setting a store_path
     /*{
         cloudx1_CClientInstance *pClient=cloudx1_NewClient(pInstance);
         const char *answer=cloudx1_ProcessJson(pClient, "{ \"factoryload\": \"All Programs\" }", NULL);
         std::cerr << "Loaded factory preset answer: " << answer<< std::endl;
         cloudx1_FreeJsonAnswer(answer);
         cloudx1_DeleteClient(pClient);
     }*/
 
    std::cerr << "Estimated delay " << ( cloudx1_GetEstimatedDelay(pInstance)*1000.0/SAMPLE_RATE ) << " ms" << std::endl;
 
    ProcessLoop(pInstance);
 
#if (CLOUDX1_HAS_WEBSERVER)
    // Stopping the webserver
    std::cerr << "Stopping web server" << std::endl;
    cloudx1_Webserver_Stop(webserver, 1000);
    std::cerr << "Stopping web server DONE" << std::endl;
#endif // (CLOUDX1_HAS_WEBSERVER)
    
    // Stopping the processing instance
    std::cerr << "Stopping Update thread" << std::endl;
    cloudx1_StopUpdateThread(pInstance); // this will exit the update thread
    std::cerr << "Stopping Update thread DONE" << std::endl;
 
    updater.join();
 
    cloudx1_ExitProcess(pInstance);
 
    return 0;
}