Developers

                        
  import time
  import requests # sudo pip install requests

  #set user credentials
  user = 'user@domain.com'
  password = 'yourpassword'

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

  url_vocloud = 'https://cloud.voctrolabs.com'

  if __name__ == '__main__':

    # CREATE TASK //////////////////////////////////////////

    print '*** CREATE TASK ***'

    #set parameters for transformation
    timestretch = 0.8;
    pitchshift = 3.0;

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

    # Post request
    response_create = requests.post(url_vocloud + "/api/voscale/tasks",
                                    json=payload,
                                    auth=(user, password))

    print(response_create.json())

    # Then upload (PUT) audio file to S3 url address returned in 
    #response_create.json()["audio_upload_urls"][0]
    print "\n*** UPLOAD FILES ***"

    filepath = "test.wav"
    fh = open(filepath)
    audio_data_binary = fh.read()
    response_upload = requests.put(response_create.json()["audio_upload_urls"][0], data=audio_data_binary)

    print("returned ok?:" + str(response_upload.ok) + 
          " reason:" + response_upload.reason + 
          " status_code:" + str(response_upload.status_code))

    # START TASK ///////////////////////////////////////////
    print "\n*** START TASK ***"
    task_url = url_vocloud + "/api/voscale/tasks/" + 
               response_create.json()["id"].encode('utf-8')

    response_start = requests.post(task_url + "/start",
                                   auth=(user, password))

    print("returned ok?:" + str(response_start.ok) + 
          " reason:" + response_start.reason + 
          " status_code:" + str(response_start.status_code))

    # Check if task finished
    print "\n*** TASK PROCESSED? ***"

    print "Processing...";
    while True:
      time.sleep(1)  # delays for 1 seconds
      response_status = requests.get(task_url,
                                     auth=(user, password))

      if response_status.json()["status"] == 'finished' or 
         response_status.json()["status"] == 'failed':
        break
      else:
        print '.'

    print "** Output URL: " + response_status.json()['audio_url']

    # Download file
    response_download = requests.get(response_status.json()['audio_url'], 
                                     stream=True)
    if response_download.status_code == 200:
      with open("output.wav", 'wb') as f:
        for chunk in response_download.iter_content(1024):
          f.write(chunk)


                      

                        
  #include "VoTransLib_api.h"

  /***************************************************************
    C++ usage example for VOICEFUL VoTrans Stand Alone SDK
    The below code is incomplete, it lacks audio in/out that will
    be implemented using standard audio driver libraries or
    reading from audio files on disk
  ****************************************************************/

  //VoTrans object
  void* mVoTrans = NULL;

  //parameters
  float gain_val = 0.9f;
  float pitch_val = 3.f;
  float mTimbreParameters[5] = { 0.5f, 0.6f, 0.7f, 0.55f, 0.5f };
  float vibratodepth_val = 0.2f;
  float vibratofreq_val = 0.3f;
  float robot_val = 0.0f;
  float alien_val = 0.0f;
  float autotune_val = 0.0f;
  float harmonizer_val = 0.0f;

  //INITIALIZATION OF THE LIBRARY
  int init()
  {
    int mnCh = 2; //number of channels
    float mSampleRate = 44100.f; 
    int mBlockSize = 256;
    
    mVoTrans = VT_Create();
          
    //CONFIGURATION
    int highQuality = 1;
    int noisy = 0;
    int bypass = 0;
    VT_Configure(mnCh, mSampleRate, mBlockSize, 
                 highQuality, noisy, bypass, mVoTrans);
    VT_SetPreAnalysis(NULL, mVoTrans);
    VT_BeginProcess(mVoTrans);
  }

  //PROCESS (in loop)
  //This function will be the audio driver callback if used in realtime or 
  //called in a loop while reading from a disk file or memory buffer if 
  //transforming offline samples
  void ProcessCallback(float* inbuffer, float* outbuffer)
  {
    //set parameters (e.g. from gui)
    VT_SetGainParameter(gain_val, mVoTrans);

    VT_SetPitchTranspositionInSemitonesParameter(pitch_val, mVoTrans);
        
    VT_SetTimbreParameters(mTimbreParameters, mVoTrans);

    VT_SetVibratoDepthParameter(vibratodepth_val, mVoTrans);
    VT_SetVibratoFreqParameter(vibratofreq_val, mVoTrans);

    VT_SetRobotParameter(robot_val, mVoTrans);
    VT_SetAlienParameter(alien_val, mVoTrans);
    VT_SetAutoTuneParameter(autotune_val, mVoTrans);
    VT_SetHarmonizerParameter(harmonizer_val, mVoTrans);
    
    //inbuffer & outbuffer memory is allocated by the user, 
    //DoProcessFloat fills the outbuffer with a maximum of 
    //configured blocksize (e.g. mBlockSize=256)
    int n = VT_DoProcessFloat(inbuffer, outbuffer, mVoTrans);
  }  
    
  //DESTROY
  void end()
  {
    VT_EndProcess(mVoTrans);
    VT_Destroy(mVoTrans);
  }