Line data    Source code

       1             : #pragma once
       2             : 
       3             : #include <Settings/NamespaceSettings.hpp>
       4             : #include <stddef.h>
       5             : #include <stdint.h>
       6             : 
       7             : BEGIN_CS_NAMESPACE
       8             : 
       9             : /** 
      10             :  * @brief   Class for parsing BLE-MIDI packets. It doesn't parse the actual MIDI
      11             :  *          messages, it just extracts the relevant MIDI data from the BLE 
      12             :  *          packets.
      13             :  * 
      14             :  * @ingroup MIDIParsers
      15             :  */
      16             : class BLEMIDIParser {
      17             :   public:
      18          44 :     BLEMIDIParser(const uint8_t *data, size_t length)
      19          44 :         : data(data), end(data + length) {
      20             :         // Need at least two bytes to be useful.
      21             :         // Usually, we have header, timestamp and at least one MIDI byte,
      22             :         // but a SysEx continuation could perhaps have only a header and a
      23             :         // single data byte (this is not explicitly allowed by the spec, but
      24             :         // handling this case requires no extra effort)
      25          44 :         if (length < 2) {
      26          30 :             this->data = end;
      27             :         }
      28             :         // First byte should be a header. If it's a data byte, discard packet.
      29          14 :         else if (isData(data[0])) {
      30           1 :             this->data = end;
      31             :         }
      32             :         // If the second byte is a data byte, this is a SysEx continuation
      33             :         // packet
      34          13 :         else if (isData(data[1])) {
      35           1 :             this->timestamp = data[0] & 0x7F;
      36           1 :             this->timestamp <<= 7;
      37           1 :             this->data += 1;
      38             :         }
      39             :         // Otherwise, the second byte is a timestamp, so skip it
      40             :         else {
      41          12 :             this->timestamp = data[0] & 0x7F;
      42          12 :             this->timestamp <<= 7;
      43          12 :             this->timestamp |= data[1] & 0x7F;
      44          12 :             this->data += 2;
      45             :         }
      46          44 :     }
      47             : 
      48             :     /// Extend the BLE packet with the given buffer.
      49             :     /// @pre    The previous buffer was fully consumed (@ref pull returned false).
      50             :     /// @note   This function should only be used for a single packet that spans
      51             :     ///         multiple buffers. If you want to parse a new packet, you should
      52             :     ///         create a new BLEMIDIParser instance.
      53           0 :     void extend(const uint8_t *data, size_t length) {
      54           0 :         this->data = data;
      55           0 :         this->end = data + length;
      56           0 :     }
      57             : 
      58             :     /// Get the next MIDI byte from the BLE packet (if available).
      59             :     /// @return True if a byte was available, false otherwise.
      60         133 :     bool pull(uint8_t &output) {
      61         156 :         while (data != end) {
      62             :             // Simply pass on all normal data bytes to the MIDI parser.
      63         129 :             if (isData(*data)) {
      64          77 :                 output = *data++;
      65          77 :                 prevWasTimestamp = false;
      66          77 :                 return true;
      67             :             }
      68             :             // If it's not a data byte, it's either a timestamp byte or a
      69             :             // MIDI status byte.
      70             :             else {
      71             :                 // Timestamp bytes and MIDI status bytes should alternate.
      72          52 :                 prevWasTimestamp = !prevWasTimestamp;
      73             :                 // If the previous non-data byte was a timestamp, this one is
      74             :                 // a MIDI status byte, so send it to the MIDI parser.
      75          52 :                 if (!prevWasTimestamp) {
      76          29 :                     output = *data++;
      77          29 :                     return true;
      78             :                 }
      79             :                 // Otherwise it's a time stamp
      80             :                 else {
      81          23 :                     uint16_t timestampLow = *data++ & 0x7F;
      82             :                     // The BLE MIDI spec has the following to say about overflow:
      83             :                     // > Should the timestamp value of a subsequent MIDI message
      84             :                     // > in the same packet overflow/wrap (i.e., the
      85             :                     // > timestampLow is smaller than a preceding timestampLow),
      86             :                     // > the receiver is responsible for tracking this by
      87             :                     // > incrementing the timestampHigh by one (the incremented
      88             :                     // > value is not transmitted, only understood as a result
      89             :                     // > of the overflow condition).
      90          23 :                     if (timestampLow < (timestamp & 0x7F)) // overflow
      91           1 :                         timestamp += 0x80;
      92          23 :                     timestamp = (timestamp & 0x3F80) | timestampLow;
      93             :                 }
      94             :             }
      95             :         }
      96          27 :         return false;
      97             :     }
      98             : 
      99          40 :     uint16_t getTimestamp() const { return timestamp; }
     100             : 
     101             :   private:
     102             :     const uint8_t *data;
     103             :     const uint8_t *end;
     104             :     bool prevWasTimestamp = true;
     105             :     uint16_t timestamp = 0;
     106             : 
     107             :   private:
     108             :     /// Check if the given byte is a data byte (and not a header, timestamp or
     109             :     /// status byte).
     110         156 :     static bool isData(uint8_t data) { return (data & (1 << 7)) == 0; }
     111             : };
     112             : 
     113             : END_CS_NAMESPACE