MIDI_Interface.hpp

Go to the documentation of this file.

#pragma once
 
#include "MIDI_Pipes.hpp"
#include <AH/Containers/Updatable.hpp>
#include <Def/Def.hpp>
#include <Def/MIDIAddress.hpp>
#include <MIDI_Parsers/MIDI_Parser.hpp>
 
BEGIN_CS_NAMESPACE
 
constexpr auto MIDI_BAUD = 31250;
 
class MIDI_Callbacks;
 
template <class Derived>
class MIDI_Sender {
  public:
 
    void send(MIDIMessageType m, Channel c, uint8_t d1, uint8_t d2,
              Cable cable = CABLE_1);
 
    void send(MIDIMessageType m, Channel c, uint8_t d1, Cable cable = CABLE_1);
 
    void sendOnCable(MIDIMessageType m, Channel c, uint8_t d1, uint8_t d2,
                     Cable cable);
 
    void sendOnCable(MIDIMessageType m, Channel c, uint8_t d1, Cable cable);
 
    void sendOnCable(MIDIMessageType rt, Cable cable);
 
    void sendNoteOn(MIDIAddress address, uint8_t velocity);
    void sendNoteOff(MIDIAddress address, uint8_t velocity);
    void sendKP(MIDIAddress address, uint8_t pressure);
    void sendCC(MIDIAddress address, uint8_t value);
    void sendPC(MIDIAddress address);
    void sendPC(MIDIChannelCN address, uint8_t value);
    void sendCP(MIDIChannelCN address, uint8_t pressure);
    void sendPB(MIDIChannelCN address, uint16_t value);
    void send(ChannelMessage message);
    void send(SysExMessage message);
    template <size_t N>
    void send(const uint8_t (&sysexdata)[N], Cable cable = CABLE_1) {
        send(SysExMessage{sysexdata, N, cable});
    }
    void send(RealTimeMessage message);
    void send(MIDIMessageType rt, Cable cable = CABLE_1);
 
};
 
class MIDI_Interface : public TrueMIDI_SinkSource,
                       public MIDI_Sender<MIDI_Interface>,
                       public AH::Updatable<MIDI_Interface> {
  protected:
    MIDI_Interface() = default;
 
    MIDI_Interface(MIDI_Interface &&) = default;
 
  public:
    virtual ~MIDI_Interface();
 
    void begin() override {}
 
    void update() override = 0;
 
 
    static MIDI_Interface *getDefault();
 
    void setAsDefault();
 
 
    virtual void setCallbacks(MIDI_Callbacks *cb) = 0;
 
    void setCallbacks(MIDI_Callbacks &cb) { setCallbacks(&cb); }
 
  protected:
    friend class MIDI_Sender<MIDI_Interface>;
    virtual void sendImpl(uint8_t header, uint8_t d1, uint8_t d2,
                          uint8_t cn) = 0;
    virtual void sendImpl(uint8_t header, uint8_t d1, uint8_t cn) = 0;
 
    virtual void sendImpl(const uint8_t *data, size_t length, uint8_t cn) = 0;
 
    virtual void sendImpl(uint8_t rt, uint8_t cn) = 0;
 
  protected:
    void sinkMIDIfromPipe(ChannelMessage) override;
    void sinkMIDIfromPipe(SysExMessage) override;
    void sinkMIDIfromPipe(RealTimeMessage) override;
 
  private:
    static MIDI_Interface *DefaultMIDI_Interface;
};
 
class Parsing_MIDI_Interface : public MIDI_Interface {
  protected:
    Parsing_MIDI_Interface(MIDI_Parser &parser) : parser(parser) {}
 
  public:
 
    MIDI_Parser &getParser() { return parser; }
 
    ChannelMessage getChannelMessage() const {
        return parser.getChannelMessage();
    }
 
    RealTimeMessage getRealTimeMessage() const {
        return parser.getRealTimeMessage();
    }
 
    SysExMessage getSysExMessage() const { return parser.getSysExMessage(); }
 
 
    void update() override;
 
    void setCallbacks(MIDI_Callbacks *cb) override { this->callbacks = cb; }
    using MIDI_Interface::setCallbacks;
 
  protected:
    bool dispatchMIDIEvent(MIDIReadEvent event);
 
  private:
    virtual MIDIReadEvent read() = 0;
 
    bool onRealTimeMessage();
    bool onChannelMessage();
    bool onSysExMessage();
 
  protected:
    MIDI_Parser &parser;
    MIDI_Callbacks *callbacks = nullptr;
    MIDIReadEvent event = MIDIReadEvent::NO_MESSAGE;
};
 
// LCOV_EXCL_START
class MIDI_Callbacks {
  public:
    virtual void onChannelMessage(Parsing_MIDI_Interface &midi) { (void)midi; }
    virtual void onSysExMessage(Parsing_MIDI_Interface &midi) { (void)midi; }
    virtual void onRealTimeMessage(Parsing_MIDI_Interface &midi) { (void)midi; }
 
    virtual ~MIDI_Callbacks() = default;
};
// LCOV_EXCL_STOP
 
END_CS_NAMESPACE
 
#include "MIDI_Interface.ipp"