MIDI_Interface.hpp

Go to the documentation of this file.

#pragma once
 
#include "MIDI_Pipes.hpp"
#include "MIDI_Sender.hpp"
#include "MIDI_Staller.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;
 
class MIDI_Interface : public TrueMIDI_SinkSource,
                       public MIDI_Sender<MIDI_Interface>,
                       public AH::Updatable<MIDI_Interface>,
                       protected MIDIStaller {
  protected:
    MIDI_Interface() = default;
    MIDI_Interface(MIDI_Interface &&) = default;
 
  public:
    virtual ~MIDI_Interface();
 
    void begin() override {}
    void update() override = 0;
 
 
    void setAsDefault();
    static MIDI_Interface *getDefault();
 
 
 
    void setCallbacks(MIDI_Callbacks *cb) { this->callbacks = cb; }
    void setCallbacks(MIDI_Callbacks &cb) { setCallbacks(&cb); }
 
 
  protected:
    friend class MIDI_Sender<MIDI_Interface>;
    virtual void sendChannelMessageImpl(ChannelMessage) = 0;
    virtual void sendSysCommonImpl(SysCommonMessage) = 0;
    virtual void sendSysExImpl(SysExMessage) = 0;
    virtual void sendRealTimeImpl(RealTimeMessage) = 0;
    virtual void sendNowImpl() = 0;
 
  public:
#if DISABLE_PIPES
    virtual MIDIReadEvent read() = 0;
    virtual ChannelMessage getChannelMessage() const = 0;
    virtual SysCommonMessage getSysCommonMessage() const = 0;
    virtual RealTimeMessage getRealTimeMessage() const = 0;
    virtual SysExMessage getSysExMessage() const = 0;
#endif
 
  protected:
#if !DISABLE_PIPES
    void sinkMIDIfromPipe(ChannelMessage msg) override { send(msg); }
    void sinkMIDIfromPipe(SysExMessage msg) override { send(msg); }
    void sinkMIDIfromPipe(SysCommonMessage msg) override { send(msg); }
    void sinkMIDIfromPipe(RealTimeMessage msg) override { send(msg); }
#endif
 
  protected:
    void onChannelMessage(ChannelMessage message);
    void onSysExMessage(SysExMessage message);
    void onSysCommonMessage(SysCommonMessage message);
    void onRealTimeMessage(RealTimeMessage message);
 
  public:
    template <class MIDIInterface_t>
    static void updateIncoming(MIDIInterface_t *iface);
    template <class MIDIInterface_t>
    static void dispatchIncoming(MIDIInterface_t *iface, MIDIReadEvent event);
    template <class MIDIInterface_t>
    static void handleStall(MIDIInterface_t *iface);
 
  private:
    MIDI_Callbacks *callbacks = nullptr;
 
  private:
    static MIDI_Interface *DefaultMIDI_Interface;
};
 
template <class MIDIInterface_t>
void MIDI_Interface::updateIncoming(MIDIInterface_t *iface) {
#if DISABLE_PIPES
    MIDIReadEvent event = iface->read();
    while (event != MIDIReadEvent::NO_MESSAGE) {
        dispatchIncoming(iface, event);
        event = iface->read();
    }
#else
    if (iface->getStaller() == iface)
        iface->unstall(iface);
    bool chunked = false;
    MIDIReadEvent event = iface->read();
    while (event != MIDIReadEvent::NO_MESSAGE) {
        dispatchIncoming(iface, event);
        if (event == MIDIReadEvent::SYSEX_CHUNK)
            chunked = true;
        if (event == MIDIReadEvent::SYSEX_MESSAGE)
            chunked = false;
        event = iface->read();
    }
    if (chunked)
        iface->stall(iface);
#endif
    // TODO: add logic to detect MIDI messages such as (N)RPN that span over
    // multiple channel voice messages and that shouldn't be interrupted.
    // For short messages such as (N)RPN, I suggest waiting with a timeout.
}
 
template <class MIDIInterface_t>
void MIDI_Interface::dispatchIncoming(MIDIInterface_t *iface,
                                      MIDIReadEvent event) {
    switch (event) {
        case MIDIReadEvent::CHANNEL_MESSAGE:
            iface->onChannelMessage(iface->getChannelMessage());
            break;
        case MIDIReadEvent::SYSEX_CHUNK: // fallthrough
        case MIDIReadEvent::SYSEX_MESSAGE:
            iface->onSysExMessage(iface->getSysExMessage());
            break;
        case MIDIReadEvent::SYSCOMMON_MESSAGE:
            iface->onSysCommonMessage(iface->getSysCommonMessage());
            break;
        case MIDIReadEvent::REALTIME_MESSAGE:
            iface->onRealTimeMessage(iface->getRealTimeMessage());
            break;
        case MIDIReadEvent::NO_MESSAGE: break; // LCOV_EXCL_LINE
        default: break;                        // LCOV_EXCL_LINE
    }
}
 
#if !DISABLE_PIPES
template <class MIDIInterface_t>
void MIDI_Interface::handleStall(MIDIInterface_t *iface) {
    iface->unstall(iface);
 
    unsigned long startTime = millis();
    while (millis() - startTime < SYSEX_CHUNK_TIMEOUT) {
        MIDIReadEvent event = iface->read();
        dispatchIncoming(iface, event);
        if (event == MIDIReadEvent::SYSEX_CHUNK)
            startTime = millis(); // reset timeout
        else if (event == MIDIReadEvent::SYSEX_MESSAGE)
            return;
    }
    DEBUGREF(F("Warning: Unable to un-stall pipes: ")
             << iface->getStallerName());
}
#endif
 
END_CS_NAMESPACE