Line data    Source code

       1             : #include "SerialMIDI_Parser.hpp"
       2             : 
       3             : BEGIN_CS_NAMESPACE
       4             : 
       5           9 : MIDIReadEvent SerialMIDI_Parser::handleRealTime(uint8_t midiByte) {
       6           9 :     rtmsg.message = midiByte;
       7           9 :     return MIDIReadEvent::REALTIME_MESSAGE;
       8             : }
       9             : 
      10         131 : MIDIReadEvent SerialMIDI_Parser::handleNonRealTimeStatus(uint8_t midiByte) {
      11             : #if !IGNORE_SYSEX
      12             :     // If a SysEx message was being received, and now we receive another
      13             :     // status byte, the status byte should terminate the SysEx message
      14             :     // first, and then we can handle the new status byte later.
      15         131 :     bool untermSysEx = currentHeader == uint8_t(MIDIMessageType::SysExStart);
      16         131 :     if (untermSysEx) {
      17             :         // Handle this new status byte later (unless it's just a SysEx End
      18             :         // byte, in which case we can just terminate it now).
      19          31 :         if (midiByte != uint8_t(MIDIMessageType::SysExEnd))
      20           7 :             storeByte(midiByte);
      21             :         // Terminate the SysEx message.
      22             :         // Check if the SysEx buffer has enough space to store the end byte.
      23          31 :         if (!hasSysExSpace()) {
      24             :             // If not store the new status byte to handle it later, and
      25             :             // return the chunk we have saved up to now.
      26           1 :             storeByte(midiByte);
      27           1 :             return MIDIReadEvent::SYSEX_CHUNK;
      28             :         }
      29             :         // Enough space is available in buffer, store the end byte and
      30             :         // terminate the message.
      31          30 :         addSysExByte(uint8_t(MIDIMessageType::SysExEnd));
      32          30 :         endSysEx();
      33          30 :         currentHeader = 0;
      34          30 :         runningHeader = 0;
      35          30 :         return MIDIReadEvent::SYSEX_MESSAGE;
      36             :     } else
      37             : #endif
      38             :     {
      39             :         // Tune Request is a special System Common message of 1 byte.
      40         100 :         if (midiByte == uint8_t(MIDIMessageType::TuneRequest)) {
      41           5 :             midimsg.header = midiByte;
      42           5 :             midimsg.data1 = 0;
      43           5 :             midimsg.data2 = 0;
      44           5 :             if (sysCommonCancelsRunningStatus)
      45           4 :                 runningHeader = 0;
      46           5 :             currentHeader = 0;
      47           5 :             return MIDIReadEvent::SYSCOMMON_MESSAGE;
      48             :         }
      49             : #if !IGNORE_SYSEX
      50             :         // If the new status byte is a SysExStart, reset the SysEx buffer
      51             :         // and store the start byte.
      52          95 :         else if (midiByte == uint8_t(MIDIMessageType::SysExStart)) {
      53          30 :             startSysEx();
      54          30 :             addSysExByte(uint8_t(MIDIMessageType::SysExStart));
      55          30 :             runningHeader = 0;
      56          30 :             currentHeader = midiByte;
      57          30 :             return MIDIReadEvent::NO_MESSAGE;
      58             :         }
      59             :         // This should already have been handled by the if (untermSysEx) above.
      60          65 :         else if (midiByte == uint8_t(MIDIMessageType::SysExEnd)) {
      61             :             DEBUGREF(F("Unexpected SysEx End"));
      62          11 :             return MIDIReadEvent::NO_MESSAGE;
      63             :         }
      64             : #endif
      65             :         // Otherwise, start a System Common or Channel message.
      66             :         else {
      67             :             // Save the newly received status byte.
      68          54 :             currentHeader = midiByte;
      69             :             // A new message starts, so we haven't received the second byte
      70             :             // yet.
      71          54 :             thirdByte = false;
      72          54 :             return MIDIReadEvent::NO_MESSAGE;
      73             :         }
      74             :     }
      75             : }
      76             : 
      77             : /*
      78             :  * Relevant sources about MIDI running status:
      79             :  *  - MIDI 1.0 Detailed Specification: A-2 (pdf p.65):
      80             :  *    “cleared when a System Exclusive or Common status message is received”
      81             :  *  - BLE-MIDI: p.4 (pdf p.7):
      82             :  *    “System Common and System Real-Time messages do not cancel Running Status”
      83             :  */
      84             : 
      85         140 : MIDIReadEvent SerialMIDI_Parser::handleStatus(uint8_t midiByte) {
      86             :     // If it's a Real-Time message
      87         140 :     if (midiByte >= uint8_t(MIDIMessageType::TimingClock)) {
      88           9 :         return handleRealTime(midiByte);
      89             :     }
      90             :     // Normal header (channel message, system exclusive, system common):
      91             :     else {
      92         131 :         return handleNonRealTimeStatus(midiByte);
      93             :     }
      94             : }
      95             : 
      96         870 : MIDIReadEvent SerialMIDI_Parser::handleData(uint8_t midiByte) {
      97         870 :     if (currentHeader == 0) {
      98             :         // If we didn't receive a header, we can't do anything with this data
      99          52 :         if (runningHeader == 0) {
     100             :             DEBUGREF(F("Data byte ignored"));
     101          32 :             return MIDIReadEvent::NO_MESSAGE;
     102             :         }
     103             :         // If we have an active running status, use that as the current header
     104          20 :         currentHeader = runningHeader;
     105             :     }
     106             : 
     107         838 :     midimsg.header = currentHeader;
     108             : 
     109             :     // If this is the third byte of three (second data byte)
     110         838 :     if (thirdByte) {
     111             :         // If it's a channel message
     112          57 :         if (midimsg.hasValidChannelMessageHeader()) {
     113          51 :             midimsg.data2 = midiByte;
     114             :             // Next byte is either a header or the first data byte of the next
     115             :             // message, so clear the thirdByte flag
     116          51 :             thirdByte = false;
     117          51 :             runningHeader = midimsg.header;
     118          51 :             currentHeader = 0;
     119          51 :             return MIDIReadEvent::CHANNEL_MESSAGE;
     120             :         }
     121             :         // If it's a system common message
     122           6 :         else if (midimsg.hasValidSystemCommonHeader()) {
     123           6 :             midimsg.data2 = midiByte;
     124           6 :             thirdByte = false;
     125           6 :             if (sysCommonCancelsRunningStatus)
     126           4 :                 runningHeader = 0;
     127           6 :             currentHeader = 0;
     128           6 :             return MIDIReadEvent::SYSCOMMON_MESSAGE;
     129             :         }
     130             :     }
     131             : 
     132             :     // If this is not the third byte of three, it's either the second byte
     133             :     // (first data byte) of a channel or system common message,
     134             :     // or a SysEx data byte
     135             : 
     136             :     // If it's a channel message
     137         781 :     else if (midimsg.hasValidChannelMessageHeader()) {
     138             :         // If it's a channel message with two data bytes
     139          62 :         if (ChannelMessage(midimsg).hasTwoDataBytes()) {
     140          51 :             midimsg.data1 = midiByte;
     141             :             // We've received the second byte, expect the third byte next
     142          51 :             thirdByte = true;
     143          51 :             return MIDIReadEvent::NO_MESSAGE;
     144             :         }
     145             :         // If it's a channel message with one data byte
     146             :         else {
     147          11 :             midimsg.data1 = midiByte;
     148          11 :             midimsg.data2 = 0;
     149          11 :             runningHeader = midimsg.header;
     150          11 :             currentHeader = 0;
     151             :             // The message is finished
     152          11 :             return MIDIReadEvent::CHANNEL_MESSAGE;
     153             :         }
     154             :     }
     155             : 
     156             :     // If it's a system common message
     157         719 :     else if (midimsg.hasValidSystemCommonHeader()) {
     158             :         // If it's a system common message with two data bytes
     159          12 :         if (SysCommonMessage(midimsg).getNumberOfDataBytes() == 2) {
     160           6 :             midimsg.data1 = midiByte;
     161             :             // We've received the second byte, expect the third byte next
     162           6 :             thirdByte = true;
     163           6 :             return MIDIReadEvent::NO_MESSAGE;
     164             :         }
     165             :         // If it's a system common message with one data byte
     166           6 :         else if (SysCommonMessage(midimsg).getNumberOfDataBytes() == 1) {
     167           6 :             midimsg.data1 = midiByte;
     168           6 :             midimsg.data2 = 0;
     169           6 :             if (sysCommonCancelsRunningStatus)
     170           5 :                 runningHeader = 0;
     171           6 :             currentHeader = 0;
     172             :             // The message is finished
     173           6 :             return MIDIReadEvent::SYSCOMMON_MESSAGE;
     174             :         }
     175             :     }
     176             : 
     177             :     // Otherwise, it's not a channel message
     178             : 
     179             : #if !IGNORE_SYSEX
     180             :     // If we're receiving a SysEx message, it's a SysEx data byte
     181         707 :     else if (currentHeader == uint8_t(MIDIMessageType::SysExStart)) {
     182             :         // Check if the SysEx buffer has enough space to store the data
     183         707 :         if (!hasSysExSpace()) {
     184           3 :             storeByte(midiByte); // Remember to add it next time
     185           3 :             return MIDIReadEvent::SYSEX_CHUNK;
     186             :         }
     187             : 
     188         704 :         addSysExByte(midiByte);
     189         704 :         return MIDIReadEvent::NO_MESSAGE;
     190             :     }
     191             : #endif // IGNORE_SYSEX
     192             : 
     193             :     DEBUGREF(F("Data byte after invalid header")); // LCOV_EXCL_LINE
     194             :     runningHeader = 0;                             // LCOV_EXCL_LINE
     195             :     currentHeader = 0;                             // LCOV_EXCL_LINE
     196             :     return MIDIReadEvent::NO_MESSAGE;              // LCOV_EXCL_LINE
     197             : }
     198             : 
     199        1010 : MIDIReadEvent SerialMIDI_Parser::feed(uint8_t midiByte) {
     200             :     // DEBUGREF(hex << NAMEDVALUE(midiByte) << dec);
     201             : 
     202             :     // If it's a status byte (first byte of a message)
     203        1010 :     if (isStatus(midiByte)) {
     204         140 :         return handleStatus(midiByte);
     205             :     }
     206             :     // If it's a data byte
     207             :     else {
     208         870 :         return handleData(midiByte);
     209             :     }
     210             : }
     211             : 
     212         200 : MIDIReadEvent SerialMIDI_Parser::resume() {
     213         200 :     if (!hasStoredByte())
     214         189 :         return MIDIReadEvent::NO_MESSAGE;
     215             : 
     216          11 :     uint8_t midiByte = popStoredByte();
     217             : 
     218             : #if !IGNORE_SYSEX
     219             :     // If a SysEx message was in progress
     220          11 :     if (currentHeader == uint8_t(MIDIMessageType::SysExStart)) {
     221             :         // Reset the buffer for the next chunk
     222           4 :         startSysEx();
     223             :     }
     224             : #endif
     225             : 
     226          11 :     return feed(midiByte);
     227             : }
     228             : 
     229             : END_CS_NAMESPACE