parse()

template<class Transport, class Settings, class Platform>

bool MidiInterface< Transport, Settings, Platform >::parse ( )

private

Definition at line 783 of file MIDI.hpp.

{
    if (mTransport.available() == 0)
        return false; // No data available.
 
    // clear the ErrorParse bit
    mLastError &= ~(1UL << ErrorParse);
 
    // Parsing algorithm:
    // Get a byte from the serial buffer.
    // If there is no pending message to be recomposed, start a new one.
    //  - Find type and channel (if pertinent)
    //  - Look for other bytes in buffer, call parser recursively,
    //    until the message is assembled or the buffer is empty.
    // Else, add the extracted byte to the pending message, and check validity.
    // When the message is done, store it.
 
    const byte extracted = mTransport.read();
 
    // Ignore Undefined
    if (extracted == Undefined_FD)
        return (Settings::Use1ByteParsing) ? false : parse();
 
    if (mPendingMessageIndex == 0)
    {
        // Start a new pending message
        mPendingMessage[0] = extracted;
 
        // Check for running status first
        if (isChannelMessage(getTypeFromStatusByte(mRunningStatus_RX)))
        {
            // Only these types allow Running Status
 
            // If the status byte is not received, prepend it
            // to the pending message
            if (extracted < 0x80)
            {
                mPendingMessage[0]   = mRunningStatus_RX;
                mPendingMessage[1]   = extracted;
                mPendingMessageIndex = 1;
            }
            // Else: well, we received another status byte,
            // so the running status does not apply here.
            // It will be updated upon completion of this message.
        }
 
        const MidiType pendingType = getTypeFromStatusByte(mPendingMessage[0]);
 
        switch (pendingType)
        {
            // 1 byte messages
            case Start:
            case Continue:
            case Stop:
            case Clock:
            case Tick:
            case ActiveSensing:
            case SystemReset:
            case TuneRequest:
                // Handle the message type directly here.
                mMessage.type    = pendingType;
                mMessage.channel = 0;
                mMessage.data1   = 0;
                mMessage.data2   = 0;
                mMessage.valid   = true;
 
                // Do not reset all input attributes, Running Status must remain unchanged.
                // We still need to reset these
                mPendingMessageIndex = 0;
                mPendingMessageExpectedLength = 0;
 
                return true;
                break;
 
            // 2 bytes messages
            case ProgramChange:
            case AfterTouchChannel:
            case TimeCodeQuarterFrame:
            case SongSelect:
                mPendingMessageExpectedLength = 2;
                break;
 
            // 3 bytes messages
            case NoteOn:
            case NoteOff:
            case ControlChange:
            case PitchBend:
            case AfterTouchPoly:
            case SongPosition:
                mPendingMessageExpectedLength = 3;
                break;
 
            case SystemExclusiveStart:
            case SystemExclusiveEnd:
                // The message can be any length
                // between 3 and MidiMessage::sSysExMaxSize bytes
                mPendingMessageExpectedLength = MidiMessage::sSysExMaxSize;
                mRunningStatus_RX = InvalidType;
                mMessage.sysexArray[0] = pendingType;
                break;
 
            case InvalidType:
            default:
                // This is obviously wrong. Let's get the hell out'a here.
                mLastError |= 1UL << ErrorParse; // set the ErrorParse bit
                if (mErrorCallback)
                    mErrorCallback(mLastError); // LCOV_EXCL_LINE
 
                resetInput();
                return false;
                break;
        }
 
        if (mPendingMessageIndex >= (mPendingMessageExpectedLength - 1))
        {
            // Reception complete
            mMessage.type    = pendingType;
            mMessage.channel = getChannelFromStatusByte(mPendingMessage[0]);
            mMessage.data1   = mPendingMessage[1];
            mMessage.data2   = 0; // Completed new message has 1 data byte
            mMessage.length  = 1;
 
            mPendingMessageIndex = 0;
            mPendingMessageExpectedLength = 0;
            mMessage.valid = true;
 
            return true;
        }
        else
        {
            // Waiting for more data
            mPendingMessageIndex++;
        }
 
        return (Settings::Use1ByteParsing) ? false : parse();
    }
    else
    {
        // First, test if this is a status byte
        if (extracted >= 0x80)
        {
            // Reception of status bytes in the middle of an uncompleted message
            // are allowed only for interleaved Real Time message or EOX
            switch (extracted)
            {
                case Clock:
                case Start:
                case Tick:
                case Continue:
                case Stop:
                case ActiveSensing:
                case SystemReset:
 
                    // Here we will have to extract the one-byte message,
                    // pass it to the structure for being read outside
                    // the MIDI class, and recompose the message it was
                    // interleaved into. Oh, and without killing the running status..
                    // This is done by leaving the pending message as is,
                    // it will be completed on next calls.
 
                    mMessage.type    = (MidiType)extracted;
                    mMessage.data1   = 0;
                    mMessage.data2   = 0;
                    mMessage.channel = 0;
                    mMessage.length  = 1;
                    mMessage.valid   = true;
 
                    return true;
 
                    // Exclusive
                case SystemExclusiveStart:
                case SystemExclusiveEnd:
                    if ((mMessage.sysexArray[0] == SystemExclusiveStart)
                    ||  (mMessage.sysexArray[0] == SystemExclusiveEnd))
                    {
                        // Store the last byte (EOX)
                        mMessage.sysexArray[mPendingMessageIndex++] = extracted;
                        mMessage.type = SystemExclusive;
 
                        // Get length
                        mMessage.data1   = mPendingMessageIndex & 0xff; // LSB
                        mMessage.data2   = byte(mPendingMessageIndex >> 8);   // MSB
                        mMessage.channel = 0;
                        mMessage.length  = mPendingMessageIndex;
                        mMessage.valid   = true;
 
                        resetInput();
 
                        return true;
                    }
                    else
                    {
                        // Well well well.. error.
                        mLastError |= 1UL << ErrorParse; // set the error bits
                        if (mErrorCallback)
                            mErrorCallback(mLastError); // LCOV_EXCL_LINE
 
                        resetInput();
                        return false;
                    }
 
                default:
                    break; // LCOV_EXCL_LINE - Coverage blind spot
            }
        }
 
        // Add extracted data byte to pending message
        if ((mPendingMessage[0] == SystemExclusiveStart)
        ||  (mPendingMessage[0] == SystemExclusiveEnd))
            mMessage.sysexArray[mPendingMessageIndex] = extracted;
        else
            mPendingMessage[mPendingMessageIndex] = extracted;
 
        // Now we are going to check if we have reached the end of the message
        if (mPendingMessageIndex >= (mPendingMessageExpectedLength - 1))
        {
            // SysEx larger than the allocated buffer size,
            // Split SysEx like so:
            //   first:  0xF0 .... 0xF0
            //   midlle: 0xF7 .... 0xF0
            //   last:   0xF7 .... 0xF7
            if ((mPendingMessage[0] == SystemExclusiveStart)
            ||  (mPendingMessage[0] == SystemExclusiveEnd))
            {
                auto lastByte = mMessage.sysexArray[Settings::SysExMaxSize - 1];
                mMessage.sysexArray[Settings::SysExMaxSize - 1] = SystemExclusiveStart;
                mMessage.type = SystemExclusive;
 
                // Get length
                mMessage.data1   = Settings::SysExMaxSize & 0xff; // LSB
                mMessage.data2   = byte(Settings::SysExMaxSize >> 8); // MSB
                mMessage.channel = 0;
                mMessage.length  = Settings::SysExMaxSize;
                mMessage.valid   = true;
 
                // No need to check against the inputChannel,
                // SysEx ignores input channel
                launchCallback();
 
                mMessage.sysexArray[0] = SystemExclusiveEnd;
                mMessage.sysexArray[1] = lastByte;
 
                mPendingMessageIndex = 2;
 
                return false;
            }
 
            mMessage.type = getTypeFromStatusByte(mPendingMessage[0]);
 
            if (isChannelMessage(mMessage.type))
                mMessage.channel = getChannelFromStatusByte(mPendingMessage[0]);
            else
                mMessage.channel = 0;
 
            mMessage.data1 = mPendingMessage[1];
            // Save data2 only if applicable
            mMessage.data2 = mPendingMessageExpectedLength == 3 ? mPendingMessage[2] : 0;
 
            // Reset local variables
            mPendingMessageIndex = 0;
            mPendingMessageExpectedLength = 0;
 
            mMessage.valid = true;
 
            // Activate running status (if enabled for the received type)
            switch (mMessage.type)
            {
                case NoteOff:
                case NoteOn:
                case AfterTouchPoly:
                case ControlChange:
                case ProgramChange:
                case AfterTouchChannel:
                case PitchBend:
                    // Running status enabled: store it from received message
                    mRunningStatus_RX = mPendingMessage[0];
                    break;
 
                default:
                    // No running status
                    mRunningStatus_RX = InvalidType;
                    break;
            }
            return true;
        }
        else
        {
            // Then update the index of the pending message.
            mPendingMessageIndex++;
 
            return (Settings::Use1ByteParsing) ? false : parse();
        }
    }
}

References ActiveSensing, AfterTouchChannel, AfterTouchPoly, Clock, Continue, ControlChange, ErrorParse, getChannelFromStatusByte(), getTypeFromStatusByte(), InvalidType, isChannelMessage(), launchCallback(), mErrorCallback, mLastError, mMessage, mPendingMessage, mPendingMessageExpectedLength, mPendingMessageIndex, mRunningStatus_RX, mTransport, NoteOff, NoteOn, parse(), PitchBend, ProgramChange, resetInput(), SongPosition, SongSelect, Message< Settings::SysExMaxSize >::sSysExMaxSize, Start, Stop, SystemExclusive, SystemExclusiveEnd, SystemExclusiveStart, SystemReset, Tick, TimeCodeQuarterFrame, TuneRequest, and Undefined_FD.

Referenced by parse(), and read().

Here is the call graph for this function:

Here is the caller graph for this function: