Cloud API

                          
  // PHP example that interacts with VOICEFUL VoScale API
  // It creates a new task, starts it and waits until
  // processing have been finished

  //set user credentials
  $user = "[email protected]";
  $password = "yourpassword";

  $url_vocloud = "https://cloud.voctrolabs.com";

  // CREATE TASK //////////////////////////////////////////
  //set parameters for transformation
  $timestretch = 0.8;
  $pitchshift = 3.0;

  $postDataCreate = array(
  'time_stretch_ratio' => $timestretch,
  'pitch_shift' => $pitchshift,
  'audio_upload_parts' => 1
  );

  // Setup cURL
  $chCreate = curl_init($url_vocloud.'/api/voscale/tasks');
  curl_setopt_array($chCreate, array(
  CURLOPT_POST => TRUE,
  CURLOPT_RETURNTRANSFER => TRUE,
  CURLOPT_HTTPHEADER => array(
  'Content-Type: application/json'
  ),

  CURLOPT_POSTFIELDS => json_encode($postDataCreate)
  ));

  curl_setopt($chCreate, CURLOPT_USERPWD, $user . ":" . $password);

  // Send the request
  $responseCreate = curl_exec($chCreate);

  curl_close($chCreate);

  echo "** Response from create task: ********\n".$responseCreate."\n";

  // Check for errors
  if($responseCreate === FALSE){
  die(curl_error($chCreate));
  }

  $responseCreate_obj = json_decode($responseCreate,true);

  // Then upload (PUT) audio file to S3 url address returned
  // in $responseCreate_obj["audio_upload_urls"][0]

  $audio_fn = "test.wav";
  $audio = fopen($audio_fn, "rb");

  $chUpload = curl_init();
  curl_setopt($chUpload, CURLOPT_CONNECTTIMEOUT, 2);
  curl_setopt($chUpload, CURLOPT_HEADER, false);
  curl_setopt($chUpload, CURLOPT_RETURNTRANSFER, 1);
  curl_setopt($chUpload, CURLOPT_BINARYTRANSFER, 1);
  curl_setopt($chUpload, CURLOPT_URL, $responseCreate_obj["audio_upload_urls"][0]);

  curl_setopt($chUpload, CURLOPT_PUT, 1);
  curl_setopt($chUpload, CURLOPT_INFILE, $audio);
  curl_setopt($chUpload, CURLOPT_INFILESIZE, filesize($audio_fn));

  $responseUpload = curl_exec($chUpload);
  curl_close($chUpload);

  echo "\n** Response from upload audio to S3: *****\n".$responseUpload."\n";

  // START TASK ///////////////////////////////////////////
  $task_id = $responseCreate_obj["id"];
  $task_url = $url_vocloud."/api/voscale/tasks/".$task_id;

  // The data to send to the API
  $postDataStart = array(
  'task_url' => $task_url
  );

  // Setup cURL
  $chStart = curl_init($task_url."/start");
  curl_setopt_array($chStart, array(
  CURLOPT_POST => TRUE,
  CURLOPT_RETURNTRANSFER => TRUE,
  CURLOPT_HTTPHEADER => array(
  'Content-Type: application/json'
  ),

  CURLOPT_POSTFIELDS => json_encode($postDataStart)
  ));

  curl_setopt($chStart, CURLOPT_USERPWD, $user . ":" . $password);

  // Send the request
  $responseStart = curl_exec($chStart);
  curl_close($chStart);

  echo "\n** Response from start task: ******\n".$responseStart."\n";

  // Check for errors
  if($responseStart === FALSE){
  die(curl_error($chStart));
  }

  $responseStart_obj = json_decode($responseStart,true);

  echo "\nProcessing...";

  while ( ($responseStatus_obj['status'] != 'failed') and
  ($responseStatus_obj['status'] != 'finished') )
  {
  sleep(1);

  // Setup cURL
  $chStatus = curl_init($task_url);
  curl_setopt($chStatus,CURLOPT_RETURNTRANSFER,true);
  curl_setopt($chStatus, CURLOPT_USERPWD, $user . ":" . $password);
  // Send the request
  $responseStatus = curl_exec($chStatus);
  curl_close($chStatus);

  $responseStatus_obj = json_decode($responseStatus,true);
  echo ".";
  }

  echo "\n\n** Response from status task: ******\n".$responseStatus."\n";

  // Check for errors
  if($responseStatus === FALSE){
  die(curl_error($chStatus));
  }

  //Decode the response
  $responseData_obj = json_decode($responseStatus, TRUE);

  //Print output audio generated
  echo "\n** Output URL: ".$responseData_obj["audio_url"]."\n";

                          
                        

                          
  // C++ example that interacts with VOICEFUL VoScale API
  // It creates a new task, starts it and waits until
  // processing have been finished, downloading the result

  #include <iostream>
  #include "json.hpp" // https://github.com/nlohmann/json
  #include <chrono>
  #include <thread>
  #include <stdlib.h>
  #include <fstream>

  // https://github.com/jpbarrette/curlpp
  #include <curlpp/cURLpp.hpp>
  #include <curlpp/Easy.hpp>
  #include <curlpp/Options.hpp>
  #include <curlpp/Exception.hpp>
  #include <curlpp/Infos.hpp>

  using json = nlohmann::json;

  std::string user = "[email protected]";
  std::string pass = "yourpassword";
  std::string url_vocloud = "https://cloud.voctrolabs.com";

  int main(int argc, const char * argv[]) {

    curlpp::Easy request;
    json payload;

    // set parameters for transformation
    float timestretch = 0.8;
    float pitchshift = 3.0;

    payload = {
        {"time_stretch_ratio", timestretch},
        {"pitch_shift", pitchshift},
        {"audio_upload_parts", 1}
    };

    request.setOpt(new curlpp::options::Url(url_vocloud + "/api/voscale/tasks"));
    std::list<std::string> header;
    header.push_back("Content-Type: application/json");
    request.setOpt(new curlpp::options::HttpHeader(header));
    request.setOpt(new curlpp::options::PostFields(payload.dump()));
    request.setOpt(new curlpp::options::UserPwd(user + ":" + pass));
    std::ostringstream response;
    request.setOpt(new curlpp::options::WriteStream(&response));
    request.perform();

    json response_create = json::parse(response.str());

    std::cout << response.str() << std::endl;

    std::cout << std::endl << "*** UPLOAD FILES ***" << std::endl;

    // Audio 1
    std::string filepath = "test.wav";
    std::string url = response_create["audio_upload_urls"][0];
    request.reset();
    request.setOpt(new curlpp::options::ConnectTimeout(2));
    request.setOpt(new curlpp::options::Header(false));
    request.setOpt(new curlpp::options::Url(url));
    request.setOpt(new curlpp::options::Put(true));
    FILE* wFile;
    wFile = fopen(filepath.c_str(), "rb");
    fseek(wFile, 0, SEEK_END);
    long size = ftell(wFile);
    fseek(wFile, 0, SEEK_SET);
    request.setOpt(new curlpp::options::ReadFile(wFile));
    request.setOpt(new curlpp::options::InfileSize(size));
    request.perform();

    std::cout << "status_code:" << curlpp::infos::ResponseCode::get(request) << std::endl;

    std::cout << "\n*** START TASK ***" << std::endl;
    std::string id = response_create["id"];
    std::string task_url = url_vocloud + "/api/voscale/tasks/" + id;
    std::string start_url = task_url + "/start";
    json payload_start = {{"task_url", task_url}};

    request.reset();
    request.setOpt(new curlpp::options::Url(start_url));
    header.clear();
    header.push_back("Content-Type: application/json");
    request.setOpt(new curlpp::options::HttpHeader(header));
    request.setOpt(new curlpp::options::PostFields(payload_start.dump()));
    request.setOpt(new curlpp::options::UserPwd(user + ":" + pass));
    request.setOpt(new curlpp::options::WriteStream(&response));
    request.perform();

    std::cout << response.str() << std::endl;
    json response_start = json::parse(response.str());

    std::cout << "\n*** TASK PROCESSED? ***" << std::endl;
    json response_status;
    while (true) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        request.reset();
        request.setOpt(new curlpp::options::Url(task_url));
        request.setOpt(new curlpp::options::UserPwd(user + ":" + pass));
        request.setOpt(new curlpp::options::WriteStream(&response));
        request.perform();
        response_status = json::parse(response.str());

        if (response_status["status"] == "finished" || response_status["status"] == "failed")
            break;
        else
            std::cout << "-------" << std::endl;
    }

    std::string mixUrl = response_status["audio_url"];
    std::cout << "** Output URL: " << mixUrl << std::endl;

    request.reset();
    request.setOpt(new curlpp::options::Url(url));
    std::ofstream outfile ("output.wav", std::ofstream::binary);
    request.setOpt(new curlpp::options::WriteStream(&outfile));
    request.perform();
    long responseCode = curlpp::infos::ResponseCode::get(request);
    if (responseCode == 200) {
        std::cout << "File written to output.wav" << std::endl;
    } else {
        std::cout << "Error " << responseCode << " downloading file";
        return -1;
    }

    return 0;
  }