Midi.h

#pragma once
#include <Bela.h>
#include <vector>
#include <string>
#ifdef XENOMAI_SKIN_native
#include <native/pipe.h>
#endif

typedef unsigned char midi_byte_t;

typedef enum midiMessageType{
        kmmNoteOff = 0,
        kmmNoteOn,
        kmmPolyphonicKeyPressure,
        kmmControlChange,
        kmmProgramChange,
        kmmChannelPressure,
        kmmPitchBend,
        kmmSystem,
        kmmNone,
        kmmAny,
} MidiMessageType;
#define midiMessageStatusBytesLength 8+2 //2 being kmmNone and kmmAny

extern midi_byte_t midiMessageStatusBytes[midiMessageStatusBytesLength];
extern unsigned int midiMessageNumDataBytes[midiMessageStatusBytesLength];

class MidiChannelMessage{
public:
        MidiChannelMessage();
        MidiChannelMessage(MidiMessageType type);
        midi_byte_t getStatusByte() const {
                return _statusByte;
        }
        virtual ~MidiChannelMessage();
        MidiMessageType getType() const;
        int getChannel() const;
        const char* getTypeText() const {
                return getTypeText(getType());
        }
        static const char* getTypeText(MidiMessageType type){
                switch (type) {
                case kmmNoteOff: 
                        return "note off";
                case kmmNoteOn:
                        return "note on";
                case kmmPolyphonicKeyPressure:
                        return "polyphonic aftertouch";
                case kmmControlChange:
                        return "control change";
                case kmmProgramChange:
                        return "program change";
                case kmmChannelPressure:
                        return "channel aftertouch";
                case kmmPitchBend:
                        return "pitch bend";
                case kmmSystem:
                        return "system";
                case kmmAny:
                        return "any";
                case kmmNone:
                default:
                        return "none";
                }
        }

        unsigned int getNumDataBytes() const {
                return midiMessageNumDataBytes[(unsigned int)_type];
        }
        void setDataByte(unsigned int dataByteIndex, midi_byte_t input){
                _dataBytes[dataByteIndex] = input;
        }
        void setType(MidiMessageType type){
                _type = type;
                _statusByte = midiMessageStatusBytes[_type];
        }
        void setChannel(midi_byte_t channel){
                _channel = channel;
        }
        midi_byte_t getDataByte(unsigned int index) const {
                return _dataBytes[index];
        }
        void clear(){
                for(int n = 0; n<maxDataBytes; n++){
                        _dataBytes[n] = 0;
                }
                _type = kmmNone;
                _statusByte = 0;
        }
        void prettyPrint() const {
                rt_printf("type: %s,  ", this->getTypeText());
                rt_printf("channel: %u, ", this->getChannel());
                for(unsigned int n = 0; n < this->getNumDataBytes(); n++){
                        rt_printf("data%d: %d, ", n + 1, this->getDataByte(n));
                }
                rt_printf("\n");
        }
private:
        const static int maxDataBytes = 2;
protected:
        midi_byte_t _statusByte;
        midi_byte_t _dataBytes[maxDataBytes]; // where 2 is the maximum number of data bytes for a channel message
        MidiMessageType _type;
        midi_byte_t _channel;
};
/*
class MidiControlChangeMessage : public MidiChannelMessage{
        int number;
        int value;
public:
        int getNumber();
        int getNumDataBytes();
        int setDataByte(midi_byte_t input, unsigned int dataByteIndex);
        int getValue();
        int set(midi_byte_t* input);
};

class MidiNoteMessage : public MidiChannelMessage{
        int note;
        int velocity;
public:
        int getNote();
        int getVelocity();
        int getNumDataBytes();
        int setDataByte(midi_byte_t input, unsigned int dataByteIndex);
};

class MidiProgramChangeMessage : public MidiChannelMessage{
        midi_byte_t program;
public:
        int getNumDataBytes();
        int setDataByte(midi_byte_t input, unsigned int dataByteIndex);
        midi_byte_t getProgram();
};
*/

class MidiParser{
private:
        std::vector<MidiChannelMessage> messages;
        unsigned int writePointer;
        unsigned int readPointer;
        unsigned int elapsedDataBytes;
        bool waitingForStatus;
        bool receivingSysex;
        void (*messageReadyCallback)(MidiChannelMessage,void*);
        void* callbackArg;
        void (*sysexCallback)(midi_byte_t,void*);
        void* sysexCallbackArg;
public:
        MidiParser(){
                waitingForStatus = true;
                receivingSysex = false;
                elapsedDataBytes= 0;
                messages.resize(100); // 100 is the number of messages that can be buffered
                writePointer = 0;
                readPointer = 0;
                messageReadyCallback = nullptr;
                callbackArg = nullptr;
                sysexCallback = nullptr;
                sysexCallbackArg = nullptr;
        }

