Midi.h

/*
 * Midi.h
 *
 *  Created on: 15 Jan 2016
 *      Author: giulio
 */

#ifndef MIDI_H_
#define MIDI_H_

#include <Bela.h>
#include <vector>

typedef unsigned char midi_byte_t;


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

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

class MidiChannelMessage{
public:
        MidiChannelMessage();
        MidiChannelMessage(MidiMessageType type);
        virtual ~MidiChannelMessage();
        MidiMessageType getType();
        int getChannel();
        unsigned int getNumDataBytes(){
                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){
                return _dataBytes[index];
        }
        void clear(){
                for(int n = 0; n<maxDataBytes; n++){
                        _dataBytes[n] = 0;
                }
                _type = kmmNone;
                _statusByte = 0;
        }
        void prettyPrint(){
                rt_printf("MessageType: %x,  ", this->getType());
                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;
        void (*messageReadyCallback)(MidiChannelMessage,void*);
        bool callbackEnabled;
        void* callbackArg;
public:
        MidiParser(){
                waitingForStatus = true;
                elapsedDataBytes= 0;
                messages.resize(100); // 100 is the number of messages that can be buffered
                writePointer = 0;
                readPointer = 0;
                callbackEnabled = false;
                messageReadyCallback = NULL;
                callbackArg = NULL;
        }

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

        void setCallback(void (*newCallback)(MidiChannelMessage, void*), void* arg=NULL){
                callbackArg = arg;
                messageReadyCallback = newCallback;
                if(newCallback != NULL){
                        callbackEnabled = true;
                } else {
                        callbackEnabled = false;
                }
        };

        bool isCallbackEnabled(){
                return callbackEnabled;
        };

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

        MidiChannelMessage getNextChannelMessage(/*MidiMessageType type*/){
                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);
//      };
};


class Midi {
public:
        Midi();

        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(int port);

        int writeTo(int port);

        int getInput();

        int writeOutput(midi_byte_t byte);

        int writeOutput(midi_byte_t* bytes, unsigned int length);
        MidiParser* getMidiParser();
        virtual ~Midi();
        static void midiInputLoop();
        static void midiOutputLoop();
    static bool staticConstructed;
        static void staticConstructor();
private:
        int _getInput();
        void readInputLoop();
        void writeOutputLoop();
        int outputPort;
        int inputPort;
        std::vector<midi_byte_t> inputBytes;
        unsigned int inputBytesWritePointer;
        unsigned int inputBytesReadPointer;
        std::vector<midi_byte_t> outputBytes;
        unsigned int outputBytesWritePointer;
        unsigned int outputBytesReadPointer;
        MidiParser* inputParser;
        bool parserEnabled;
        static std::vector<Midi*> objAddrs[2];
        static AuxiliaryTask midiInputTask;
        static AuxiliaryTask midiOutputTask;
};


#endif /* MIDI_H_ */