sound4.x1.cloud-loopcreate.cpp

Go to the documentation of this file.

#include <unistd.h>
#include <iostream>
#include <strings.h>
#include <sys/types.h>
#include <signal.h>
#include <chrono>
#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>
#endif
#include <sound4.x1.cloud.h>
 
#define SAMPLE_RATE       48000
#define CHUNK_SIZE        64
#define CHANNEL_COUNT     2
 
using namespace std::chrono_literals;
 
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 << " - S4_AWS_ACCESS_KEY_ID    : SOUND4 Access Key ID"<< std::endl;;
    std::cerr << " - S4_AWS_SECRET_ACCESS_KEY: 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;
}
 
volatile bool gs_request_quit=false;
volatile bool gs_reload=false;
 
void sigint(int signum [[maybe_unused]])
{
    std::cerr << "Signal for quit" << std::endl;
    signal(SIGINT, NULL);
    signal(SIGTERM, NULL);
    gs_request_quit=true;
}
 
int main(int argc, char *const argv[])
{
    const char *store_path=getenv("S4STORE_PATH");
    // Get credentials from environment
    char *pLoginKey=getenv("S4LOGINKEY");
    if (!pLoginKey) {
        pLoginKey=getenv("S4USERID");
    }
    char *pRadioName=getenv("RADIO_NAME");
    char *pKeyId=getenv("S4_AWS_ACCESS_KEY_ID");
    char *pAccessKey=getenv("S4_AWS_SECRET_ACCESS_KEY");
#if (CLOUDX1_HAS_WEBSERVER)
    // int http=8080;
    int http=0;
    int https=0;
#endif // (CLOUDX1_HAS_WEBSERVER)
 
    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;
    }
    if (!store_path ) {
        store_path="./state";
    }
    if (!std::filesystem::exists(store_path) || !std::filesystem::is_directory(store_path)) {
      std::cerr << "Storage folder '"<<store_path<<"' is not a valid directory" << std::endl;
        Usage(progname);
      return 1;
    }
 
    
    //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;
    }
 
    signal(SIGTERM, &sigint);
    signal(SIGINT, &sigint);
 
    while (!gs_request_quit) {
        struct cloudx1_CInstance *pInstance = NULL;
 
        // Create the processing instance
        std::cerr << "Creating instance" << std::endl;
        pInstance=cloudx1_InitProcess(pLoginKey,pRadioName,pKeyId,pAccessKey,store_path);
        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
        uint64_t webserver=-1;
        if (http || https) {
            std::cerr << "Starting web server" << std::endl;
            webserver= cloudx1_Webserver(http,https,pInstance);
            std::cerr << "Starting web server DONE" << std::endl;
        }
    #endif // (CLOUDX1_HAS_WEBSERVER)
 
        while (!gs_reload && !gs_request_quit) {
            std::cout << "Type r(eload) or q(uit) + ENTER" << std::endl;
            std::string s;
            std::cin >> s;
            if (s.length()>0) {
                switch (s[0]) {
                    case 'q':
                    case 'Q':
                        gs_request_quit=true; break;
                    case 'r':
                    case 'R':
                    default:
                        gs_reload=true; break;
                }
            }
        }
 
    #if (CLOUDX1_HAS_WEBSERVER)
        if (http || https) {
            // 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;
 
        std::cerr << "waiting update thread" << std::endl;
        updater.join();
 
        std::cerr << "Destorying instance" << std::endl;
        cloudx1_ExitProcess(pInstance);
 
        gs_reload=false;
    }
 
    return 0;
}