audio.hpp

Go to the documentation of this file.

#pragma once
#include <vector>
#include <set>
#include <mutex>
 
#include <jansson.h>
 
#include <common.hpp>
#include <context.hpp>
 
namespace rack {
namespace audio {
 

// Driver
 
struct Device;
struct Port;

struct Driver {
    virtual ~Driver() {}
    virtual std::string getName() {
        return "";
    }

    virtual std::vector<int> getDeviceIds() {
        return {};
    }

    virtual int getDefaultDeviceId() {
        return -1;
    }

    virtual std::string getDeviceName(int deviceId) {
        return "";
    }

    virtual int getDeviceNumInputs(int deviceId) {
        return 0;
    }

    virtual int getDeviceNumOutputs(int deviceId) {
        return 0;
    }

    virtual Device* subscribe(int deviceId, Port* port) {
        return NULL;
    }

    virtual void unsubscribe(int deviceId, Port* port) {}
};

// Device

struct Device {
    std::set<Port*> subscribed;
    std::mutex processMutex;
 
    virtual ~Device() {}
 
    virtual std::string getName() {
        return "";
    }
    virtual int getNumInputs() {
        return 0;
    }
    virtual int getNumOutputs() {
        return 0;
    }

    virtual std::set<float> getSampleRates() {
        return {};
    }

    virtual float getSampleRate() {
        return 0;
    }

    virtual void setSampleRate(float sampleRate) {}

    virtual std::set<int> getBlockSizes() {
        return {};
    }

    virtual int getBlockSize() {
        return 0;
    }

    virtual void setBlockSize(int blockSize) {}

    virtual void subscribe(Port* port);
    virtual void unsubscribe(Port* port);

    void processBuffer(const float* input, int inputStride, float* output, int outputStride, int frames);
    void onStartStream();
    void onStopStream();
};

// Port

struct Port {
    int inputOffset = 0;
    int outputOffset = 0;
    int maxInputs = 8;
    int maxOutputs = 8;
 
    // private
    int driverId = -1;
    int deviceId = -1;
    Driver* driver = NULL;
    Device* device = NULL;
    Context* context;
 
    Port();
    virtual ~Port();
    void reset();
 
    Driver* getDriver();
    int getDriverId();
    void setDriverId(int driverId);
    std::string getDriverName();
 
    Device* getDevice();
    std::vector<int> getDeviceIds();
    int getDeviceId();
    void setDeviceId(int deviceId);
    int getDeviceNumInputs(int deviceId);
    int getDeviceNumOutputs(int deviceId);
    std::string getDeviceName(int deviceId);
    std::string getDeviceDetail(int deviceId, int offset);
 
    std::set<float> getSampleRates();
    float getSampleRate();
    void setSampleRate(float sampleRate);
 
    std::set<int> getBlockSizes();
    int getBlockSize();
    void setBlockSize(int blockSize);

    int getNumInputs();
    int getNumOutputs();
 
    json_t* toJson();
    void fromJson(json_t* rootJ);

    virtual void processBuffer(const float* input, int inputStride, float* output, int outputStride, int frames) {}
    virtual void processInput(const float* input, int inputStride, int frames) {}
    virtual void processOutput(float* output, int outputStride, int frames) {}
    virtual void onStartStream() {}
    virtual void onStopStream() {}
};
 
 
PRIVATE void init();
PRIVATE void destroy();
void addDriver(int driverId, Driver* driver);
std::vector<int> getDriverIds();
Driver* getDriver(int driverId);
 
 
} // namespace audio
} // namespace rack