  So you want to use tclmidi with a different MIDI driver?  Well,
you'll need to create a new subclass of MidiDevice in the device
directory.  MPU401 and MPU401Copy are examples of this.
  The MidiDevice class is a pure virtual class and contains the
prototypes for the four virtual functions that need to be written
in the new subclass.  These virtual functions are Play, Record,
Stop and Wait.

int Play(Song *s, int r = 0)
  This is the function that plays MIDI songs.  The first argument
is a pointer to the song to be played and the second argument is
a boolean that determines if the song should be repeated when
it reaches the end.
  Play returns an int signifying if the song could be played or
not.  1 if playing is possible, 0 if not.
  Play should return immediately, and must not block.


int Record(Song *rec_song, Song *play_song = 0, int r = 0)
  This is the function that records a MIDI song.  The first argument
is a pointer to the Song where the incoming events should be placed.
The second argument is an optional argument.  It specifies a song
that should be played while recording.  The last argument is another
optional argument that determines if the play song should be repeated
when it reaches its end.
  Record returns an int signifying if the song could be recorded or
not.  1 if recording is possible, 0 if not.
  Like Play, Record should return immediately, and must not block.

int Stop(void)
  This function stops all Playing and recording currently in progress.
It should turn off any notes currently on.
  Stop returns 1 if it could successfully stop recording or playing,
0 otherwise.

int Wait(void)
  This function blocks until the song currently playing reaches the
end.  In the case that the song playing is in repeat mode, Wait
will block forever until a Stop call is made.
  Wait returns 1 if it could wait successfully, 0 otherwise.


  The tricky part to implementing a device interface is the requirement
that Play and Record not block.  The MPU401 interface does this by
catching SIGIOs and putting the device in ASYNC mode.  Other devices
that don't have an ASYNC mode will have to come up with other methods
to avoid blocking.  Forking, spawning a thread or using itimer might
be solutions.
  The new class should be wrapped in a define to control if it
will be compiled.  Something similar to USE_MPU401.
  Once the new class is written, a hook should be added to tclmPlay.C.
The proper header file should be included and an instance of the
device interface created.  Lines similar to the following should be added:
#ifdef USE_MPU401
#include "MPU401.h"
#endif

#ifdef USE_MPU401
	tclm_interp->SetMidiDevice(new MPU401("/dev/midi0"));
#else
	tclm_interp->SetMidiDevice(0);
#endif