        int parse(midi_byte_t* input, unsigned int length);

        void setCallback(void (*newCallback)(MidiChannelMessage, void*), void* arg=NULL){
                callbackArg = arg;
                messageReadyCallback = newCallback;
        };

        bool isCallbackEnabled(){
                return messageReadyCallback != nullptr;
        };

        void setSysexCallback(void (*newCallback)(midi_byte_t, void*), void* arg=nullptr){
                sysexCallbackArg = arg;
                sysexCallback = newCallback;
        };

        bool isSysexCallbackEnabled(){
                return sysexCallback != nullptr;
        };

        int numAvailableMessages(){
                int num = (writePointer - readPointer + messages.size() ) % messages.size();
                return num;
        }

        MidiChannelMessage getNextChannelMessage(){
                MidiChannelMessage message;
                message = messages[readPointer];
                if(message.getType() == kmmNone){
                        message.clear();
                }
                messages[readPointer].setType(kmmNone); // do not use it again
                readPointer++;
                if(readPointer == messages.size()){
                        readPointer = 0;
                }
                return message;
        };

//      MidiChannelMessage getNextChannelMessage(){
//              getNextChannelMessage(kmmAny);
//      }
//      MidiControlChangeMessage* getNextControlChangeMessage(){
//              return (MidiControlChangeMessage*)getNextChannelMessage(kmmControlChange);
//      };
//      MidiProgramChangeMessage* getNextProgramChangeMessage(){
//              return (MidiProgramChangeMessage*)getNextChannelMessage(kmmProgramChange);
//      };
//      MidiNoteMessage* getNextNoteOnMessage(){
//              return (MidiNoteMessage*)getNextChannelMessage(kmmNoteOn);
//      };
};


typedef struct _snd_rawmidi snd_rawmidi_t;
class Midi {
public:
        Midi();
        void setup();
        void cleanup();
        void enableParser(bool enable);

        MidiParser* getParser();

        void setParserCallback(void (*callback)(MidiChannelMessage, void*), void* arg=NULL){
                // if callback is not NULL, also enable the parser
                enableParser(callback != NULL); //this needs to be first, as it deletes the parser(if exists)
                getParser()->setCallback(callback, arg);
        }

        int readFrom(const char* port);

        int writeTo(const char* port);

        int getInput();

        int writeOutput(midi_byte_t byte);

        int writeOutput(midi_byte_t* bytes, unsigned int length);
        

        static midi_byte_t makeStatusByte(midi_byte_t statusCode, midi_byte_t dataByte);
        int writeMessage(midi_byte_t statusCode, midi_byte_t channel, midi_byte_t dataByte);
        int writeMessage(midi_byte_t statusCode, midi_byte_t channel, midi_byte_t dataByte1, midi_byte_t dataByte2);
        int writeMessage(const MidiChannelMessage& msg);
        int writeNoteOff(midi_byte_t channel, midi_byte_t pitch, midi_byte_t velocity);
        int writeNoteOn(midi_byte_t channel, midi_byte_t pitch, midi_byte_t velocity);
        int writePolyphonicKeyPressure(midi_byte_t channel, midi_byte_t pitch, midi_byte_t pressure);
        int writeControlChange(midi_byte_t channel, midi_byte_t controller, midi_byte_t value);
        int writeProgramChange(midi_byte_t channel, midi_byte_t program);
        int writeChannelPressure(midi_byte_t channel, midi_byte_t pressure);
        int writePitchBend(midi_byte_t channel, uint16_t bend);

        MidiParser* getMidiParser();
        virtual ~Midi();

        bool isInputEnabled();

        bool isOutputEnabled();

        static void createAllPorts(std::vector<Midi*>& ports, bool useParser = false);

        static void destroyPorts(std::vector<Midi*>& ports);
private:
        char defaultPort[9];
        std::string inPort;
        std::string outPort;
        int _getInput();
        int attemptRecoveryRead();
        static void readInputLoop(void* obj);
        int attemptRecoveryWrite();
        static void writeOutputLoop(void* obj);
        snd_rawmidi_t *alsaIn,*alsaOut;
        std::vector<midi_byte_t> inputBytes;
        unsigned int inputBytesWritePointer;
        unsigned int inputBytesReadPointer;
        std::vector<midi_byte_t> outputBytes;
        MidiParser* inputParser;
        bool parserEnabled;
        bool inputEnabled;
        bool outputEnabled;
        AuxiliaryTask midiInputTask;
        AuxiliaryTask midiOutputTask;
        char* inId;
        char* outId;
        char* outPipeName;
#ifdef XENOMAI_SKIN_native
        RT_PIPE outPipe;
#endif
#ifdef XENOMAI_SKIN_posix
        int sock;
#endif
};