Line data    Source code

       1              : #pragma once
       2              : 
       3              : #include "MIDI_Parser.hpp"
       4              : #include "SysExBuffer.hpp"
       5              : 
       6              : BEGIN_CS_NAMESPACE
       7              : 
       8              : /**
       9              :  * @brief   Parser for Serial MIDI streams (and BLE-MIDI).
      10              :  * 
      11              :  * @ingroup MIDIParsers
      12              :  */
      13              : class SerialMIDI_Parser : public MIDI_Parser {
      14              :   public:
      15          101 :     SerialMIDI_Parser(bool sysCommonCancelsRunningStatus = true)
      16          101 :         : sysCommonCancelsRunningStatus(sysCommonCancelsRunningStatus) {}
      17              : 
      18              :     /**
      19              :      * @brief   Parse one incoming MIDI message.
      20              :      * @param   puller
      21              :      *          The source of MIDI bytes.
      22              :      * @return  The type of MIDI message available, or 
      23              :      *          `MIDIReadEvent::NO_MESSAGE` if `puller` ran out of bytes before
      24              :      *          a complete message was parsed.
      25              :      */
      26              :     template <class BytePuller>
      27              :     MIDIReadEvent pull(BytePuller &&puller);
      28              : 
      29              :   protected:
      30              :     /// Feed a new byte to the parser.
      31              :     MIDIReadEvent feed(uint8_t midibyte);
      32              :     /// Resume the parser with the previously stored and unhandled byte.
      33              :     MIDIReadEvent resume();
      34              : 
      35              : #if !IGNORE_SYSEX
      36              :   public:
      37              :     /// Get the latest SysEx message.
      38           48 :     SysExMessage getSysExMessage() const {
      39           48 :         return {sysexbuffer.getBuffer(), sysexbuffer.getLength()};
      40              :     }
      41              : 
      42              :   protected:
      43          764 :     void addSysExByte(uint8_t data) { sysexbuffer.add(data); }
      44          738 :     bool hasSysExSpace() const { return sysexbuffer.hasSpaceLeft(); }
      45           34 :     void startSysEx() { sysexbuffer.start(); }
      46           30 :     void endSysEx() { sysexbuffer.end(); }
      47              : 
      48              :     SysExBuffer sysexbuffer;
      49              : #endif
      50              : 
      51              :   protected:
      52              :     MIDIReadEvent handleRealTime(uint8_t midiByte);
      53              :     MIDIReadEvent handleNonRealTimeStatus(uint8_t midiByte);
      54              :     MIDIReadEvent handleStatus(uint8_t midiByte);
      55              :     MIDIReadEvent handleData(uint8_t midiByte);
      56              : 
      57              :   protected:
      58              :     /// Store a byte to parse later. This is used when the SysEx buffer is full,
      59              :     /// for example. The byte cannot be added to the buffer now, so store it to
      60              :     /// add it the next time the parser is updated.
      61           11 :     void storeByte(uint8_t midiByte) { storedByte = midiByte; }
      62              :     /// Check whether there's a stored byte. If this is the case, this byte
      63              :     /// should be parsed before reading a new byte.
      64          200 :     bool hasStoredByte() const { return storedByte != 0xFF; }
      65              :     /// Get the stored byte. Afterwards, @ref hasStoredByte will return false.
      66           11 :     uint8_t popStoredByte() {
      67           11 :         uint8_t t = storedByte;
      68           11 :         storedByte = 0xFF;
      69           11 :         return t;
      70              :     }
      71              : 
      72              :   public:
      73              :     /// Clear the running status header for MIDI Channel messages.
      74              :     /// Internal method.
      75              :     void cancelRunningStatus() { runningHeader = 0; }
      76              : 
      77              :   private:
      78              :     /// Accounts for running status differences between MIDI 1.0 and BLE-MIDI.
      79              :     bool sysCommonCancelsRunningStatus;
      80              :     /// Flag that remembers that the next data byte will be the third byte of
      81              :     /// a message.
      82              :     bool thirdByte = false;
      83              :     /// Current header (not necessarily running), contains the header of the
      84              :     /// message that's currently being received. As soon as the message is
      85              :     /// complete, it is set to zero.
      86              :     uint8_t currentHeader = 0;
      87              :     /// Running status header.
      88              :     uint8_t runningHeader = 0;
      89              :     /// @see @ref storeByte
      90              :     uint8_t storedByte = 0xFF;
      91              : };
      92              : 
      93              : template <class BytePuller>
      94          200 : inline MIDIReadEvent SerialMIDI_Parser::pull(BytePuller &&puller) {
      95              :     // First try resuming the parser, we might have a stored byte that has to
      96              :     // be parsed first.
      97          200 :     MIDIReadEvent evt = resume();
      98          200 :     if (evt != MIDIReadEvent::NO_MESSAGE)
      99            2 :         return evt;
     100              : 
     101              :     // If resumption didn't produce a message, read new bytes from the input and
     102              :     // parse them until either we get a message, or until the input runs out of
     103              :     // new bytes.
     104          198 :     uint8_t midiByte;
     105         1077 :     while (puller.pull(midiByte)) {
     106          999 :         evt = feed(midiByte);
     107          999 :         if (evt != MIDIReadEvent::NO_MESSAGE)
     108          120 :             return evt;
     109              :     }
     110           78 :     return MIDIReadEvent::NO_MESSAGE;
     111              : }
     112              : 
     113              : END_CS_NAMESPACE