MIDIIOP.h

Go to the documentation of this file.

#ifndef CSL_MIDIIO_H
#define CSL_MIDIIO_H

#include "CSL_Types.h"
#include "CGestalt.h"

#include "math.h"
#include "portmidi.h"
#include "porttime.h"

// copied from 240_test.c. need to sort out where it belongs.

#define OUTPUT_BUFFER_SIZE 0
#define DRIVER_INFO NULL
#define TIME_PROC Pt_Time
#define TIME_INFO NULL
#define TIME_START Pt_Start(1, 0, 0) /* timer started w/millisecond accuracy */
#define MIDI_THRU NULL

// PmDeviceInfo data structure taken from portmidi.h
//
//  typedef struct {
//      int structVersion; 
//      const char *interf; /* underlying MIDI API, e.g. MMSystem or DirectX */
//      const char *name;   /* device name, e.g. USB MidiSport 1x1 */
//      int input;          /* true iff input is available */
//      int output;         /* true iff output is available */
//      int opened;         /* used by generic PortMidi code to do error checking on arguments */       
//  } PmDeviceInfo;

// PmEvent data structure taken from portmidi.h
//  typedef long PmMessage;
//  typedef struct {
//      PmMessage      message;
//      PmTimestamp    timestamp;
//  } PmEvent;

namespace csl {
    

typedef enum {
    kNone           = 0,
    kNoteOff        = 8,
    kNoteOn         = 9,
    kPolyTouch      = 10,
    kControlChange  = 11,
    kProgramChange  = 12,
    kAftertouch     = 13,
    kPitchWheel     = 14,
    kSysEX          = 15
} CSL_MIDIMessageType;


class CSL_MIDIMessage {

public:
    CSL_MIDIMessageType message;
    unsigned channel;   // 0-indexed, so from 0 to 15 
    unsigned data1;
    unsigned data2;
    long time;
    
    CSL_MIDIMessage();
//  CSL_MIDIMessage(CSL_MIDIMessageType, ch, d1, d2 );
}; 


void copy_CSL_MIDIMessage(CSL_MIDIMessage* source, CSL_MIDIMessage* dest );


void CSL_MIDIMessageToPmEvent(CSL_MIDIMessage* cslMIDI, PmEvent* event );


void PmEventToCSL_MIDIMessage( PmEvent* event, CSL_MIDIMessage* cslMIDI );


unsigned Message_ChannelToStatus(CSL_MIDIMessageType message, unsigned channel );


class MIDIIO {
public: 
    MIDIIO();
    virtual ~MIDIIO();
    
    virtual void open() { };        
    bool is_open();                 
    void close();                   
    void dump_device_info();        
    void dump_count_devices();      

    int count_devices();
    int get_default_input_id();
    int get_default_output_id();    
    const PmDeviceInfo* get_device_info(int deviceID );
    
protected:
    PmStream * mMIDIStream;         
    PmDeviceID mDeviceID;           

    static bool mIsInitialized; 
    static unsigned mNumInstantiated;
    static bool mIsPortTimeStarted;
    
    bool mIsInput;
    bool mIsOutput;
    bool mIsOpen;

    void handle_error(PmError err);
};


class MIDIIn : public MIDIIO {
public:
    MIDIIn();   
    
    unsigned buffer_size();
    void set_buffer_size(unsigned bufferSize );
    void open();                
    void open(int deviceID);
    bool poll();
    void read();                
    void read_interpret();      
    
    PmEvent buffer() { return mBuffer[0]; }
    void dump_buffer();

    CSL_MIDIMessage message() { return mMsg; }
    void dump_CSL_MIDIMessage();
    
    bool is_NoteOn_received();
    bool is_NoteOff_received();
    bool is_PolyTouch_received();
    bool is_ControlChange_received();
    bool is_ProgramChange_received();
    bool is_Aftertouch_received();
    bool is_PitchWheel_received();
    bool is_SysEX_received();
    
    unsigned get_note();
    unsigned get_velocity();
    unsigned get_PolyAftertouch();
    unsigned get_ControlChange_function();
    unsigned get_ControlChange_value();
    unsigned get_ProgramNumber();
    unsigned get_Aftertouch();
    unsigned get_PitchWheel();
    float get_frequency();
    float get_velocity_float();  
    
    void setFilter();
    void filter_active_sensing(bool flag );
    void filter_sysex(bool flag );
    void filter_clock_msg(bool flag );
    

protected:
    long     mBufferSize;
    long     mFilterFlag;
    
    CSL_MIDIMessage mMsg;
    
    PmEvent mBuffer[1]; 
    PmError mLength;    

};


class MIDIOut : public MIDIIO {
public:
    MIDIOut();
    ~MIDIOut();

    unsigned buffer_size();                         
    void set_buffer_size(unsigned bufferSize ); // TODO: should not be called after opening.
    long latency();
    void set_latency(long latency );            // TODO: should not be called after opening.
    
    void open();
    void open(int deviceID );
    void set_message(CSL_MIDIMessage msg, long when ); 
    void write();
    void write(CSL_MIDIMessage* msg, long length );  
    void write_short(CSL_MIDIMessage msg );
    void write_SysEX(long when, unsigned char *msg );
    
    void write_NoteOn(unsigned channel, unsigned pitch, unsigned velocity );        
    void write_NoteOn(unsigned channel, float frequency, float amplitude );     
    void write_NoteOff(unsigned channel, unsigned pitch, unsigned velocity );       
    void write_NoteOff(unsigned channel, float frequency, float amplitude );        
    void write_PolyTouch(unsigned channel, unsigned pitch, unsigned amount );
    void write_ControlChange(unsigned channel, unsigned function, unsigned value );
    void write_ProgramChange(unsigned channel, unsigned programNum );
    void write_Aftertouch(unsigned channel, unsigned amount );                      
    void write_PitchWheel(unsigned channel, unsigned amount );                      

protected:
    long        mBufferSize;
    long        mLatency;
    
    CSL_MIDIMessage mMsg;
};

}   // csl namespace

#endif

---