Line data    Source code

       1              : #include "MIDI_Parser.hpp"
       2              : #include "SysExBuffer.hpp"
       3              : #include <AH/Containers/Array.hpp>
       4              : 
       5              : #ifdef MIDI_NUM_CABLES
       6              : #define USB_MIDI_NUMBER_OF_CABLES MIDI_NUM_CABLES
       7              : #elif defined(USB_MIDI4_SERIAL) || defined(USB_MIDI4)
       8              : #define USB_MIDI_NUMBER_OF_CABLES 4
       9              : #elif defined(USB_MIDI16_AUDIO_SERIAL) || defined(USB_MIDI16_SERIAL) ||        \
      10              :     defined(USB_MIDI16)
      11              : // TODO: || defined(USB_EVERYTHING)
      12              : #define USB_MIDI_NUMBER_OF_CABLES 16
      13              : #elif defined(ARDUINO_ARCH_RP2040)
      14              : #define USB_MIDI_NUMBER_OF_CABLES 16
      15              : #elif !defined(ARDUINO) || defined(DOXYGEN)
      16              : #define USB_MIDI_NUMBER_OF_CABLES 16
      17              : #else
      18              : #define USB_MIDI_NUMBER_OF_CABLES 1
      19              : #endif
      20              : 
      21              : BEGIN_CS_NAMESPACE
      22              : 
      23              : /**
      24              :  * @brief   Parser for MIDI over USB packets.
      25              :  * 
      26              :  * @ingroup MIDIParsers
      27              :  */
      28              : class USBMIDI_Parser : public MIDI_Parser {
      29              :   public:
      30              :     using MIDIUSBPacket_t = AH::Array<uint8_t, 4>;
      31              : 
      32              :     /**
      33              :      * @brief   Parse one incoming MIDI message.
      34              :      * @param   puller
      35              :      *          The source of MIDI USB packets.
      36              :      * @return  The type of MIDI message available, or 
      37              :      *          `MIDIReadEvent::NO_MESSAGE` if `puller` ran out of packets
      38              :      *          before a complete message was parsed.
      39              :      */
      40              :     template <class BytePuller>
      41              :     MIDIReadEvent pull(BytePuller &&puller);
      42              : 
      43              :   protected:
      44              :     /// Feed a new packet to the parser.
      45              :     MIDIReadEvent feed(MIDIUSBPacket_t packet);
      46              :     /// Resume the parser with the previously stored and unhandled packet.
      47              :     MIDIReadEvent resume();
      48              : 
      49              :   public:
      50              : #if !IGNORE_SYSEX
      51              :     /// Get the latest SysEx message.
      52           30 :     SysExMessage getSysExMessage() const {
      53              :         return {
      54           30 :             sysexbuffers[activeCable.getRaw()].getBuffer(),
      55           30 :             sysexbuffers[activeCable.getRaw()].getLength(),
      56              :             activeCable,
      57           90 :         };
      58              :     }
      59              : #endif
      60              : 
      61              :   protected:
      62              :     MIDIReadEvent handleChannelMessage(MIDIUSBPacket_t packet, Cable cable);
      63              :     MIDIReadEvent handleSingleByte(MIDIUSBPacket_t packet, Cable cable);
      64              :     MIDIReadEvent handleSysExStartCont(MIDIUSBPacket_t packet, Cable cable);
      65              :     template <uint8_t NumBytes>
      66              :     MIDIReadEvent handleSysExEnd(MIDIUSBPacket_t packet, Cable cable);
      67              :     MIDIReadEvent handleSysCommon(MIDIUSBPacket_t packet, Cable cable);
      68              : 
      69              :   protected:
      70              : #if !IGNORE_SYSEX
      71           14 :     void startSysEx(Cable cable) { sysexbuffers[cable.getRaw()].start(); }
      72           12 :     void endSysEx(Cable cable) {
      73           12 :         sysexbuffers[cable.getRaw()].end();
      74           12 :         activeCable = cable;
      75           12 :     }
      76            2 :     void endSysExChunk(Cable cable) { activeCable = cable; }
      77          114 :     bool hasSysExSpace(Cable cable, uint8_t amount) const {
      78          114 :         return sysexbuffers[cable.getRaw()].hasSpaceLeft(amount);
      79              :     }
      80            4 :     void addSysExByte(Cable cable, uint8_t data) {
      81            4 :         sysexbuffers[cable.getRaw()].add(data);
      82            4 :     }
      83          108 :     void addSysExBytes(Cable cable, const uint8_t *data, uint8_t len) {
      84          108 :         sysexbuffers[cable.getRaw()].add(data, len);
      85          108 :     }
      86          108 :     bool receivingSysEx(Cable cable) const {
      87          108 :         return sysexbuffers[cable.getRaw()].isReceiving();
      88              :     }
      89              : 
      90            2 :     void storePacket(MIDIUSBPacket_t packet) { storedPacket = packet; }
      91           39 :     bool hasStoredPacket() const { return storedPacket[0] != 0x00; }
      92            2 :     MIDIUSBPacket_t popStoredPacket() {
      93            2 :         MIDIUSBPacket_t t = storedPacket;
      94            2 :         storedPacket[0] = 0x00;
      95            2 :         return t;
      96              :     }
      97              : 
      98              :     Cable activeCable = Cable_1;
      99              : 
     100              :   private:
     101              :     SysExBuffer sysexbuffers[USB_MIDI_NUMBER_OF_CABLES] = {};
     102              :     MIDIUSBPacket_t storedPacket = {{ 0x00 }};
     103              : #endif
     104              : };
     105              : 
     106              : template <class BytePuller>
     107           39 : inline MIDIReadEvent USBMIDI_Parser::pull(BytePuller &&puller) {
     108              :     // First try resuming the parser, we might have a stored packet that has to
     109              :     // be parsed first.
     110           39 :     MIDIReadEvent evt = resume();
     111           39 :     if (evt != MIDIReadEvent::NO_MESSAGE)
     112            1 :         return evt;
     113              : 
     114              :     // If resumption didn't produce a message, read new packets from the input
     115              :     // and parse them until either we get a message, or until the input runs out
     116              :     // of new packets.
     117           38 :     MIDIUSBPacket_t midiPacket;
     118          141 :     while (puller.pull(midiPacket)) {
     119          131 :         evt = feed(midiPacket);
     120          131 :         if (evt != MIDIReadEvent::NO_MESSAGE)
     121           28 :             return evt;
     122              :     }
     123           10 :     return MIDIReadEvent::NO_MESSAGE;
     124              : }
     125              : 
     126              : END_CS_NAMESPACE