midi.hpp

Go to the documentation of this file.

#pragma once
#include <vector>
#include <set>
 
#include <jansson.h>
 
#include <common.hpp>
#include <context.hpp>
 
 
namespace rack {
namespace midi {
 
 
struct Message {
    std::vector<uint8_t> bytes;
    int64_t frame = -1;
 
    Message() : bytes(3) {}
 
    int getSize() const {
        return bytes.size();
    }
    void setSize(int size) {
        bytes.resize(size);
    }
 
    uint8_t getChannel() const {
        if (bytes.size() < 1)
            return 0;
        return bytes[0] & 0xf;
    }
    void setChannel(uint8_t channel) {
        if (bytes.size() < 1)
            return;
        bytes[0] = (bytes[0] & 0xf0) | (channel & 0xf);
    }
 
    uint8_t getStatus() const {
        if (bytes.size() < 1)
            return 0;
        return bytes[0] >> 4;
    }
    void setStatus(uint8_t status) {
        if (bytes.size() < 1)
            return;
        bytes[0] = (bytes[0] & 0xf) | (status << 4);
    }
 
    uint8_t getNote() const {
        if (bytes.size() < 2)
            return 0;
        return bytes[1];
    }
    void setNote(uint8_t note) {
        if (bytes.size() < 2)
            return;
        bytes[1] = note & 0x7f;
    }
 
    uint8_t getValue() const {
        if (bytes.size() < 3)
            return 0;
        return bytes[2];
    }
    void setValue(uint8_t value) {
        if (bytes.size() < 3)
            return;
        bytes[2] = value & 0x7f;
    }
 
    std::string toString() const;
 
    int64_t getFrame() const {
        return frame;
    }
 
    void setFrame(int64_t frame) {
        this->frame = frame;
    }
};

// Driver
 
struct InputDevice;
struct Input;
struct OutputDevice;
struct Output;

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

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

    virtual int getDefaultInputDeviceId() {
        return -1;
    }

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

    virtual InputDevice* subscribeInput(int deviceId, Input* input) {
        return NULL;
    }

    virtual void unsubscribeInput(int deviceId, Input* input) {}
 
    // The following behave identically as the above methods except for outputs.
 
    virtual std::vector<int> getOutputDeviceIds() {
        return {};
    }
    virtual int getDefaultOutputDeviceId() {
        return -1;
    }
    virtual std::string getOutputDeviceName(int deviceId) {
        return "";
    }
    virtual OutputDevice* subscribeOutput(int deviceId, Output* output) {
        return NULL;
    }
    virtual void unsubscribeOutput(int deviceId, Output* output) {}
};

// Device

struct Device {
    virtual ~Device() {}
    virtual std::string getName() {
        return "";
    }
};
 
struct InputDevice : Device {
    std::set<Input*> subscribed;
    void subscribe(Input* input);
    void unsubscribe(Input* input);
    void onMessage(const Message& message);
};
 
struct OutputDevice : Device {
    std::set<Output*> subscribed;
    void subscribe(Output* output);
    void unsubscribe(Output* output);
    virtual void sendMessage(const Message& message) {}
};

// Port

struct Port {
    int channel = -1;
 
    // private
    int driverId = -1;
    int deviceId = -1;
    Driver* driver = NULL;
    Device* device = NULL;
    Context* context;
 
    Port();
    virtual ~Port();
 
    Driver* getDriver();
    int getDriverId();
    void setDriverId(int driverId);
 
    Device* getDevice();
    virtual std::vector<int> getDeviceIds() = 0;
    virtual int getDefaultDeviceId() = 0;
    int getDeviceId();
    virtual void setDeviceId(int deviceId) = 0;
    virtual std::string getDeviceName(int deviceId) = 0;
 
    virtual std::vector<int> getChannels() = 0;
    int getChannel();
    void setChannel(int channel);
    std::string getChannelName(int channel);
 
    json_t* toJson();
    void fromJson(json_t* rootJ);
};
 
 
struct Input : Port {
    InputDevice* inputDevice = NULL;
 
    Input();
    ~Input();
    void reset();
 
    std::vector<int> getDeviceIds() override;
    int getDefaultDeviceId() override;
    void setDeviceId(int deviceId) override;
    std::string getDeviceName(int deviceId) override;
 
    std::vector<int> getChannels() override;
 
    virtual void onMessage(const Message& message) {}
};
 

struct InputQueue : Input {
    struct Internal;
    Internal* internal;
 
    InputQueue();
    ~InputQueue();
    void onMessage(const Message& message) override;
    bool tryPop(Message* messageOut, int64_t maxFrame);
    size_t size();
};
 
 
struct Output : Port {
    OutputDevice* outputDevice = NULL;
 
    Output();
    ~Output();
    void reset();
 
    std::vector<int> getDeviceIds() override;
    int getDefaultDeviceId() override;
    void setDeviceId(int deviceId) override;
    std::string getDeviceName(int deviceId) override;
 
    std::vector<int> getChannels() override;
 
    void sendMessage(const Message& message);
};
 
 
PRIVATE void init();
PRIVATE void destroy();
void addDriver(int driverId, Driver* driver);
std::vector<int> getDriverIds();
Driver* getDriver(int driverId);
 
 
} // namespace midi
} // namespace rack