MIDIIO.h

Go to the documentation of this file.

#ifndef CSL_MIDIIO_H
#define CSL_MIDIIO_H

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

#include "CSL_Types.h"
#include "CGestalt.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 );


float MIDINoteToFreq( unsigned midiNote );


unsigned FreqToMIDINote( float frequency );


class MIDIIO {
public: 
    MIDIIO();
    virtual ~MIDIIO();
    
    virtual status open() { return cslErr; };       
    bool is_open();                 
    status close();                 
    status 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 );
    status open();              
    status open(int deviceID);
    bool poll();
    status read();              // generic read method. gets MIDI message and store it in mBuffer
    status read_interpret();        // read method and sets internal flag for which message was received
    
    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();  // has range of [0.0 1.0] mapped to [0 127]
    
    status  setFilter();
    status  filter_active_sensing( bool flag );
    status  filter_sysex( bool flag );
    status  filter_clock_msg( bool flag );
    

protected:
    // fundamental members
    long     mBufferSize;
    long     mFilterFlag;
    
    CSL_MIDIMessage mMsg;
    
    PmEvent mBuffer[1]; // buffer which gets filled by read()
    PmError mLength;    // length 

};


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.
    
    status open();
    status open( int deviceID );
    void     set_message( CSL_MIDIMessage msg, long when ); 
    status write();
    status write( CSL_MIDIMessage* msg, long length );  // thin wrapper for Pm_Write
    status write_short( CSL_MIDIMessage msg );
    status write_SysEX( long when, unsigned char *msg );
    
                // convenience method for each MIDI messages
                // writes directly and doesn't use member mMsg for temporal storage.
    status write_NoteOn( unsigned channel, unsigned pitch, unsigned velocity );     // MIDINote#, [0, 127]
    status write_NoteOn( unsigned channel, float frequency, float amplitude );      // [Hz], [0.0 1.0];
    status write_NoteOff( unsigned channel, unsigned pitch, unsigned velocity );    // MIDINote#, [0, 127]
    status write_NoteOff( unsigned channel, float frequency, float amplitude );     // [Hz], [0.0 1.0];
    status write_PolyTouch( unsigned channel, unsigned pitch, unsigned amount );
    status write_ControlChange( unsigned channel, unsigned function, unsigned value );
    status write_ProgramChange( unsigned channel, unsigned programNum );
    status write_Aftertouch( unsigned channel, unsigned amount );                   // [0, 127]
    status write_PitchWheel( unsigned channel, unsigned amount );               // [0, 16384] 

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

}   // csl namespace

#endif