USBMIDI_Interface.hpp

Go to the documentation of this file.

#pragma once
 
#include "MIDI_Interface.hpp"
#include "USBMIDI/USBMIDI.hpp"
#include "USBMIDI_Sender.hpp"
#include <AH/Error/Error.hpp>
#include <AH/Teensy/TeensyUSBTypes.hpp>
#include <MIDI_Parsers/USBMIDI_Parser.hpp>
 
BEGIN_CS_NAMESPACE
 
template <class Backend>
class GenericUSBMIDI_Interface : public MIDI_Interface {
  public:
    template <class... Args>
    GenericUSBMIDI_Interface(Args &&...args)
        : backend {std::forward<Args>(args)...},
          alwaysSendImmediately_(backend.preferImmediateSend()) {}
 
    GenericUSBMIDI_Interface(const GenericUSBMIDI_Interface &) = delete;
    GenericUSBMIDI_Interface(GenericUSBMIDI_Interface &&) = delete;
    GenericUSBMIDI_Interface &
    operator=(const GenericUSBMIDI_Interface &) = delete;
    GenericUSBMIDI_Interface &operator=(GenericUSBMIDI_Interface &&) = delete;
 
  private:
    // MIDI send implementations
    void sendChannelMessageImpl(ChannelMessage) override;
    void sendSysCommonImpl(SysCommonMessage) override;
    void sendSysExImpl(SysExMessage) override;
    void sendRealTimeImpl(RealTimeMessage) override;
    void sendNowImpl() override { backend.sendNow(); }
 
  private:
#if !DISABLE_PIPES
    void handleStall() override { MIDI_Interface::handleStall(this); }
#ifdef DEBUG_OUT
    const char *getName() const override { return "usb"; }
#endif
#endif
 
  public:
 
    void begin() override;
    void update() override;
 
 
  public:
 
    MIDIReadEvent read();
 
    ChannelMessage getChannelMessage() const;
    SysCommonMessage getSysCommonMessage() const;
    RealTimeMessage getRealTimeMessage() const;
    SysExMessage getSysExMessage() const;
 
 
  public:
 
    Backend backend;
 
  private:
    struct Sender {
        GenericUSBMIDI_Interface *iface;
        void operator()(Cable cn, MIDICodeIndexNumber cin, uint8_t d0,
                        uint8_t d1, uint8_t d2) {
            uint8_t cn_cin = (cn.getRaw() << 4) | uint8_t(cin);
            iface->backend.write({cn_cin, d0, d1, d2});
        }
    };
 
  private:
    USBMIDI_Parser parser;
    USBMIDI_Sender sender;
    bool alwaysSendImmediately_ = true;
 
  public:
 
    bool alwaysSendsImmediately() const { return alwaysSendImmediately_; }
    void neverSendImmediately() { alwaysSendImmediately_ = false; }
    void alwaysSendImmediately() { alwaysSendImmediately_ = true; }
 
};
 
END_CS_NAMESPACE
 
#include "USBMIDI_Interface.ipp"
 
#if defined(TEENSYDUINO) && !defined(TEENSY_MIDIUSB_ENABLED)
#pragma message(                                                               \
    "Teensy: USB MIDI not enabled. Enable it from the Tools > USB Type menu.")
#define CS_USB_MIDI_DISABLED
#endif
 
// If MIDI over USB is supported
#if (!defined(CS_USB_MIDI_NOT_SUPPORTED) && !defined(CS_USB_MIDI_DISABLED)) || \
    !defined(ARDUINO)
 
BEGIN_CS_NAMESPACE
 
class USBMIDI_Interface
    : public GenericUSBMIDI_Interface<USBDeviceMIDIBackend> {
  public:
    using backend_t = USBDeviceMIDIBackend;
    using GenericUSBMIDI_Interface<backend_t>::GenericUSBMIDI_Interface;
    using MIDIUSBPacket_t = backend_t::MIDIUSBPacket_t;
};
 
END_CS_NAMESPACE
 
// If the main MCU doesn't have a USB connection:
// Fall back on Serial connection at the hardware MIDI baud rate.
// (Can be used with HIDUINO or USBMidiKliK.)
#elif !defined(CS_USB_MIDI_DISABLED)
 
#include "SerialMIDI_Interface.hpp"
 
BEGIN_CS_NAMESPACE
 
class USBMIDI_Interface : public USBSerialMIDI_Interface {
  public:
    USBMIDI_Interface() : USBSerialMIDI_Interface(MIDI_BAUD) {}
};
 
END_CS_NAMESPACE
 
#endif