Release 1.0.0 tarball1.0.0

author: Gary Scavone <gary@music.mcgill.ca> 2013-10-11 15:04:06 +0200
committer: Stephen Sinclair <sinclair@music.mcgill.ca> 2013-10-11 15:04:06 +0200
commit: 1f910fbc187d2f50004bb0f7e619bd39f043b5b5 (patch)
tree: 8254a3a788c9cbf1e34a22f1320e865f525cfb36 /doxygen/html
parent: eeca35408122b9fc020139a20255f3c1ad8254cd (diff)
39 files changed, 3986 insertions, 0 deletions
diff --git a/doxygen/html/MidiFileIn_8cpp-source.html b/doxygen/html/MidiFileIn_8cpp-source.html
new file mode 100755
index 0000000..a7109dd
--- /dev/null
+++ b/doxygen/html/MidiFileIn_8cpp-source.html
@@ -0,0 +1,350 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>MidiFileIn.cpp</h1><div class="fragment"><pre>00001 <span class="comment">/**********************************************************************/</span>
+00016 <span class="comment">/**********************************************************************/</span>
+00017 
+00018 <span class="preprocessor">#include "MidiFileIn.h"</span>
+00019 <span class="preprocessor">#include &lt;iostream&gt;</span>
+00020 
+<a name="l00021"></a><a class="code" href="classMidiFileIn.html#a0">00021</a> <a class="code" href="classMidiFileIn.html#a0">MidiFileIn :: MidiFileIn</a>( std::string fileName )
+00022 {
+00023   <span class="comment">// Attempt to open the file.</span>
+00024   file_.open( fileName.c_str(), std::ios::in );
+00025   <span class="keywordflow">if</span> ( !file_ ) {
+00026     errorString_ &lt;&lt; <span class="stringliteral">"MidiFileIn: error opening or finding file ("</span> &lt;&lt;  fileName &lt;&lt; <span class="stringliteral">")."</span>;
+00027     <a class="code" href="classStk.html#e0">handleError</a>( errorString_.str(), StkError::FILE_NOT_FOUND );
+00028   }
+00029 
+00030   <span class="comment">// Parse header info.</span>
+00031   <span class="keywordtype">char</span> chunkType[4];
+00032   <span class="keywordtype">char</span> buffer[4];
+00033   SINT32 *length;
+00034   <span class="keywordflow">if</span> ( !file_.read( chunkType, 4 ) ) <span class="keywordflow">goto</span> error;
+00035   <span class="keywordflow">if</span> ( !file_.read( buffer, 4 ) ) <span class="keywordflow">goto</span> error;
+00036   length = (SINT32 *) &amp;buffer;
+00037   <span class="keywordflow">if</span> ( strncmp( chunkType, <span class="stringliteral">"MThd"</span>, 4 ) || ( *length != 6 ) ) {
+00038     errorString_ &lt;&lt; <span class="stringliteral">"MidiFileIn: file ("</span> &lt;&lt;  fileName &lt;&lt; <span class="stringliteral">") does not appear to be a MIDI file!"</span>;
+00039     <a class="code" href="classStk.html#e0">handleError</a>( errorString_.str(), StkError::FILE_UNKNOWN_FORMAT );
+00040   }
+00041 
+00042   <span class="comment">// Read the MIDI file format.</span>
+00043   SINT16 *data;
+00044   <span class="keywordflow">if</span> ( !file_.read( buffer, 2 ) ) <span class="keywordflow">goto</span> error;
+00045   data = (SINT16 *) &amp;buffer;
+00046   <span class="keywordflow">if</span> ( *data &lt; 0 || *data &gt; 2 ) {
+00047     errorString_ &lt;&lt; <span class="stringliteral">"MidiFileIn: the file ("</span> &lt;&lt;  fileName &lt;&lt; <span class="stringliteral">") format is invalid!"</span>;
+00048     <a class="code" href="classStk.html#e0">handleError</a>( errorString_.str(), StkError::FILE_ERROR );
+00049   }
+00050   format_ = *data;
+00051 
+00052   <span class="comment">// Read the number of tracks.</span>
+00053   <span class="keywordflow">if</span> ( !file_.read( buffer, 2 ) ) <span class="keywordflow">goto</span> error;
+00054   <span class="keywordflow">if</span> ( format_ == 0 &amp;&amp; *data != 1 ) {
+00055     errorString_ &lt;&lt; <span class="stringliteral">"MidiFileIn: invalid number of tracks (&gt;1) for a file format = 0!"</span>;
+00056     <a class="code" href="classStk.html#e0">handleError</a>( errorString_.str(), StkError::FILE_ERROR );
+00057   }
+00058   nTracks_ = *data;
+00059 
+00060   <span class="comment">// Read the beat division.</span>
+00061   <span class="keywordflow">if</span> ( !file_.read( buffer, 2 ) ) <span class="keywordflow">goto</span> error;
+00062   division_ = (int) *data;
+00063   <span class="keywordtype">double</span> tickrate;
+00064   usingTimeCode_ = <span class="keyword">false</span>;
+00065   <span class="keywordflow">if</span> ( *data &amp; 0x8000 ) {
+00066     <span class="comment">// Determine ticks per second from time-code formats.</span>
+00067     tickrate = (double) -(*data &amp; 0x7F00);
+00068     <span class="comment">// If frames per second value is 29, it really should be 29.97.</span>
+00069     <span class="keywordflow">if</span> ( tickrate == 29.0 ) tickrate = 29.97;
+00070     tickrate *= (*data &amp; 0x00FF);
+00071     usingTimeCode_ = <span class="keyword">true</span>;
+00072   }
+00073   <span class="keywordflow">else</span> {
+00074     tickrate = (double) (*data &amp; 0x7FFF); <span class="comment">// ticks per quarter note</span>
+00075   }
+00076 
+00077   <span class="comment">// Now locate the track offsets and lengths.  If not using time</span>
+00078   <span class="comment">// code, we can initialize the "tick time" using a default tempo of</span>
+00079   <span class="comment">// 120 beats per minute.  We will then check for tempo meta-events</span>
+00080   <span class="comment">// afterward.</span>
+00081   <span class="keywordflow">for</span> ( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> i=0; i&lt;nTracks_; i++ ) {
+00082     <span class="keywordflow">if</span> ( !file_.read( chunkType, 4 ) ) <span class="keywordflow">goto</span> error;
+00083     <span class="keywordflow">if</span> ( strncmp( chunkType, <span class="stringliteral">"MTrk"</span>, 4 ) ) <span class="keywordflow">goto</span> error;
+00084     <span class="keywordflow">if</span> ( !file_.read( buffer, 4 ) ) <span class="keywordflow">goto</span> error;
+00085     length = (SINT32 *) &amp;buffer;
+00086     trackLengths_.push_back( *length );
+00087     trackOffsets_.push_back( file_.tellg() );
+00088     trackPointers_.push_back( file_.tellg() );
+00089     trackStatus_.push_back( 0 );
+00090     file_.seekg( *length, std::ios_base::cur );
+00091     <span class="keywordflow">if</span> ( usingTimeCode_ ) tickSeconds_.push_back( (<span class="keywordtype">double</span>) (1.0 / tickrate) );
+00092     <span class="keywordflow">else</span> tickSeconds_.push_back( (<span class="keywordtype">double</span>) (0.5 / tickrate) );
+00093   }
+00094 
+00095   <span class="comment">// Save the initial tickSeconds parameter.</span>
+00096   TempoChange tempoEvent;
+00097   tempoEvent.count = 0;
+00098   tempoEvent.tickSeconds = tickSeconds_[0];
+00099   tempoEvents_.push_back( tempoEvent );
+00100 
+00101   <span class="comment">// If format 1 and not using time code, parse and save the tempo map</span>
+00102   <span class="comment">// on track 0.</span>
+00103   <span class="keywordflow">if</span> ( format_ == 1 &amp;&amp; !usingTimeCode_ ) {
+00104     std::vector&lt;unsigned char&gt; event;
+00105     <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> value, count;
+00106 
+00107     <span class="comment">// We need to temporarily change the usingTimeCode_ value here so</span>
+00108     <span class="comment">// that the getNextEvent() function doesn't try to check the tempo</span>
+00109     <span class="comment">// map (which we're creating here).</span>
+00110     usingTimeCode_ = <span class="keyword">true</span>;
+00111     count = <a class="code" href="classMidiFileIn.html#a7">getNextEvent</a>( &amp;event, 0 );
+00112     <span class="keywordflow">while</span> ( event.size() ) {
+00113       <span class="keywordflow">if</span> ( ( event.size() == 6 ) &amp;&amp; ( event[0] == 0xff ) &amp;&amp;
+00114            ( event[1] == 0x51 ) &amp;&amp; ( event[2] == 0x03 ) ) {
+00115         tempoEvent.count = count;
+00116         value = ( event[3] &lt;&lt; 16 ) + ( event[4] &lt;&lt; 8 ) + event[5];
+00117         tempoEvent.tickSeconds = (double) (0.000001 * value / tickrate);
+00118         <span class="keywordflow">if</span> ( count &gt; tempoEvents_.back().count )
+00119           tempoEvents_.push_back( tempoEvent );
+00120         <span class="keywordflow">else</span>
+00121           tempoEvents_.back() = tempoEvent;
+00122       }
+00123       count += <a class="code" href="classMidiFileIn.html#a7">getNextEvent</a>( &amp;event, 0 );
+00124     }
+00125     <a class="code" href="classMidiFileIn.html#a5">rewindTrack</a>( 0 );
+00126     <span class="keywordflow">for</span> ( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> i=0; i&lt;nTracks_; i++ ) {
+00127       trackCounters_.push_back( 0 );
+00128       trackTempoIndex_.push_back( 0 );
+00129     }
+00130     <span class="comment">// Change the time code flag back!</span>
+00131     usingTimeCode_ = <span class="keyword">false</span>;
+00132   }
+00133 
+00134   <span class="keywordflow">return</span>;
+00135 
+00136  error:
+00137   errorString_ &lt;&lt; <span class="stringliteral">"MidiFileIn: error reading from file ("</span> &lt;&lt;  fileName &lt;&lt; <span class="stringliteral">")."</span>;
+00138   <a class="code" href="classStk.html#e0">handleError</a>( errorString_.str(), StkError::FILE_ERROR );
+00139 }
+00140 
+<a name="l00141"></a><a class="code" href="classMidiFileIn.html#a1">00141</a> <a class="code" href="classMidiFileIn.html#a1">MidiFileIn :: ~MidiFileIn</a>()
+00142 {
+00143   <span class="comment">// An ifstream object implicitly closes itself during destruction</span>
+00144   <span class="comment">// but we'll make an explicit call to "close" anyway.</span>
+00145   file_.close(); 
+00146 }
+00147 
+<a name="l00148"></a><a class="code" href="classMidiFileIn.html#a2">00148</a> <span class="keywordtype">int</span> <a class="code" href="classMidiFileIn.html#a2">MidiFileIn :: getFileFormat</a>()<span class="keyword"> const</span>
+00149 <span class="keyword"></span>{
+00150   <span class="keywordflow">return</span> format_;
+00151 }
+00152 
+<a name="l00153"></a><a class="code" href="classMidiFileIn.html#a3">00153</a> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> <a class="code" href="classMidiFileIn.html#a3">MidiFileIn :: getNumberOfTracks</a>()<span class="keyword"> const</span>
+00154 <span class="keyword"></span>{
+00155   <span class="keywordflow">return</span> nTracks_;
+00156 }
+00157 
+<a name="l00158"></a><a class="code" href="classMidiFileIn.html#a4">00158</a> <span class="keywordtype">int</span> <a class="code" href="classMidiFileIn.html#a4">MidiFileIn :: getDivision</a>()<span class="keyword"> const</span>
+00159 <span class="keyword"></span>{
+00160   <span class="keywordflow">return</span> division_;
+00161 }
+00162 
+<a name="l00163"></a><a class="code" href="classMidiFileIn.html#a5">00163</a> <span class="keywordtype">void</span> <a class="code" href="classMidiFileIn.html#a5">MidiFileIn :: rewindTrack</a>( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> track )
+00164 {
+00165   <span class="keywordflow">if</span> ( track &gt;= nTracks_ ) {
+00166     errorString_ &lt;&lt; <span class="stringliteral">"MidiFileIn::getNextEvent: invalid track argument ("</span> &lt;&lt;  track &lt;&lt; <span class="stringliteral">")."</span>;
+00167     <a class="code" href="classStk.html#e0">handleError</a>( errorString_.str(), StkError::FUNCTION_ARGUMENT );
+00168   }
+00169 
+00170   trackPointers_[track] = trackOffsets_[track];
+00171   trackStatus_[track] = 0;
+00172   tickSeconds_[track] = tempoEvents_[0].tickSeconds;
+00173 }
+00174 
+<a name="l00175"></a><a class="code" href="classMidiFileIn.html#a6">00175</a> <span class="keywordtype">double</span> <a class="code" href="classMidiFileIn.html#a6">MidiFileIn :: getTickSeconds</a>( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> track )
+00176 {
+00177   <span class="comment">// Return the current tick value in seconds for the given track.</span>
+00178   <span class="keywordflow">if</span> ( track &gt;= nTracks_ ) {
+00179     errorString_ &lt;&lt; <span class="stringliteral">"MidiFileIn::getTickSeconds: invalid track argument ("</span> &lt;&lt;  track &lt;&lt; <span class="stringliteral">")."</span>;
+00180     <a class="code" href="classStk.html#e0">handleError</a>( errorString_.str(), StkError::FUNCTION_ARGUMENT );
+00181   }
+00182 
+00183   <span class="keywordflow">return</span> tickSeconds_[track];
+00184 }
+00185 
+<a name="l00186"></a><a class="code" href="classMidiFileIn.html#a7">00186</a> <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> <a class="code" href="classMidiFileIn.html#a7">MidiFileIn :: getNextEvent</a>( std::vector&lt;unsigned char&gt; *event, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> track )
+00187 {
+00188   <span class="comment">// Fill the user-provided vector with the next event in the</span>
+00189   <span class="comment">// specified track (default = 0) and return the event delta time in</span>
+00190   <span class="comment">// ticks.  This function assumes that the stored track pointer is</span>
+00191   <span class="comment">// positioned at the start of a track event.  If the track has</span>
+00192   <span class="comment">// reached its end, the event vector size will be zero.</span>
+00193   <span class="comment">//</span>
+00194   <span class="comment">// If we have a format 0 or 2 file and we're not using timecode, we</span>
+00195   <span class="comment">// should check every meta-event for tempo changes and make</span>
+00196   <span class="comment">// appropriate updates to the tickSeconds_ parameter if so.</span>
+00197   <span class="comment">//</span>
+00198   <span class="comment">// If we have a format 1 file and we're not using timecode, keep a</span>
+00199   <span class="comment">// running sum of ticks for each track and update the tickSeconds_</span>
+00200   <span class="comment">// parameter as needed based on the stored tempo map.</span>
+00201 
+00202   <span class="keywordflow">if</span> ( track &gt;= nTracks_ ) {
+00203     errorString_ &lt;&lt; <span class="stringliteral">"MidiFileIn::getNextEvent: invalid track argument ("</span> &lt;&lt;  track &lt;&lt; <span class="stringliteral">")."</span>;
+00204     <a class="code" href="classStk.html#e0">handleError</a>( errorString_.str(), StkError::FUNCTION_ARGUMENT );
+00205   }
+00206 
+00207   event-&gt;clear();
+00208   <span class="comment">// Check for the end of the track.</span>
+00209   <span class="keywordflow">if</span> ( (trackPointers_[track] - trackOffsets_[track]) &gt;= trackLengths_[track] )
+00210     <span class="keywordflow">return</span> 0;
+00211 
+00212   <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> ticks = 0, bytes = 0;
+00213   <span class="keywordtype">bool</span> isTempoEvent = <span class="keyword">false</span>;
+00214 
+00215   <span class="comment">// Read the event delta time.</span>
+00216   file_.seekg( trackPointers_[track], std::ios_base::beg );
+00217   <span class="keywordflow">if</span> ( !readVariableLength( &amp;ticks ) ) <span class="keywordflow">goto</span> error;
+00218 
+00219   <span class="comment">// Parse the event stream to determine the event length.</span>
+00220   <span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> c;
+00221   <span class="keywordflow">if</span> ( !file_.read( (<span class="keywordtype">char</span> *)&amp;c, 1 ) ) <span class="keywordflow">goto</span> error;
+00222   <span class="keywordflow">switch</span> ( c ) {
+00223 
+00224   <span class="keywordflow">case</span> 0xFF: <span class="comment">// A Meta-Event</span>
+00225     <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> position;
+00226     trackStatus_[track] = 0;
+00227     event-&gt;push_back( c );
+00228     <span class="keywordflow">if</span> ( !file_.read( (<span class="keywordtype">char</span> *)&amp;c, 1 ) ) <span class="keywordflow">goto</span> error;
+00229     event-&gt;push_back( c );
+00230     <span class="keywordflow">if</span> ( format_ != 1 &amp;&amp; ( c == 0x51 ) ) isTempoEvent = <span class="keyword">true</span>;
+00231     position = file_.tellg();
+00232     <span class="keywordflow">if</span> ( !readVariableLength( &amp;bytes ) ) <span class="keywordflow">goto</span> error;
+00233     bytes += ( (<span class="keywordtype">unsigned</span> <span class="keywordtype">long</span>)file_.tellg() - position );
+00234     file_.seekg( position, std::ios_base::beg );
+00235     <span class="keywordflow">break</span>;
+00236 
+00237   <span class="keywordflow">case</span> 0xF0 || 0xF7: <span class="comment">// The start or continuation of a Sysex event</span>
+00238     trackStatus_[track] = 0;
+00239     event-&gt;push_back( c );
+00240     position = file_.tellg();
+00241     <span class="keywordflow">if</span> ( !readVariableLength( &amp;bytes ) ) <span class="keywordflow">goto</span> error;
+00242     bytes += ( (<span class="keywordtype">unsigned</span> <span class="keywordtype">long</span>)file_.tellg() - position );
+00243     file_.seekg( position, std::ios_base::beg );
+00244     <span class="keywordflow">break</span>;
+00245 
+00246   <span class="keywordflow">default</span>: <span class="comment">// Should be a MIDI channel event</span>
+00247     <span class="keywordflow">if</span> ( c &amp; 0x80 ) { <span class="comment">// MIDI status byte</span>
+00248       <span class="keywordflow">if</span> ( c &gt; 0xF0 ) <span class="keywordflow">goto</span> error;
+00249       trackStatus_[track] = c;
+00250       event-&gt;push_back( c );
+00251       c &amp;= 0xF0;
+00252       <span class="keywordflow">if</span> ( (c == 0xC0) || (c == 0xD0) ) bytes = 1;
+00253       <span class="keywordflow">else</span> bytes = 2;
+00254     }
+00255     <span class="keywordflow">else</span> <span class="keywordflow">if</span> ( trackStatus_[track] &amp; 0x80 ) { <span class="comment">// Running status</span>
+00256       event-&gt;push_back( trackStatus_[track] );
+00257       event-&gt;push_back( c );
+00258       c = trackStatus_[track] &amp; 0xF0;
+00259       <span class="keywordflow">if</span> ( (c != 0xC0) &amp;&amp; (c != 0xD0) ) bytes = 1;
+00260     }
+00261     <span class="keywordflow">else</span> <span class="keywordflow">goto</span> error;
+00262 
+00263   }
+00264 
+00265   <span class="comment">// Read the rest of the event into the event vector.</span>
+00266   <span class="keywordflow">for</span> ( <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> i=0; i&lt;bytes; i++ ) {
+00267     <span class="keywordflow">if</span> ( !file_.read( (<span class="keywordtype">char</span> *)&amp;c, 1 ) ) <span class="keywordflow">goto</span> error;
+00268     event-&gt;push_back( c );
+00269   }
+00270 
+00271   <span class="keywordflow">if</span> ( !usingTimeCode_ ) {
+00272     <span class="keywordflow">if</span> ( isTempoEvent ) {
+00273       <span class="comment">// Parse the tempo event and update tickSeconds_[track].</span>
+00274       <span class="keywordtype">double</span> tickrate = (double) (division_ &amp; 0x7FFF);
+00275       <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> value = ( event-&gt;at(3) &lt;&lt; 16 ) + ( event-&gt;at(4) &lt;&lt; 8 ) + event-&gt;at(5);
+00276       tickSeconds_[track] = (double) (0.000001 * value / tickrate);
+00277     }
+00278 
+00279     <span class="keywordflow">if</span> ( format_ == 1 ) {
+00280       <span class="comment">// Update track counter and check the tempo map.</span>
+00281       trackCounters_[track] += ticks;
+00282       TempoChange tempoEvent = tempoEvents_[ trackTempoIndex_[track] ];
+00283       <span class="keywordflow">if</span> ( trackCounters_[track] &gt;= tempoEvent.count ) {
+00284         trackTempoIndex_[track]++;
+00285         tickSeconds_[track] = tempoEvent.tickSeconds;
+00286       }
+00287     }
+00288   }
+00289 
+00290   <span class="comment">// Save the current track pointer value.</span>
+00291   trackPointers_[track] = file_.tellg();
+00292 
+00293   <span class="keywordflow">return</span> ticks;
+00294 
+00295  error:
+00296   errorString_ &lt;&lt; <span class="stringliteral">"MidiFileIn::getNextEvent: file read error!"</span>;
+00297   <a class="code" href="classStk.html#e0">handleError</a>( errorString_.str(), StkError::FILE_ERROR );
+00298   <span class="keywordflow">return</span> 0;
+00299 }
+00300 
+<a name="l00301"></a><a class="code" href="classMidiFileIn.html#a8">00301</a> <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> <a class="code" href="classMidiFileIn.html#a8">MidiFileIn :: getNextMidiEvent</a>( std::vector&lt;unsigned char&gt; *midiEvent, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> track )
+00302 {
+00303   <span class="comment">// Fill the user-provided vector with the next MIDI event in the</span>
+00304   <span class="comment">// specified track (default = 0) and return the event delta time in</span>
+00305   <span class="comment">// ticks.  Meta-Events preceeding this event are skipped and ignored.</span>
+00306   <span class="keywordflow">if</span> ( track &gt;= nTracks_ ) {
+00307     errorString_ &lt;&lt; <span class="stringliteral">"MidiFileIn::getNextMidiEvent: invalid track argument ("</span> &lt;&lt;  track &lt;&lt; <span class="stringliteral">")."</span>;
+00308     <a class="code" href="classStk.html#e0">handleError</a>( errorString_.str(), StkError::FUNCTION_ARGUMENT );
+00309   }
+00310 
+00311   <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> ticks = <a class="code" href="classMidiFileIn.html#a7">getNextEvent</a>( midiEvent, track );
+00312   <span class="keywordflow">while</span> ( midiEvent-&gt;size() &amp;&amp; ( midiEvent-&gt;at(0) &gt;= 0xF0 ) ) {
+00313     <span class="keywordflow">for</span> ( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> i=0; i&lt;midiEvent-&gt;size(); i++ )
+00314       std::cout &lt;&lt; <span class="stringliteral">"event byte = "</span> &lt;&lt; i &lt;&lt; <span class="stringliteral">", value = "</span> &lt;&lt; (int)midiEvent-&gt;at(i) &lt;&lt; std::endl;
+00315     ticks = <a class="code" href="classMidiFileIn.html#a7">getNextEvent</a>( midiEvent, track );
+00316   }
+00317 
+00318   <span class="keywordflow">for</span> ( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> i=0; i&lt;midiEvent-&gt;size(); i++ )
+00319   std::cout &lt;&lt; <span class="stringliteral">"event byte = "</span> &lt;&lt; i &lt;&lt; <span class="stringliteral">", value = "</span> &lt;&lt; (int)midiEvent-&gt;at(i) &lt;&lt; std::endl;
+00320 
+00321   <span class="keywordflow">return</span> ticks;
+00322 }
+00323 
+00324 <span class="keywordtype">bool</span> MidiFileIn :: readVariableLength( <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> *value )
+00325 {
+00326   <span class="comment">// It is assumed that this function is called with the file read</span>
+00327   <span class="comment">// pointer positioned at the start of a variable-length value.  The</span>
+00328   <span class="comment">// function returns "true" if the value is successfully parsed and</span>
+00329   <span class="comment">// "false" otherwise.</span>
+00330   *value = 0;
+00331   <span class="keywordtype">char</span> c;
+00332 
+00333   <span class="keywordflow">if</span> ( !file_.read( &amp;c, 1 ) ) <span class="keywordflow">return</span> <span class="keyword">false</span>;
+00334   *value = (<span class="keywordtype">unsigned</span> <span class="keywordtype">long</span>) c;
+00335   <span class="keywordflow">if</span> ( *value &amp; 0x80 ) {
+00336     *value &amp;= 0x7f;
+00337     <span class="keywordflow">do</span> {
+00338       <span class="keywordflow">if</span> ( !file_.read( &amp;c, 1 ) ) <span class="keywordflow">return</span> <span class="keyword">false</span>;
+00339       *value = ( *value &lt;&lt; 7 ) + ( c &amp; 0x7f );
+00340     } <span class="keywordflow">while</span> ( c &amp; 0x80 );
+00341   }
+00342 
+00343   <span class="keywordflow">return</span> <span class="keyword">true</span>;
+00344 } 
+</pre></div><HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/MidiFileIn_8h-source.html b/doxygen/html/MidiFileIn_8h-source.html
new file mode 100755
index 0000000..235fda2
--- /dev/null
+++ b/doxygen/html/MidiFileIn_8h-source.html
@@ -0,0 +1,93 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>MidiFileIn.h</h1><div class="fragment"><pre>00001 <span class="comment">/**********************************************************************/</span>
+00016 <span class="comment">/**********************************************************************/</span>
+00017 
+00018 <span class="preprocessor">#ifndef STK_MIDIFILEIN_H</span>
+00019 <span class="preprocessor"></span><span class="preprocessor">#define STK_MIDIFILEIN_H</span>
+00020 <span class="preprocessor"></span>
+00021 <span class="preprocessor">#include "Stk.h"</span>
+00022 <span class="preprocessor">#include &lt;string&gt;</span>
+00023 <span class="preprocessor">#include &lt;vector&gt;</span>
+00024 <span class="preprocessor">#include &lt;fstream&gt;</span>
+00025 <span class="preprocessor">#include &lt;sstream&gt;</span>
+00026 
+<a name="l00027"></a><a class="code" href="classMidiFileIn.html">00027</a> <span class="keyword">class </span><a class="code" href="classMidiFileIn.html">MidiFileIn</a> : <span class="keyword">public</span> <a class="code" href="classStk.html">Stk</a>
+00028 {
+00029  <span class="keyword">public</span>:
+00031 
+00035   <a class="code" href="classMidiFileIn.html#a0">MidiFileIn</a>( std::string fileName );
+00036 
+00038   <a class="code" href="classMidiFileIn.html#a1">~MidiFileIn</a>();
+00039 
+00041   <span class="keywordtype">int</span> <a class="code" href="classMidiFileIn.html#a2">getFileFormat</a>() <span class="keyword">const</span>;
+00042 
+00044   <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> <a class="code" href="classMidiFileIn.html#a3">getNumberOfTracks</a>() <span class="keyword">const</span>;
+00045 
+00047 
+00052   <span class="keywordtype">int</span> <a class="code" href="classMidiFileIn.html#a4">getDivision</a>() <span class="keyword">const</span>;
+00053 
+00055 
+00059   <span class="keywordtype">void</span> <a class="code" href="classMidiFileIn.html#a5">rewindTrack</a>( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> track = 0 );
+00060 
+00062 
+00069   <span class="keywordtype">double</span> <a class="code" href="classMidiFileIn.html#a6">getTickSeconds</a>( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> track = 0 );
+00070 
+00072 
+00084   <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> <a class="code" href="classMidiFileIn.html#a7">getNextEvent</a>( std::vector&lt;unsigned char&gt; *event, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> track = 0 );
+00085 
+00087 
+00097   <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> <a class="code" href="classMidiFileIn.html#a8">getNextMidiEvent</a>( std::vector&lt;unsigned char&gt; *midiEvent, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> track = 0 );
+00098 
+00099  <span class="keyword">protected</span>:
+00100 
+00101   <span class="comment">// This protected class function is used for reading variable-length</span>
+00102   <span class="comment">// MIDI file values. It is assumed that this function is called with</span>
+00103   <span class="comment">// the file read pointer positioned at the start of a</span>
+00104   <span class="comment">// variable-length value.  The function returns true if the value is</span>
+00105   <span class="comment">// successfully parsed.  Otherwise, it returns false.</span>
+00106   <span class="keywordtype">bool</span> readVariableLength( <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> *value );
+00107 
+00108   std::ifstream file_;
+00109   <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> nTracks_;
+00110   <span class="keywordtype">int</span> format_;
+00111   <span class="keywordtype">int</span> division_;
+00112   <span class="keywordtype">bool</span> usingTimeCode_;
+00113   std::vector&lt;double&gt; tickSeconds_;
+00114   std::vector&lt;long&gt; trackPointers_;
+00115   std::vector&lt;long&gt; trackOffsets_;
+00116   std::vector&lt;long&gt; trackLengths_;
+00117   std::vector&lt;char&gt; trackStatus_;
+00118   std::ostringstream errorString_;
+00119 
+00120   <span class="comment">// This structure and the following variables are used to save and</span>
+00121   <span class="comment">// keep track of a format 1 tempo map (and the initial tickSeconds</span>
+00122   <span class="comment">// parameter for formats 0 and 2).</span>
+00123   <span class="keyword">struct </span>TempoChange { 
+00124     <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> count;
+00125     <span class="keywordtype">double</span> tickSeconds;
+00126   };
+00127   std::vector&lt;TempoChange&gt; tempoEvents_;
+00128   std::vector&lt;unsigned long&gt; trackCounters_;
+00129   std::vector&lt;unsigned int&gt; trackTempoIndex_;
+00130 };
+00131 
+00132 <span class="preprocessor">#endif</span>
+</pre></div><HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/RtError_8h-source.html b/doxygen/html/RtError_8h-source.html
new file mode 100755
index 0000000..ce20468
--- /dev/null
+++ b/doxygen/html/RtError_8h-source.html
@@ -0,0 +1,63 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>RtError.h</h1><div class="fragment"><pre>00001 <span class="comment">/************************************************************************/</span>
+00010 <span class="comment">/************************************************************************/</span>
+00011 
+00012 <span class="preprocessor">#ifndef RTERROR_H</span>
+00013 <span class="preprocessor"></span><span class="preprocessor">#define RTERROR_H</span>
+00014 <span class="preprocessor"></span>
+00015 <span class="preprocessor">#include &lt;iostream&gt;</span>
+00016 <span class="preprocessor">#include &lt;string&gt;</span>
+00017 
+<a name="l00018"></a><a class="code" href="classRtError.html">00018</a> <span class="keyword">class </span><a class="code" href="classRtError.html">RtError</a>
+00019 {
+00020 <span class="keyword">public</span>:
+<a name="l00022"></a><a class="code" href="classRtError.html#s11">00022</a>   <span class="keyword">enum</span> <a class="code" href="classRtError.html#s11">Type</a> {
+00023     WARNING,
+00024     DEBUG_WARNING,
+00025     UNSPECIFIED,
+00026     NO_DEVICES_FOUND,
+00027     INVALID_DEVICE,
+00028     INVALID_STREAM,
+00029     MEMORY_ERROR,
+00030     INVALID_PARAMETER,
+00031     DRIVER_ERROR,
+00032     SYSTEM_ERROR,
+00033     THREAD_ERROR
+00034   };
+00035 
+00036 <span class="keyword">protected</span>:
+00037   std::string message_;
+00038   <a class="code" href="classRtError.html#s11">Type</a> type_;
+00039 
+00040 <span class="keyword">public</span>:
+<a name="l00042"></a><a class="code" href="classRtError.html#a0">00042</a>   <a class="code" href="classRtError.html#a0">RtError</a>(<span class="keyword">const</span> std::string&amp; message, Type type = RtError::UNSPECIFIED) : message_(message), type_(type) {}
+00043 
+<a name="l00045"></a><a class="code" href="classRtError.html#a1">00045</a>   <span class="keyword">virtual</span> <a class="code" href="classRtError.html#a1">~RtError</a>(<span class="keywordtype">void</span>) {}
+00046 
+<a name="l00048"></a><a class="code" href="classRtError.html#a2">00048</a>   <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classRtError.html#a2">printMessage</a>(<span class="keywordtype">void</span>) { std::cout &lt;&lt; <span class="charliteral">'\n'</span> &lt;&lt; message_ &lt;&lt; <span class="stringliteral">"\n\n"</span>; }
+00049 
+<a name="l00051"></a><a class="code" href="classRtError.html#a3">00051</a>   <span class="keyword">virtual</span> <span class="keyword">const</span> <a class="code" href="classRtError.html#s11">Type</a>&amp; <a class="code" href="classRtError.html#a3">getType</a>(<span class="keywordtype">void</span>) { <span class="keywordflow">return</span> type_; }
+00052 
+<a name="l00054"></a><a class="code" href="classRtError.html#a4">00054</a>   <span class="keyword">virtual</span> <span class="keyword">const</span> std::string&amp; <a class="code" href="classRtError.html#a4">getMessage</a>(<span class="keywordtype">void</span>) { <span class="keywordflow">return</span> message_; }
+00055 };
+00056 
+00057 <span class="preprocessor">#endif</span>
+</pre></div><HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/RtMidi_8cpp-source.html b/doxygen/html/RtMidi_8cpp-source.html
new file mode 100755
index 0000000..1b65b96
--- /dev/null
+++ b/doxygen/html/RtMidi_8cpp-source.html
@@ -0,0 +1,482 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>RtMidi.cpp</h1><div class="fragment"><pre>00001 <span class="comment">/**********************************************************************/</span>
+00010 <span class="comment">/**********************************************************************/</span>
+00011 
+00012 <span class="preprocessor">#include "RtMidi.h"</span>
+00013 <span class="preprocessor">#include &lt;sstream&gt;</span>
+00014 
+00015 RtMidi :: RtMidi()
+00016   : apiData_( 0 ), connected_( false )
+00017 {
+00018 }
+00019 
+00020 <span class="keywordtype">void</span> RtMidi :: error( RtError::Type type )
+00021 {
+00022   <span class="keywordflow">if</span> (type == RtError::WARNING) {
+00023     std::cerr &lt;&lt; <span class="charliteral">'\n'</span> &lt;&lt; errorString_ &lt;&lt; <span class="stringliteral">"\n\n"</span>;
+00024   }
+00025   <span class="keywordflow">else</span> <span class="keywordflow">if</span> (type == RtError::DEBUG_WARNING) {
+00026 <span class="preprocessor">#if defined(__RTMIDI_DEBUG__)</span>
+00027 <span class="preprocessor"></span>    std::cerr &lt;&lt; <span class="charliteral">'\n'</span> &lt;&lt; errorString_ &lt;&lt; <span class="stringliteral">"\n\n"</span>;
+00028 <span class="preprocessor">#endif</span>
+00029 <span class="preprocessor"></span>  }
+00030   <span class="keywordflow">else</span> {
+00031     std::cerr &lt;&lt; <span class="charliteral">'\n'</span> &lt;&lt; errorString_ &lt;&lt; <span class="stringliteral">"\n\n"</span>;
+00032     <span class="keywordflow">throw</span> <a class="code" href="classRtError.html#a0">RtError</a>( errorString_, type );
+00033   }
+00034 }
+00035 
+<a name="l00036"></a><a class="code" href="classRtMidiIn.html#a0">00036</a> <a class="code" href="classRtMidiIn.html#a0">RtMidiIn :: RtMidiIn</a>() : <a class="code" href="classRtMidi.html">RtMidi</a>()
+00037 {
+00038 }
+00039 
+<a name="l00040"></a><a class="code" href="classRtMidiIn.html#a1">00040</a> <a class="code" href="classRtMidiIn.html#a0">RtMidiIn :: RtMidiIn</a>( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> portNumber, RtMidiCallback callback, <span class="keywordtype">void</span> *userData ) : <a class="code" href="classRtMidi.html">RtMidi</a>()
+00041 
+00042 {
+00043   <span class="comment">// Attempt to make the connection.</span>
+00044   this-&gt;<a class="code" href="classRtMidiIn.html#a3">openPort</a>( portNumber, callback, userData );
+00045 }
+00046 
+<a name="l00047"></a><a class="code" href="classRtMidiIn.html#a2">00047</a> <a class="code" href="classRtMidiIn.html#a2">RtMidiIn :: ~RtMidiIn</a>()
+00048 {
+00049   <a class="code" href="classRtMidiIn.html#a4">closePort</a>();
+00050 }
+00051 
+<a name="l00052"></a><a class="code" href="classRtMidiOut.html#a0">00052</a> <a class="code" href="classRtMidiOut.html#a0">RtMidiOut :: RtMidiOut</a>() : <a class="code" href="classRtMidi.html">RtMidi</a>()
+00053 {
+00054 }
+00055 
+<a name="l00056"></a><a class="code" href="classRtMidiOut.html#a1">00056</a> <a class="code" href="classRtMidiOut.html#a0">RtMidiOut :: RtMidiOut</a>( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> portNumber ) : <a class="code" href="classRtMidi.html">RtMidi</a>()
+00057 {
+00058   <span class="comment">// Attempt to make the connection.</span>
+00059   this-&gt;<a class="code" href="classRtMidiOut.html#a3">openPort</a>( portNumber );
+00060 }
+00061 
+<a name="l00062"></a><a class="code" href="classRtMidiOut.html#a2">00062</a> <a class="code" href="classRtMidiOut.html#a2">RtMidiOut :: ~RtMidiOut</a>()
+00063 {
+00064   <a class="code" href="classRtMidiOut.html#a4">closePort</a>();
+00065 }
+00066 
+00067 
+00068 <span class="preprocessor">#if defined(__MACOSX_CORE__)</span>
+00069 <span class="preprocessor"></span>
+00070 <span class="comment">// The CoreMIDI API is based on the use of a callback function for</span>
+00071 <span class="comment">// MIDI input.  We convert the system specific time stamps to delta</span>
+00072 <span class="comment">// time values.</span>
+00073 
+00074 <span class="comment">// OS-X CoreMIDI header files.</span>
+00075 <span class="preprocessor">#include &lt;CoreMIDI/CoreMIDI.h&gt;</span>
+00076 <span class="preprocessor">#include &lt;CoreAudio/HostTime.h&gt;</span>
+00077 
+00078 <span class="comment">// A structure to hold variables related to the CoreMIDI API</span>
+00079 <span class="comment">// implementation.</span>
+00080 <span class="keyword">struct </span>CoreMidiData {
+00081   MIDIClientRef client;
+00082   MIDIPortRef port;
+00083   MIDIEndpointRef destinationId;
+00084 };
+00085 
+00086 <span class="keywordtype">void</span> midiInputCallback( <span class="keyword">const</span> MIDIPacketList *list, <span class="keywordtype">void</span> *procRef, <span class="keywordtype">void</span> *srcRef )
+00087 {
+00088   RtMidiIn::RtMidiInData *data = static_cast&lt;RtMidiIn::RtMidiInData *&gt; (procRef);
+00089 
+00090   <span class="keywordtype">bool</span> continueSysex = <span class="keyword">false</span>;
+00091   <span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> status;
+00092   <span class="keywordtype">unsigned</span> <span class="keywordtype">short</span> nBytes, iByte, size;
+00093   <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> <span class="keywordtype">long</span> time;
+00094   RtMidiIn::MidiMessage message;
+00095   <span class="keyword">const</span> MIDIPacket *packet = &amp;list-&gt;packet[0];
+00096   <span class="keywordflow">for</span> ( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> i=0; i&lt;list-&gt;numPackets; ++i ) {
+00097 
+00098     <span class="comment">// My interpretation of the CoreMIDI documentation: all message</span>
+00099     <span class="comment">// types, except sysex, are complete within a packet and there may</span>
+00100     <span class="comment">// be several of them in a single packet.  Sysex messages can be</span>
+00101     <span class="comment">// broken across multiple packets but are bundled alone within a</span>
+00102     <span class="comment">// packet.  I'm assuming that sysex messages, if segmented, must</span>
+00103     <span class="comment">// be complete within the same MIDIPacketList.</span>
+00104 
+00105     nBytes = packet-&gt;length;
+00106     <span class="keywordflow">if</span> ( nBytes == 0 ) <span class="keywordflow">continue</span>;
+00107 
+00108     <span class="comment">// Calculate time stamp.</span>
+00109     message.timeStamp = 0.0;
+00110     time = packet-&gt;timeStamp;
+00111     time -= data-&gt;lastTime;
+00112     data-&gt;lastTime = packet-&gt;timeStamp;
+00113     time = AudioConvertHostTimeToNanos( time );
+00114     message.timeStamp = time * 0.000000001;
+00115 
+00116     iByte = 0;
+00117     <span class="keywordflow">if</span> ( continueSysex ) {
+00118       <span class="comment">// We have a continuing, segmented sysex message.</span>
+00119       <span class="keywordflow">if</span> ( !(data-&gt;ignoreFlags &amp; 0x01) ) {
+00120         <span class="comment">// If we're not ignoring sysex messages, copy the entire packet.</span>
+00121         message.bytes.assign( packet-&gt;data, &amp;packet-&gt;data[nBytes] );
+00122       }
+00123       <span class="keywordflow">if</span> ( packet-&gt;data[nBytes] == 0xF7 ) continueSysex = <span class="keyword">false</span>;
+00124       <span class="keywordflow">if</span> ( !continueSysex ) {
+00125         <span class="comment">// If not a continuing sysex message, invoke the user callback function or queue the message.</span>
+00126         <span class="keywordflow">if</span> ( data-&gt;usingCallback &amp;&amp; message.bytes.size() &gt; 0 ) {
+00127           <a class="code" href="classRtMidiIn.html#s0">RtMidiIn::RtMidiCallback</a> callback = (RtMidiIn::RtMidiCallback) data-&gt;userCallback;
+00128           callback( message.timeStamp, &amp;message.bytes, data-&gt;userData );
+00129         }
+00130         <span class="keywordflow">else</span> {
+00131           <span class="comment">// As long as we haven't reached our queue size limit, push the message.</span>
+00132           <span class="keywordflow">if</span> ( data-&gt;queueLimit &gt; data-&gt;queue.size() )
+00133             data-&gt;queue.push( message );
+00134           <span class="keywordflow">else</span>
+00135             std::cerr &lt;&lt; <span class="stringliteral">"\nRtMidiIn: message queue limit reached!!\n\n"</span>;
+00136         }
+00137         message.bytes.clear();
+00138       }
+00139     }
+00140     <span class="keywordflow">else</span> {
+00141       <span class="keywordflow">while</span> ( iByte &lt; nBytes ) {
+00142         size = 0;
+00143         <span class="comment">// We are expecting that the next byte in the packet is a status byte.</span>
+00144         status = packet-&gt;data[iByte];
+00145         <span class="keywordflow">if</span> ( !(status &amp; 0x80) ) <span class="keywordflow">break</span>;
+00146         <span class="comment">// Determine the number of bytes in the MIDI message.</span>
+00147         <span class="keywordflow">if</span> ( status &lt; 0xC0 ) size = 3;
+00148         <span class="keywordflow">else</span> <span class="keywordflow">if</span> ( status &lt; 0xE0 ) size = 2;
+00149         <span class="keywordflow">else</span> <span class="keywordflow">if</span> ( status &lt; 0xF0 ) size = 3;
+00150         <span class="keywordflow">else</span> <span class="keywordflow">if</span> ( status == 0xF0 ) {
+00151           <span class="comment">// A MIDI sysex</span>
+00152           <span class="keywordflow">if</span> ( data-&gt;ignoreFlags &amp; 0x01 ) {
+00153             size = 0;
+00154             iByte = nBytes;
+00155           }
+00156           <span class="keywordflow">else</span> size = nBytes - iByte;
+00157           <span class="keywordflow">if</span> ( packet-&gt;data[nBytes] == 0xF7 ) continueSysex = <span class="keyword">false</span>;
+00158         }
+00159         <span class="keywordflow">else</span> <span class="keywordflow">if</span> ( status &lt; 0xF3 ) {
+00160           <span class="keywordflow">if</span> ( status == 0xF1 &amp;&amp; (data-&gt;ignoreFlags &amp; 0x02) ) {
+00161             <span class="comment">// A MIDI time code message and we're ignoring it.</span>
+00162             size = 0;
+00163             iByte += 3;
+00164           }
+00165           <span class="keywordflow">else</span> size = 3;
+00166         }
+00167         <span class="keywordflow">else</span> <span class="keywordflow">if</span> ( status == 0xF3 ) size = 2;
+00168         <span class="keywordflow">else</span> <span class="keywordflow">if</span> ( status == 0xFE &amp;&amp; (data-&gt;ignoreFlags &amp; 0x04) ) {
+00169           <span class="comment">// A MIDI active sensing message and we're ignoring it.</span>
+00170           size = 0;
+00171           iByte += 1;
+00172         }
+00173         <span class="keywordflow">else</span> size = 1;
+00174 
+00175         <span class="comment">// Copy the MIDI data to our vector.</span>
+00176         <span class="keywordflow">if</span> ( size ) {
+00177           message.bytes.assign( &amp;packet-&gt;data[iByte], &amp;packet-&gt;data[iByte+size] );
+00178           <span class="keywordflow">if</span> ( !continueSysex ) {
+00179             <span class="comment">// If not a continuing sysex message, invoke the user callback function or queue the message.</span>
+00180             <span class="keywordflow">if</span> ( data-&gt;usingCallback ) {
+00181               <a class="code" href="classRtMidiIn.html#s0">RtMidiIn::RtMidiCallback</a> callback = (RtMidiIn::RtMidiCallback) data-&gt;userCallback;
+00182               callback( message.timeStamp, &amp;message.bytes, data-&gt;userData );
+00183             }
+00184             <span class="keywordflow">else</span> {
+00185               <span class="comment">// As long as we haven't reached our queue size limit, push the message.</span>
+00186               <span class="keywordflow">if</span> ( data-&gt;queueLimit &gt; data-&gt;queue.size() )
+00187                 data-&gt;queue.push( message );
+00188               <span class="keywordflow">else</span>
+00189                 std::cerr &lt;&lt; <span class="stringliteral">"\nRtMidiIn: message queue limit reached!!\n\n"</span>;
+00190             }
+00191             message.bytes.clear();
+00192           }
+00193           iByte += size;
+00194         }
+00195       }
+00196     }
+00197     packet = MIDIPacketNext(packet);
+00198   }
+00199 }
+00200 
+00201 <span class="keywordtype">void</span> <a class="code" href="classRtMidiIn.html#a3">RtMidiIn :: openPort</a>( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> portNumber, RtMidiCallback callback, <span class="keywordtype">void</span> *userData )
+00202 {
+00203   <span class="keywordflow">if</span> ( connected_ ) {
+00204     errorString_ = <span class="stringliteral">"RtMidiIn::openPort: a valid connection already exists!"</span>;
+00205     error( RtError::WARNING );
+00206     <span class="keywordflow">return</span>;
+00207   }
+00208 
+00209   <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> nSrc = MIDIGetNumberOfSources();
+00210   <span class="keywordflow">if</span> (nSrc &lt; 1) {
+00211     errorString_ = <span class="stringliteral">"RtMidiIn::openPort: no MIDI input sources found!"</span>;
+00212     error( RtError::NO_DEVICES_FOUND );
+00213   }
+00214 
+00215   std::ostringstream ost;
+00216   <span class="keywordflow">if</span> ( portNumber &gt;= nSrc ) {
+00217     ost &lt;&lt; <span class="stringliteral">"RtMidiIn::openPort: the 'portNumber' argument ("</span> &lt;&lt; portNumber &lt;&lt; <span class="stringliteral">") is invalid."</span>;
+00218     errorString_ = ost.str();
+00219     error( RtError::INVALID_PARAMETER );
+00220   }
+00221 
+00222   MIDIClientRef client;
+00223   OSStatus result = MIDIClientCreate( CFSTR(<span class="stringliteral">"RtMidi Input Client"</span>), NULL, NULL, &amp;client );
+00224   <span class="keywordflow">if</span> ( result != noErr ) {
+00225     errorString_ = <span class="stringliteral">"RtMidiIn::openPort: error creating OS-X MIDI client object."</span>;
+00226     error( RtError::DRIVER_ERROR );
+00227   }
+00228 
+00229   MIDIPortRef port;
+00230   result = MIDIInputPortCreate( client, CFSTR(<span class="stringliteral">"RtMidi Virtual MIDI Input Port"</span>), midiInputCallback, (<span class="keywordtype">void</span> *)&amp;inputData_, &amp;port );
+00231   <span class="keywordflow">if</span> ( result != noErr ) {
+00232     MIDIClientDispose( client );
+00233     errorString_ = <span class="stringliteral">"RtMidiIn::openPort: error creating OS-X MIDI input port."</span>;
+00234     error( RtError::DRIVER_ERROR );
+00235   }
+00236 
+00237   <span class="comment">// Get the desired input source identifier.</span>
+00238   MIDIEndpointRef src = MIDIGetSource( portNumber );
+00239   <span class="keywordflow">if</span> ( src == NULL ) {
+00240     MIDIPortDispose( port );
+00241     MIDIClientDispose( client );
+00242     errorString_ = <span class="stringliteral">"RtMidiIn::openPort: error getting MIDI input source reference."</span>;
+00243     error( RtError::DRIVER_ERROR );
+00244   }
+00245 
+00246   <span class="comment">// Make the connection.</span>
+00247   result = MIDIPortConnectSource(port, src, NULL );
+00248   <span class="keywordflow">if</span> ( result != noErr ) {
+00249     MIDIPortDispose( port );
+00250     MIDIClientDispose( client );
+00251     errorString_ = <span class="stringliteral">"RtMidiIn::openPort: error connecting OS-X MIDI input port."</span>;
+00252     error( RtError::DRIVER_ERROR );
+00253   }
+00254 
+00255   <span class="comment">// Save our api-specific connection information.</span>
+00256   CoreMidiData *data = (CoreMidiData *) <span class="keyword">new</span> CoreMidiData;
+00257   data-&gt;client = client;
+00258   data-&gt;port = port;
+00259   apiData_ = (<span class="keywordtype">void</span> *) data;
+00260 
+00261   <span class="keywordflow">if</span> ( callback ) {
+00262     inputData_.userCallback = (<span class="keywordtype">void</span> *) callback;
+00263     inputData_.userData = userData;
+00264     inputData_.usingCallback = <span class="keyword">true</span>;
+00265   }
+00266 
+00267   inputData_.lastTime = AudioGetCurrentHostTime();
+00268 
+00269   connected_ = <span class="keyword">true</span>;
+00270 }
+00271 
+00272 <span class="keywordtype">void</span> <a class="code" href="classRtMidiIn.html#a4">RtMidiIn :: closePort</a>( <span class="keywordtype">void</span> )
+00273 {
+00274   <span class="keywordflow">if</span> ( connected_ ) {
+00275     CoreMidiData *data = static_cast&lt;CoreMidiData *&gt; (apiData_);
+00276     MIDIClientDispose( data-&gt;client );
+00277     MIDIPortDispose( data-&gt;port );
+00278     <span class="keyword">delete</span> data;
+00279     apiData_ = 0;
+00280   }
+00281 
+00282   connected_ = <span class="keyword">false</span>;
+00283 }
+00284 
+00285 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> <a class="code" href="classRtMidiIn.html#a5">RtMidiIn :: getPortCount</a>()
+00286 {
+00287   <span class="keywordflow">return</span> MIDIGetNumberOfSources();
+00288 }
+00289 
+00290 std::string <a class="code" href="classRtMidiIn.html#a6">RtMidiIn :: getPortName</a>( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> portNumber )
+00291 {
+00292   CFStringRef nameRef;
+00293   MIDIEndpointRef portRef;
+00294   std::ostringstream ost;
+00295   <span class="keywordtype">char</span> name[128];
+00296 
+00297   <span class="keywordflow">if</span> ( portNumber &gt;= MIDIGetNumberOfSources() ) {
+00298     ost &lt;&lt; <span class="stringliteral">"RtMidiIn::getPortName: the 'portNumber' argument ("</span> &lt;&lt; portNumber &lt;&lt; <span class="stringliteral">") is invalid."</span>;
+00299     errorString_ = ost.str();
+00300     error( RtError::INVALID_PARAMETER );
+00301   }
+00302   portRef = MIDIGetSource( portNumber );
+00303 
+00304   MIDIObjectGetStringProperty( portRef, kMIDIPropertyName, &amp;nameRef );
+00305   CFStringGetCString( nameRef, name, <span class="keyword">sizeof</span>(name), 0);
+00306   CFRelease( nameRef );
+00307   std::string stringName = name;
+00308   <span class="keywordflow">return</span> stringName;
+00309 }
+00310 
+00311 <span class="keywordtype">void</span> <a class="code" href="classRtMidiIn.html#a7">RtMidiIn :: setQueueSizeLimit</a>( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> queueSize )
+00312 {
+00313   inputData_.queueLimit = queueSize;
+00314 }
+00315 
+00316 <span class="keywordtype">void</span> <a class="code" href="classRtMidiIn.html#a8">RtMidiIn :: ignoreTypes</a>( <span class="keywordtype">bool</span> midiSysex, <span class="keywordtype">bool</span> midiTime, <span class="keywordtype">bool</span> midiSense )
+00317 {
+00318   inputData_.ignoreFlags = 0;
+00319   <span class="keywordflow">if</span> ( midiSysex ) inputData_.ignoreFlags = 0x01;
+00320   <span class="keywordflow">if</span> ( midiTime ) inputData_.ignoreFlags |= 0x02;
+00321   <span class="keywordflow">if</span> ( midiSense ) inputData_.ignoreFlags |= 0x04;
+00322 }
+00323 
+00324 <span class="keywordtype">double</span> <a class="code" href="classRtMidiIn.html#a9">RtMidiIn :: getMessage</a>( std::vector&lt;unsigned char&gt; *message )
+00325 {
+00326   message-&gt;clear();
+00327   <span class="keywordflow">if</span> ( !connected_ ) {
+00328     errorString_ = <span class="stringliteral">"RtMidiIn::getNextMessage: a port is not open!"</span>;
+00329     error( RtError::WARNING );
+00330     <span class="keywordflow">return</span> 0.0;
+00331   }
+00332 
+00333   <span class="keywordflow">if</span> ( inputData_.usingCallback ) {
+00334     errorString_ = <span class="stringliteral">"RtMidiIn::getNextMessage: a user callback is currently set for this port."</span>;
+00335     error( RtError::WARNING );
+00336     <span class="keywordflow">return</span> 0.0;
+00337   }
+00338 
+00339   <span class="keywordflow">if</span> ( inputData_.queue.size() == 0 ) <span class="keywordflow">return</span> 0.0;
+00340 
+00341   <span class="comment">// Copy queued message to the vector pointer argument and then "pop" it.</span>
+00342   std::vector&lt;unsigned char&gt; *bytes = &amp;(inputData_.queue.front().bytes);
+00343   message-&gt;assign( bytes-&gt;begin(), bytes-&gt;end() );
+00344   <span class="keywordtype">double</span> deltaTime = inputData_.queue.front().timeStamp;
+00345   inputData_.queue.pop();
+00346 
+00347   <span class="keywordflow">return</span> deltaTime;
+00348 }
+00349 
+00350 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> <a class="code" href="classRtMidiOut.html#a5">RtMidiOut :: getPortCount</a>()
+00351 {
+00352   <span class="keywordflow">return</span> MIDIGetNumberOfDestinations();
+00353 }
+00354 
+00355 std::string <a class="code" href="classRtMidiOut.html#a6">RtMidiOut :: getPortName</a>( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> portNumber )
+00356 {
+00357   CFStringRef nameRef;
+00358   MIDIEndpointRef portRef;
+00359   std::ostringstream ost;
+00360   <span class="keywordtype">char</span> name[128];
+00361 
+00362   <span class="keywordflow">if</span> ( portNumber &gt;= MIDIGetNumberOfDestinations() ) {
+00363     ost &lt;&lt; <span class="stringliteral">"RtMidiOut::getPortName: the 'portNumber' argument ("</span> &lt;&lt; portNumber &lt;&lt; <span class="stringliteral">") is invalid."</span>;
+00364     errorString_ = ost.str();
+00365     error( RtError::INVALID_PARAMETER );
+00366   }
+00367   portRef = MIDIGetDestination( portNumber );
+00368 
+00369   MIDIObjectGetStringProperty( portRef, kMIDIPropertyName, &amp;nameRef );
+00370   CFStringGetCString( nameRef, name, <span class="keyword">sizeof</span>(name), 0);
+00371   CFRelease( nameRef );
+00372   std::string stringName = name;
+00373   <span class="keywordflow">return</span> stringName;
+00374 }
+00375 
+00376 <span class="keywordtype">void</span> <a class="code" href="classRtMidiOut.html#a3">RtMidiOut :: openPort</a>( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> portNumber )
+00377 {
+00378   <span class="keywordflow">if</span> ( connected_ ) {
+00379     errorString_ = <span class="stringliteral">"RtMidiOut::openPort: a valid connection already exists!"</span>;
+00380     error( RtError::WARNING );
+00381     <span class="keywordflow">return</span>;
+00382   }
+00383 
+00384   <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> nDest = MIDIGetNumberOfDestinations();
+00385   <span class="keywordflow">if</span> (nDest &lt; 1) {
+00386     errorString_ = <span class="stringliteral">"RtMidiOut::openPort: no MIDI output destinations found!"</span>;
+00387     error( RtError::NO_DEVICES_FOUND );
+00388   }
+00389 
+00390   std::ostringstream ost;
+00391   <span class="keywordflow">if</span> ( portNumber &gt;= nDest ) {
+00392     ost &lt;&lt; <span class="stringliteral">"RtMidiOut::openPort: the 'portNumber' argument ("</span> &lt;&lt; portNumber &lt;&lt; <span class="stringliteral">") is invalid."</span>;
+00393     errorString_ = ost.str();
+00394     error( RtError::INVALID_PARAMETER );
+00395   }
+00396 
+00397   MIDIClientRef client;
+00398   OSStatus result = MIDIClientCreate( CFSTR(<span class="stringliteral">"RtMidi Output Client"</span>), NULL, NULL, &amp;client );
+00399   <span class="keywordflow">if</span> ( result != noErr ) {
+00400     errorString_ = <span class="stringliteral">"RtMidiOut::openPort: error creating OS-X MIDI client object."</span>;
+00401     error( RtError::DRIVER_ERROR );
+00402   }
+00403 
+00404   MIDIPortRef port;
+00405   result = MIDIOutputPortCreate( client, CFSTR(<span class="stringliteral">"RtMidi Virtual MIDI Output Port"</span>), &amp;port );
+00406   <span class="keywordflow">if</span> ( result != noErr ) {
+00407     MIDIClientDispose( client );
+00408     errorString_ = <span class="stringliteral">"RtMidiOut::openPort: error creating OS-X MIDI output port."</span>;
+00409     error( RtError::DRIVER_ERROR );
+00410   }
+00411 
+00412   <span class="comment">// Get the desired output port identifier.</span>
+00413   MIDIEndpointRef destinationId = MIDIGetDestination( portNumber );
+00414   <span class="keywordflow">if</span> ( destinationId == NULL ) {
+00415     MIDIPortDispose( port );
+00416     MIDIClientDispose( client );
+00417     errorString_ = <span class="stringliteral">"RtMidiOut::openPort: error getting MIDI output destination reference."</span>;
+00418     error( RtError::DRIVER_ERROR );
+00419   }
+00420 
+00421   <span class="comment">// Save our api-specific connection information.</span>
+00422   CoreMidiData *data = (CoreMidiData *) <span class="keyword">new</span> CoreMidiData;
+00423   data-&gt;client = client;
+00424   data-&gt;port = port;
+00425   data-&gt;destinationId = destinationId;
+00426   apiData_ = (<span class="keywordtype">void</span> *) data;
+00427 
+00428   connected_ = <span class="keyword">true</span>;
+00429 }
+00430 
+00431 <span class="keywordtype">void</span> <a class="code" href="classRtMidiOut.html#a4">RtMidiOut :: closePort</a>( <span class="keywordtype">void</span> )
+00432 {
+00433   <span class="keywordflow">if</span> ( connected_ ) {
+00434     CoreMidiData *data = static_cast&lt;CoreMidiData *&gt; (apiData_);
+00435     MIDIClientDispose( data-&gt;client );
+00436     MIDIPortDispose( data-&gt;port );
+00437     <span class="keyword">delete</span> data;
+00438     apiData_ = 0;
+00439   }
+00440 
+00441   connected_ = <span class="keyword">false</span>;
+00442 }
+00443 
+00444 <span class="keywordtype">void</span> <a class="code" href="classRtMidiOut.html#a7">RtMidiOut :: sendMessage</a>( std::vector&lt;unsigned char&gt; *message )
+00445 {
+00446   <span class="keywordflow">if</span> ( !connected_ ) {
+00447     errorString_ = <span class="stringliteral">"RtMidiOut::sendMessage: a port is not open!"</span>;
+00448     error( RtError::WARNING );
+00449     <span class="keywordflow">return</span>;
+00450   }
+00451 
+00452   <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> nBytes = message-&gt;size();
+00453   <span class="comment">// Pad the buffer for extra (unknown) structure data.</span>
+00454   Byte buffer[nBytes+32];
+00455   MIDIPacketList *pktlist = (MIDIPacketList *) buffer;
+00456   MIDIPacket *curPacket = MIDIPacketListInit( pktlist );
+00457 
+00458   MIDITimeStamp timeStamp = 0;
+00459   curPacket = MIDIPacketListAdd( pktlist, <span class="keyword">sizeof</span>(buffer), curPacket, timeStamp, nBytes, &amp;message-&gt;at(0) );
+00460 
+00461   CoreMidiData *data = static_cast&lt;CoreMidiData *&gt; (apiData_);
+00462   OSStatus result = MIDISend( data-&gt;port, data-&gt;destinationId, pktlist );
+00463   <span class="keywordflow">if</span> ( result != noErr ) {
+00464     errorString_ = <span class="stringliteral">"RtMidiOut::sendMessage: error sending MIDI message."</span>;
+00465     error( RtError::WARNING );
+00466   }
+00467 }
+00468 
+00469 <span class="preprocessor">#endif</span>
+00470 <span class="preprocessor"></span>
+</pre></div><HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/RtMidi_8h-source.html b/doxygen/html/RtMidi_8h-source.html
new file mode 100755
index 0000000..5a60461
--- /dev/null
+++ b/doxygen/html/RtMidi_8h-source.html
@@ -0,0 +1,145 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>RtMidi.h</h1><div class="fragment"><pre>00001 <span class="comment">/**********************************************************************/</span>
+00010 <span class="comment">/**********************************************************************/</span>
+00011 
+00012 <span class="preprocessor">#ifndef RTMIDI_H</span>
+00013 <span class="preprocessor"></span><span class="preprocessor">#define RTMIDI_H</span>
+00014 <span class="preprocessor"></span>
+00015 <span class="preprocessor">#include "RtError.h"</span>
+00016 <span class="preprocessor">#include &lt;string&gt;</span>
+00017 
+<a name="l00018"></a><a class="code" href="classRtMidi.html">00018</a> <span class="keyword">class </span><a class="code" href="classRtMidi.html">RtMidi</a>
+00019 {
+00020  <span class="keyword">protected</span>:
+00021 
+00022   <a class="code" href="classRtMidi.html">RtMidi</a>();
+00023 
+00024   <span class="comment">// A basic error reporting function for internal use in the RtMidi</span>
+00025   <span class="comment">// subclasses.  The behavior of this function can be modified to</span>
+00026   <span class="comment">// suit specific needs.</span>
+00027   <span class="keywordtype">void</span> error( RtError::Type type );
+00028 
+00029   <span class="keywordtype">void</span> *apiData_;
+00030   <span class="keywordtype">bool</span> connected_;
+00031   std::string errorString_;
+00032 };
+00033 
+00034 <span class="comment">/**********************************************************************/</span>
+00048 <span class="comment">/**********************************************************************/</span>
+00049 
+00050 <span class="preprocessor">#include &lt;vector&gt;</span>
+00051 <span class="preprocessor">#include &lt;queue&gt;</span>
+00052 
+<a name="l00053"></a><a class="code" href="classRtMidiIn.html">00053</a> <span class="keyword">class </span><a class="code" href="classRtMidiIn.html">RtMidiIn</a> : <span class="keyword">public</span> <a class="code" href="classRtMidi.html">RtMidi</a>
+00054 {
+00055  <span class="keyword">public</span>:
+00056 
+<a name="l00058"></a><a class="code" href="classRtMidiIn.html#s0">00058</a>   <span class="keyword">typedef</span> void (*RtMidiCallback)( <span class="keywordtype">double</span> timeStamp, std::vector&lt;unsigned char&gt; *message, <span class="keywordtype">void</span> *userData);
+00059 
+00061   <a class="code" href="classRtMidiIn.html#a0">RtMidiIn</a>();
+00062 
+00064 
+00070   <a class="code" href="classRtMidiIn.html#a0">RtMidiIn</a>( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> portNumber, RtMidiCallback callback = 0, <span class="keywordtype">void</span> *userData = 0  );
+00071 
+00073   <a class="code" href="classRtMidiIn.html#a2">~RtMidiIn</a>();
+00074 
+00076 
+00084   <span class="keywordtype">void</span> <a class="code" href="classRtMidiIn.html#a3">openPort</a>( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> portNumber = 0, RtMidiCallback callback = 0, <span class="keywordtype">void</span> *userData = 0 );
+00085 
+00087   <span class="keywordtype">void</span> <a class="code" href="classRtMidiIn.html#a4">closePort</a>( <span class="keywordtype">void</span> );
+00088 
+00090   <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> <a class="code" href="classRtMidiIn.html#a5">getPortCount</a>();
+00091 
+00093   std::string <a class="code" href="classRtMidiIn.html#a6">getPortName</a>( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> portNumber = 0 );
+00094 
+00096 
+00100   <span class="keywordtype">void</span> <a class="code" href="classRtMidiIn.html#a7">setQueueSizeLimit</a>( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> queueSize );
+00101 
+00103 
+00110   <span class="keywordtype">void</span> <a class="code" href="classRtMidiIn.html#a8">ignoreTypes</a>( <span class="keywordtype">bool</span> midiSysex = <span class="keyword">true</span>, <span class="keywordtype">bool</span> midiTime = <span class="keyword">true</span>, <span class="keywordtype">bool</span> midiSense = <span class="keyword">true</span> );
+00111 
+00113 
+00120   <span class="keywordtype">double</span> <a class="code" href="classRtMidiIn.html#a9">getMessage</a>( std::vector&lt;unsigned char&gt; *message );
+00121 
+00122   <span class="comment">// A MIDI structure used internally by the class to store incoming</span>
+00123   <span class="comment">// messages.  Each message represents one and only one MIDI message.</span>
+00124   <span class="keyword">struct </span>MidiMessage { 
+00125     std::vector&lt;unsigned char&gt; bytes; 
+00126     <span class="keywordtype">double</span> timeStamp;
+00127 
+00128     <span class="comment">// Default constructor.</span>
+00129     MidiMessage()
+00130       :bytes(3), timeStamp(0.0) {}
+00131   };
+00132 
+00133   <span class="comment">// The RtMidiInData structure is used to pass private class data to</span>
+00134   <span class="comment">// the MIDI input handling function or thread.</span>
+00135   <span class="keyword">struct </span>RtMidiInData {
+00136     <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> <span class="keywordtype">long</span> lastTime;
+00137     std::queue&lt;MidiMessage&gt; queue;
+00138     <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> queueLimit;
+00139     <span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> ignoreFlags;
+00140     <span class="keywordtype">bool</span> usingCallback;
+00141     <span class="keywordtype">void</span> *userCallback;
+00142     <span class="keywordtype">void</span> *userData;
+00143 
+00144     <span class="comment">// Default constructor.</span>
+00145     RtMidiInData()
+00146       : lastTime(0), queueLimit(1024), ignoreFlags(7),
+00147          usingCallback(false), userCallback(0), userData(0) {}
+00148   };
+00149 
+00150  <span class="keyword">private</span>:
+00151 
+00152   RtMidiInData inputData_;
+00153 
+00154 };
+00155 
+00156 <span class="comment">/**********************************************************************/</span>
+00168 <span class="comment">/**********************************************************************/</span>
+00169 
+<a name="l00170"></a><a class="code" href="classRtMidiOut.html">00170</a> <span class="keyword">class </span><a class="code" href="classRtMidiOut.html">RtMidiOut</a> : <span class="keyword">public</span> <a class="code" href="classRtMidi.html">RtMidi</a>
+00171 {
+00172  <span class="keyword">public</span>:
+00173 
+00175   <a class="code" href="classRtMidiOut.html#a0">RtMidiOut</a>();
+00176 
+00178 
+00182   <a class="code" href="classRtMidiOut.html#a0">RtMidiOut</a>( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> portNumber );
+00183 
+00185   <a class="code" href="classRtMidiOut.html#a2">~RtMidiOut</a>();
+00186 
+00188 
+00194   <span class="keywordtype">void</span> <a class="code" href="classRtMidiOut.html#a3">openPort</a>( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> portNumber = 0 );
+00195 
+00197   <span class="keywordtype">void</span> <a class="code" href="classRtMidiOut.html#a4">closePort</a>();
+00198 
+00200   <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> <a class="code" href="classRtMidiOut.html#a5">getPortCount</a>();
+00201 
+00203   std::string <a class="code" href="classRtMidiOut.html#a6">getPortName</a>( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> portNumber );
+00204 
+00206 
+00210   <span class="keywordtype">void</span> <a class="code" href="classRtMidiOut.html#a7">sendMessage</a>( std::vector&lt;unsigned char&gt; *message );
+00211 
+00212 };
+00213 
+00214 <span class="preprocessor">#endif</span>
+</pre></div><HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/Stk_8cpp-source.html b/doxygen/html/Stk_8cpp-source.html
new file mode 100755
index 0000000..09312fc
--- /dev/null
+++ b/doxygen/html/Stk_8cpp-source.html
@@ -0,0 +1,128 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>Stk.cpp</h1><div class="fragment"><pre>00001 <span class="comment">/***************************************************/</span>
+00013 <span class="comment">/***************************************************/</span>
+00014 
+00015 <span class="preprocessor">#include "Stk.h"</span>
+00016 
+00017 StkFloat Stk :: srate_ = (StkFloat) SRATE;
+00018 std::string Stk :: rawwavepath_ = RAWWAVE_PATH;
+<a name="l00019"></a><a class="code" href="classStk.html#p0">00019</a> <span class="keyword">const</span> Stk::StkFormat Stk :: STK_SINT8 = 1;
+<a name="l00020"></a><a class="code" href="classStk.html#p1">00020</a> <span class="keyword">const</span> Stk::StkFormat Stk :: STK_SINT16 = 2;
+<a name="l00021"></a><a class="code" href="classStk.html#p2">00021</a> <span class="keyword">const</span> Stk::StkFormat Stk :: STK_SINT32 = 8;
+<a name="l00022"></a><a class="code" href="classStk.html#p3">00022</a> <span class="keyword">const</span> Stk::StkFormat Stk :: STK_FLOAT32 = 16;
+<a name="l00023"></a><a class="code" href="classStk.html#p4">00023</a> <span class="keyword">const</span> Stk::StkFormat Stk :: STK_FLOAT64 = 32;
+00024 
+<a name="l00025"></a><a class="code" href="classStk.html#d3">00025</a> <span class="keywordtype">void</span> <a class="code" href="classStk.html#d3">Stk :: setRawwavePath</a>(std::string path)
+00026 {
+00027   <span class="keywordflow">if</span> ( !path.empty() )
+00028     rawwavepath_ = path;
+00029 
+00030   <span class="comment">// Make sure the path includes a "/"</span>
+00031   <span class="keywordflow">if</span> ( rawwavepath_[rawwavepath_.length()-1] != <span class="charliteral">'/'</span> )
+00032     rawwavepath_ += <span class="stringliteral">"/"</span>;
+00033 }
+00034 
+<a name="l00035"></a><a class="code" href="classStk.html#d4">00035</a> <span class="keywordtype">void</span> <a class="code" href="classStk.html#d4">Stk :: swap16</a>(<span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> *ptr)
+00036 {
+00037   <span class="keyword">register</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> val;
+00038 
+00039   <span class="comment">// Swap 1st and 2nd bytes</span>
+00040   val = *(ptr);
+00041   *(ptr) = *(ptr+1);
+00042   *(ptr+1) = val;
+00043 }
+00044 
+<a name="l00045"></a><a class="code" href="classStk.html#d5">00045</a> <span class="keywordtype">void</span> <a class="code" href="classStk.html#d5">Stk :: swap32</a>(<span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> *ptr)
+00046 {
+00047   <span class="keyword">register</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> val;
+00048 
+00049   <span class="comment">// Swap 1st and 4th bytes</span>
+00050   val = *(ptr);
+00051   *(ptr) = *(ptr+3);
+00052   *(ptr+3) = val;
+00053 
+00054   <span class="comment">//Swap 2nd and 3rd bytes</span>
+00055   ptr += 1;
+00056   val = *(ptr);
+00057   *(ptr) = *(ptr+1);
+00058   *(ptr+1) = val;
+00059 }
+00060 
+<a name="l00061"></a><a class="code" href="classStk.html#d6">00061</a> <span class="keywordtype">void</span> <a class="code" href="classStk.html#d6">Stk :: swap64</a>(<span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> *ptr)
+00062 {
+00063   <span class="keyword">register</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> val;
+00064 
+00065   <span class="comment">// Swap 1st and 8th bytes</span>
+00066   val = *(ptr);
+00067   *(ptr) = *(ptr+7);
+00068   *(ptr+7) = val;
+00069 
+00070   <span class="comment">// Swap 2nd and 7th bytes</span>
+00071   ptr += 1;
+00072   val = *(ptr);
+00073   *(ptr) = *(ptr+5);
+00074   *(ptr+5) = val;
+00075 
+00076   <span class="comment">// Swap 3rd and 6th bytes</span>
+00077   ptr += 1;
+00078   val = *(ptr);
+00079   *(ptr) = *(ptr+3);
+00080   *(ptr+3) = val;
+00081 
+00082   <span class="comment">// Swap 4th and 5th bytes</span>
+00083   ptr += 1;
+00084   val = *(ptr);
+00085   *(ptr) = *(ptr+1);
+00086   *(ptr+1) = val;
+00087 }
+00088 
+00089 <span class="preprocessor">#if (defined(__OS_IRIX__) || defined(__OS_LINUX__) || defined(__OS_MACOSX__))</span>
+00090 <span class="preprocessor"></span><span class="preprocessor">  #include &lt;unistd.h&gt;</span>
+00091 <span class="preprocessor">#elif defined(__OS_WINDOWS__)</span>
+00092 <span class="preprocessor"></span><span class="preprocessor">  #include &lt;windows.h&gt;</span>
+00093 <span class="preprocessor">#endif</span>
+00094 <span class="preprocessor"></span>
+<a name="l00095"></a><a class="code" href="classStk.html#d7">00095</a> <span class="keywordtype">void</span> <a class="code" href="classStk.html#d7">Stk :: sleep</a>(<span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> milliseconds)
+00096 {
+00097 <span class="preprocessor">#if defined(__OS_WINDOWS__)</span>
+00098 <span class="preprocessor"></span>  Sleep((DWORD) milliseconds);
+00099 <span class="preprocessor">#elif (defined(__OS_IRIX__) || defined(__OS_LINUX__) || defined(__OS_MACOSX__))</span>
+00100 <span class="preprocessor"></span>  usleep( (<span class="keywordtype">unsigned</span> <span class="keywordtype">long</span>) (milliseconds * 1000.0) );
+00101 <span class="preprocessor">#endif</span>
+00102 <span class="preprocessor"></span>}
+00103 
+<a name="l00104"></a><a class="code" href="classStk.html#e0">00104</a> <span class="keywordtype">void</span> <a class="code" href="classStk.html#e0">Stk :: handleError</a>( <span class="keyword">const</span> std::string&amp; message, StkError::Type type )
+00105 {
+00106   <span class="keywordflow">if</span> ( type == StkError::WARNING ) {
+00107     std::cerr &lt;&lt; <span class="charliteral">'\n'</span> &lt;&lt; message &lt;&lt; <span class="stringliteral">"\n\n"</span>;
+00108   }
+00109   <span class="keywordflow">else</span> <span class="keywordflow">if</span> ( type == StkError::DEBUG_WARNING ) {
+00110 <span class="preprocessor">#if defined( __STK_DEBUG__ )</span>
+00111 <span class="preprocessor"></span>    std::cerr &lt;&lt; <span class="charliteral">'\n'</span> &lt;&lt; message &lt;&lt; <span class="stringliteral">"\n\n"</span>;
+00112 <span class="preprocessor">#endif</span>
+00113 <span class="preprocessor"></span>  }
+00114   <span class="keywordflow">else</span> {
+00115     <span class="comment">// Print error message before throwing.</span>
+00116     std::cerr &lt;&lt; <span class="charliteral">'\n'</span> &lt;&lt; message &lt;&lt; <span class="stringliteral">"\n\n"</span>;
+00117     <span class="keywordflow">throw</span> <a class="code" href="classStkError.html">StkError</a>(message, type);
+00118   }
+00119 }
+</pre></div><HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/Stk_8h-source.html b/doxygen/html/Stk_8h-source.html
new file mode 100755
index 0000000..45a46a1
--- /dev/null
+++ b/doxygen/html/Stk_8h-source.html
@@ -0,0 +1,162 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>Stk.h</h1><div class="fragment"><pre>00001 <span class="comment">/***************************************************/</span>
+00013 <span class="comment">/***************************************************/</span>
+00014 
+00015 <span class="preprocessor">#ifndef STK_STK_H</span>
+00016 <span class="preprocessor"></span><span class="preprocessor">#define STK_STK_H</span>
+00017 <span class="preprocessor"></span>
+00018 <span class="preprocessor">#include &lt;string&gt;</span>
+00019 <span class="preprocessor">#include &lt;iostream&gt;</span>
+00020 
+00021 <span class="comment">// Most data in STK is passed and calculated with the</span>
+00022 <span class="comment">// following user-definable floating-point type.  You</span>
+00023 <span class="comment">// can change this to "float" if you prefer or perhaps</span>
+00024 <span class="comment">// a "long double" in the future.</span>
+00025 <span class="keyword">typedef</span> <span class="keywordtype">double</span> StkFloat;
+00026 
+00028 
+<a name="l00033"></a><a class="code" href="classStkError.html">00033</a> <span class="keyword">class </span><a class="code" href="classStkError.html">StkError</a>
+00034 {
+00035 <span class="keyword">public</span>:
+00036   <span class="keyword">enum</span> Type { 
+00037     WARNING,
+00038     DEBUG_WARNING,
+00039     FUNCTION_ARGUMENT,
+00040     FILE_NOT_FOUND,
+00041     FILE_UNKNOWN_FORMAT,
+00042     FILE_ERROR,
+00043     PROCESS_THREAD,
+00044     PROCESS_SOCKET,
+00045     PROCESS_SOCKET_IPADDR,
+00046     AUDIO_SYSTEM,
+00047     MIDI_SYSTEM,
+00048     UNSPECIFIED
+00049   };
+00050 
+00051 <span class="keyword">protected</span>:
+00052   std::string message_;
+00053   Type type_;
+00054 
+00055 <span class="keyword">public</span>:
+<a name="l00057"></a><a class="code" href="classStkError.html#a0">00057</a>   <a class="code" href="classStkError.html#a0">StkError</a>( <span class="keyword">const</span> std::string&amp; message, Type type = StkError::UNSPECIFIED ) : message_(message), type_(type) {}
+00058 
+<a name="l00060"></a><a class="code" href="classStkError.html#a1">00060</a>   <span class="keyword">virtual</span> <a class="code" href="classStkError.html#a1">~StkError</a>(<span class="keywordtype">void</span>) {}
+00061 
+<a name="l00063"></a><a class="code" href="classStkError.html#a2">00063</a>   <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classStkError.html#a2">printMessage</a>(<span class="keywordtype">void</span>) { std::cout &lt;&lt; <span class="charliteral">'\n'</span> &lt;&lt; message_ &lt;&lt; <span class="stringliteral">"\n\n"</span>; }
+00064 
+<a name="l00066"></a><a class="code" href="classStkError.html#a3">00066</a>   <span class="keyword">virtual</span> <span class="keyword">const</span> Type&amp; <a class="code" href="classStkError.html#a3">getType</a>(<span class="keywordtype">void</span>) { <span class="keywordflow">return</span> type_; }
+00067 
+<a name="l00069"></a><a class="code" href="classStkError.html#a4">00069</a>   <span class="keyword">virtual</span> <span class="keyword">const</span> std::string&amp; <a class="code" href="classStkError.html#a4">getMessage</a>(<span class="keywordtype">void</span>) { <span class="keywordflow">return</span> message_; }
+00070 };
+00071 
+<a name="l00072"></a><a class="code" href="classStk.html">00072</a> <span class="keyword">class </span><a class="code" href="classStk.html">Stk</a>
+00073 {
+00074 <span class="keyword">public</span>:
+00075 
+00076   <span class="keyword">typedef</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> StkFormat;
+00077   <span class="keyword">static</span> <span class="keyword">const</span> StkFormat <a class="code" href="classStk.html#p0">STK_SINT8</a>;   
+00078   <span class="keyword">static</span> <span class="keyword">const</span> StkFormat <a class="code" href="classStk.html#p1">STK_SINT16</a>;  
+00079   <span class="keyword">static</span> <span class="keyword">const</span> StkFormat <a class="code" href="classStk.html#p2">STK_SINT32</a>;  
+00080   <span class="keyword">static</span> <span class="keyword">const</span> StkFormat <a class="code" href="classStk.html#p3">STK_FLOAT32</a>; 
+00081   <span class="keyword">static</span> <span class="keyword">const</span> StkFormat <a class="code" href="classStk.html#p4">STK_FLOAT64</a>; 
+00083 
+<a name="l00084"></a><a class="code" href="classStk.html#d0">00084</a>   <span class="keyword">static</span> StkFloat <a class="code" href="classStk.html#d0">sampleRate</a>(<span class="keywordtype">void</span>) { <span class="keywordflow">return</span> srate_; }
+00085 
+00087 
+<a name="l00095"></a><a class="code" href="classStk.html#d1">00095</a>   <span class="keyword">static</span> <span class="keywordtype">void</span> <a class="code" href="classStk.html#d1">setSampleRate</a>(StkFloat rate) { <span class="keywordflow">if</span> (rate &gt; 0.0) srate_ = rate; }
+00096 
+<a name="l00098"></a><a class="code" href="classStk.html#d2">00098</a>   <span class="keyword">static</span> std::string <a class="code" href="classStk.html#d2">rawwavePath</a>(<span class="keywordtype">void</span>) { <span class="keywordflow">return</span> rawwavepath_; }
+00099 
+00101   <span class="keyword">static</span> <span class="keywordtype">void</span> <a class="code" href="classStk.html#d3">setRawwavePath</a>(std::string path);
+00102 
+00104   <span class="keyword">static</span> <span class="keywordtype">void</span> <a class="code" href="classStk.html#d4">swap16</a>(<span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> *ptr);
+00105 
+00107   <span class="keyword">static</span> <span class="keywordtype">void</span> <a class="code" href="classStk.html#d5">swap32</a>(<span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> *ptr);
+00108 
+00110   <span class="keyword">static</span> <span class="keywordtype">void</span> <a class="code" href="classStk.html#d6">swap64</a>(<span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> *ptr);
+00111 
+00113   <span class="keyword">static</span> <span class="keywordtype">void</span> <a class="code" href="classStk.html#d7">sleep</a>(<span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> milliseconds);
+00114 
+00115 <span class="keyword">private</span>:
+00116   <span class="keyword">static</span> StkFloat srate_;
+00117   <span class="keyword">static</span> std::string rawwavepath_;
+00118 
+00119 <span class="keyword">protected</span>:
+00120 
+00122   <span class="keyword">static</span> <span class="keywordtype">void</span> <a class="code" href="classStk.html#e0">handleError</a>( <span class="keyword">const</span> std::string&amp; message, StkError::Type type );
+00123 
+00124 };
+00125 
+00126 <span class="comment">// Here are a few other useful typedefs.</span>
+00127 <span class="keyword">typedef</span> <span class="keywordtype">signed</span> <span class="keywordtype">short</span> SINT16;
+00128 <span class="keyword">typedef</span> <span class="keywordtype">signed</span> <span class="keywordtype">int</span> SINT32;
+00129 <span class="keyword">typedef</span> <span class="keywordtype">float</span> FLOAT32;
+00130 <span class="keyword">typedef</span> <span class="keywordtype">double</span> FLOAT64;
+00131 
+00132 <span class="comment">// Boolean values</span>
+00133 <span class="preprocessor">#define FALSE 0</span>
+00134 <span class="preprocessor"></span><span class="preprocessor">#define TRUE 1</span>
+00135 <span class="preprocessor"></span>
+00136 <span class="comment">// The default sampling rate.</span>
+00137 <span class="preprocessor">#define SRATE (StkFloat) 44100.0</span>
+00138 <span class="preprocessor"></span>
+00139 <span class="comment">// The default real-time audio input and output buffer size.  If</span>
+00140 <span class="comment">// clicks are occuring in the input and/or output sound stream, a</span>
+00141 <span class="comment">// larger buffer size may help.  Larger buffer sizes, however, result</span>
+00142 <span class="comment">// in more latency.</span>
+00143 <span class="preprocessor">#define RT_BUFFER_SIZE 512</span>
+00144 <span class="preprocessor"></span>
+00145 <span class="comment">// The default rawwave path value is set with the preprocessor</span>
+00146 <span class="comment">// definition RAWWAVE_PATH.  This can be specified as an argument to</span>
+00147 <span class="comment">// the configure script, in an integrated development environment, or</span>
+00148 <span class="comment">// below.  The global STK rawwave path variable can be dynamically set</span>
+00149 <span class="comment">// with the Stk::setRawwavePath() function.  This value is</span>
+00150 <span class="comment">// concatenated to the beginning of all references to rawwave files in</span>
+00151 <span class="comment">// various STK classes.  If you wish to move the rawwaves directory to</span>
+00152 <span class="comment">// a different location in your file system, you will need to set this</span>
+00153 <span class="comment">// path definition appropriately.</span>
+00154 <span class="preprocessor">#if !defined(RAWWAVE_PATH)</span>
+00155 <span class="preprocessor"></span><span class="preprocessor">  #define RAWWAVE_PATH "../../rawwaves/"</span>
+00156 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
+00157 <span class="preprocessor"></span>
+00158 <span class="preprocessor">#define PI (MY_FLOAT) 3.14159265359</span>
+00159 <span class="preprocessor"></span><span class="preprocessor">#define TWO_PI (MY_FLOAT) (MY_FLOAT) (2 * PI)</span>
+00160 <span class="preprocessor"></span>
+00161 <span class="preprocessor">#define ONE_OVER_128 (MY_FLOAT) 0.0078125</span>
+00162 <span class="preprocessor"></span>
+00163 <span class="preprocessor">#if defined(__WINDOWS_DS__) || defined(__WINDOWS_ASIO__)</span>
+00164 <span class="preprocessor"></span><span class="preprocessor">  #define __OS_WINDOWS__</span>
+00165 <span class="preprocessor"></span><span class="preprocessor">  #define __STK_REALTIME__</span>
+00166 <span class="preprocessor"></span><span class="preprocessor">#elif defined(__LINUX_OSS__) || defined(__LINUX_ALSA__) || defined(__LINUX_JACK__)</span>
+00167 <span class="preprocessor"></span><span class="preprocessor">  #define __OS_LINUX__</span>
+00168 <span class="preprocessor"></span><span class="preprocessor">  #define __STK_REALTIME__</span>
+00169 <span class="preprocessor"></span><span class="preprocessor">#elif defined(__IRIX_AL__)</span>
+00170 <span class="preprocessor"></span><span class="preprocessor">  #define __OS_IRIX__</span>
+00171 <span class="preprocessor"></span><span class="preprocessor">  #define __STK_REALTIME__</span>
+00172 <span class="preprocessor"></span><span class="preprocessor">#elif defined(__MACOSX_CORE__)</span>
+00173 <span class="preprocessor"></span><span class="preprocessor">  #define __OS_MACOSX__</span>
+00174 <span class="preprocessor"></span><span class="preprocessor">  #define __STK_REALTIME__</span>
+00175 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
+00176 <span class="preprocessor"></span>
+00177 <span class="comment">//#define __STK_DEBUG__</span>
+00178 
+00179 <span class="preprocessor">#endif</span>
+</pre></div><HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/annotated.html b/doxygen/html/annotated.html
new file mode 100755
index 0000000..02a08e7
--- /dev/null
+++ b/doxygen/html/annotated.html
@@ -0,0 +1,29 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>STK Compound List</h1>Here are the classes, structs, unions and interfaces with brief descriptions:<table>
+  <tr><td class="indexkey"><a class="el" href="classMidiFileIn.html">MidiFileIn</a></td><td class="indexvalue">A standard MIDI file reading/parsing class</td></tr>
+  <tr><td class="indexkey"><a class="el" href="classRtError.html">RtError</a></td><td class="indexvalue">Exception handling class for RtAudio &amp; <a class="el" href="classRtMidi.html">RtMidi</a></td></tr>
+  <tr><td class="indexkey"><a class="el" href="classRtMidi.html">RtMidi</a></td><td class="indexvalue">An abstract base class for realtime MIDI input/output</td></tr>
+  <tr><td class="indexkey"><a class="el" href="classRtMidiIn.html">RtMidiIn</a></td><td class="indexvalue">A realtime MIDI input class</td></tr>
+  <tr><td class="indexkey"><a class="el" href="classRtMidiOut.html">RtMidiOut</a></td><td class="indexvalue">A realtime MIDI output class</td></tr>
+  <tr><td class="indexkey"><a class="el" href="classStk.html">Stk</a></td><td class="indexvalue">STK base class</td></tr>
+  <tr><td class="indexkey"><a class="el" href="classStkError.html">StkError</a></td><td class="indexvalue">STK error handling class</td></tr>
+</table>
+<HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/classMidiFileIn-members.html b/doxygen/html/classMidiFileIn-members.html
new file mode 100755
index 0000000..85c5512
--- /dev/null
+++ b/doxygen/html/classMidiFileIn-members.html
@@ -0,0 +1,44 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>MidiFileIn Member List</h1>This is the complete list of members for <a class="el" href="classMidiFileIn.html">MidiFileIn</a>, including all inherited members.<table>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classMidiFileIn.html#a4">getDivision</a>() const</td><td><a class="el" href="classMidiFileIn.html">MidiFileIn</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classMidiFileIn.html#a2">getFileFormat</a>() const</td><td><a class="el" href="classMidiFileIn.html">MidiFileIn</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classMidiFileIn.html#a7">getNextEvent</a>(std::vector&lt; unsigned char &gt; *event, unsigned int track=0)</td><td><a class="el" href="classMidiFileIn.html">MidiFileIn</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classMidiFileIn.html#a8">getNextMidiEvent</a>(std::vector&lt; unsigned char &gt; *midiEvent, unsigned int track=0)</td><td><a class="el" href="classMidiFileIn.html">MidiFileIn</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classMidiFileIn.html#a3">getNumberOfTracks</a>() const</td><td><a class="el" href="classMidiFileIn.html">MidiFileIn</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classMidiFileIn.html#a6">getTickSeconds</a>(unsigned int track=0)</td><td><a class="el" href="classMidiFileIn.html">MidiFileIn</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#e0">handleError</a>(const std::string &amp;message, StkError::Type type)</td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [protected, static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classMidiFileIn.html#a0">MidiFileIn</a>(std::string fileName)</td><td><a class="el" href="classMidiFileIn.html">MidiFileIn</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#d2">rawwavePath</a>(void)</td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [inline, static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classMidiFileIn.html#a5">rewindTrack</a>(unsigned int track=0)</td><td><a class="el" href="classMidiFileIn.html">MidiFileIn</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#d0">sampleRate</a>(void)</td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [inline, static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#d3">setRawwavePath</a>(std::string path)</td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#d1">setSampleRate</a>(StkFloat rate)</td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [inline, static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#d7">sleep</a>(unsigned long milliseconds)</td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#p3">STK_FLOAT32</a></td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#p4">STK_FLOAT64</a></td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#p1">STK_SINT16</a></td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#p2">STK_SINT32</a></td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#p0">STK_SINT8</a></td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#d4">swap16</a>(unsigned char *ptr)</td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#d5">swap32</a>(unsigned char *ptr)</td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#d6">swap64</a>(unsigned char *ptr)</td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classMidiFileIn.html#a1">~MidiFileIn</a>()</td><td><a class="el" href="classMidiFileIn.html">MidiFileIn</a></td><td></td></tr>
+</table><HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/classMidiFileIn.html b/doxygen/html/classMidiFileIn.html
new file mode 100755
index 0000000..e03bb48
--- /dev/null
+++ b/doxygen/html/classMidiFileIn.html
@@ -0,0 +1,296 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>MidiFileIn Class Reference</h1>A standard MIDI file reading/parsing class. 
+<a href="#_details">More...</a>
+<p>
+<code>#include &lt;<a class="el" href="MidiFileIn_8h-source.html">MidiFileIn.h</a>&gt;</code>
+<p>
+<p>Inheritance diagram for MidiFileIn:
+<p><center><img src="classMidiFileIn.png" usemap="#MidiFileIn_map" border="0" alt=""></center>
+<map name="MidiFileIn_map">
+<area href="classStk.html" alt="Stk" shape="rect" coords="0,0,67,24">
+</map>
+<a href="classMidiFileIn-members.html">List of all members.</a><table border=0 cellpadding=0 cellspacing=0>
+<tr><td></td></tr>
+<tr><td colspan=2><br><h2>Public Member Functions</h2></td></tr>
+<tr><td nowrap align=right valign=top>&nbsp;</td><td valign=bottom><a class="el" href="classMidiFileIn.html#a0">MidiFileIn</a> (std::string fileName)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Default constructor.</em> <a href="#a0"></a><em></em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="a1" doxytag="MidiFileIn::~MidiFileIn"></a>
+&nbsp;</td><td valign=bottom><a class="el" href="classMidiFileIn.html#a1">~MidiFileIn</a> ()</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Class destructor.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="a2" doxytag="MidiFileIn::getFileFormat"></a>
+int&nbsp;</td><td valign=bottom><a class="el" href="classMidiFileIn.html#a2">getFileFormat</a> () const</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Return the MIDI file format (0, 1, or 2).</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="a3" doxytag="MidiFileIn::getNumberOfTracks"></a>
+unsigned int&nbsp;</td><td valign=bottom><a class="el" href="classMidiFileIn.html#a3">getNumberOfTracks</a> () const</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Return the number of tracks in the MIDI file.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top>int&nbsp;</td><td valign=bottom><a class="el" href="classMidiFileIn.html#a4">getDivision</a> () const</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Return the MIDI file division value from the file header.</em> <a href="#a4"></a><em></em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top>void&nbsp;</td><td valign=bottom><a class="el" href="classMidiFileIn.html#a5">rewindTrack</a> (unsigned int track=0)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Move the specified track event reader to the beginning of its track.</em> <a href="#a5"></a><em></em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top>double&nbsp;</td><td valign=bottom><a class="el" href="classMidiFileIn.html#a6">getTickSeconds</a> (unsigned int track=0)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Get the current value, in seconds, of delta-time ticks for the specified track.</em> <a href="#a6"></a><em></em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top>unsigned long&nbsp;</td><td valign=bottom><a class="el" href="classMidiFileIn.html#a7">getNextEvent</a> (std::vector&lt; unsigned char &gt; *event, unsigned int track=0)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Fill the user-provided vector with the next event in the specified track and return the event delta-time in ticks.</em> <a href="#a7"></a><em></em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top>unsigned long&nbsp;</td><td valign=bottom><a class="el" href="classMidiFileIn.html#a8">getNextMidiEvent</a> (std::vector&lt; unsigned char &gt; *midiEvent, unsigned int track=0)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Fill the user-provided vector with the next MIDI channel event in the specified track and return the event delta time in ticks.</em> <a href="#a8"></a><em></em></font><br><br></td></tr>
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+A standard MIDI file reading/parsing class.
+<p>
+This class can be used to read events from a standard MIDI file. Event bytes are copied to a C++ vector and must be subsequently interpreted by the user. The function <a class="el" href="classMidiFileIn.html#a8">getNextMidiEvent()</a> skips meta and sysex events, returning only MIDI channel messages. Event delta-times are returned in the form of "ticks" and a function is provided to determine the current "seconds per tick". Tempo changes are internally tracked by the class and reflected in the values returned by the function <a class="el" href="classMidiFileIn.html#a6">getTickSeconds()</a>.<p>
+by Gary P. Scavone, 2003. 
+<p>
+
+<p>
+Definition at line <a class="el" href="MidiFileIn_8h-source.html#l00027">27</a> of file <a class="el" href="MidiFileIn_8h-source.html">MidiFileIn.h</a>.<hr><h2>Constructor &amp; Destructor Documentation</h2>
+<a name="a0" doxytag="MidiFileIn::MidiFileIn"></a><p>
+<table width="100%" cellpadding="2" cellspacing="0" border="0">
+  <tr>
+    <td class="md">
+      <table cellpadding="0" cellspacing="0" border="0">
+        <tr>
+          <td class="md" nowrap valign="top"> MidiFileIn::MidiFileIn </td>
+          <td class="md" valign="top">(&nbsp;</td>
+          <td class="md" nowrap valign="top">std::string&nbsp;</td>
+          <td class="mdname1" valign="top" nowrap>&nbsp; <em>fileName</em>          </td>
+          <td class="md" valign="top">)&nbsp;</td>
+          <td class="md" nowrap></td>
+        </tr>
+
+      </table>
+    </td>
+  </tr>
+</table>
+<table cellspacing=5 cellpadding=0 border=0>
+  <tr>
+    <td>
+      &nbsp;
+    </td>
+    <td>
+
+<p>
+Default constructor.
+<p>
+If an error occurs while opening or parsing the file header, an <a class="el" href="classStkError.html">StkError</a> exception will be thrown. 
+<p>
+Definition at line <a class="el" href="MidiFileIn_8cpp-source.html#l00021">21</a> of file <a class="el" href="MidiFileIn_8cpp-source.html">MidiFileIn.cpp</a>.
+<p>
+References <a class="el" href="MidiFileIn_8cpp-source.html#l00186">getNextEvent()</a>, <a class="el" href="Stk_8cpp-source.html#l00104">Stk::handleError()</a>, and <a class="el" href="MidiFileIn_8cpp-source.html#l00163">rewindTrack()</a>.    </td>
+  </tr>
+</table>
+<hr><h2>Member Function Documentation</h2>
+<a name="a4" doxytag="MidiFileIn::getDivision"></a><p>
+<table width="100%" cellpadding="2" cellspacing="0" border="0">
+  <tr>
+    <td class="md">
+      <table cellpadding="0" cellspacing="0" border="0">
+        <tr>
+          <td class="md" nowrap valign="top"> int MidiFileIn::getDivision </td>
+          <td class="md" valign="top">(&nbsp;</td>
+          <td class="mdname1" valign="top" nowrap>&nbsp;          </td>
+          <td class="md" valign="top">)&nbsp;</td>
+          <td class="md" nowrap> const</td>
+        </tr>
+
+      </table>
+    </td>
+  </tr>
+</table>
+<table cellspacing=5 cellpadding=0 border=0>
+  <tr>
+    <td>
+      &nbsp;
+    </td>
+    <td>
+
+<p>
+Return the MIDI file division value from the file header.
+<p>
+Note that this value must be "parsed" in accordance with the MIDI File Specification. In particular, if the MSB is set, the file uses time-code representations for delta-time values. 
+<p>
+Definition at line <a class="el" href="MidiFileIn_8cpp-source.html#l00158">158</a> of file <a class="el" href="MidiFileIn_8cpp-source.html">MidiFileIn.cpp</a>.    </td>
+  </tr>
+</table>
+<a name="a5" doxytag="MidiFileIn::rewindTrack"></a><p>
+<table width="100%" cellpadding="2" cellspacing="0" border="0">
+  <tr>
+    <td class="md">
+      <table cellpadding="0" cellspacing="0" border="0">
+        <tr>
+          <td class="md" nowrap valign="top"> void MidiFileIn::rewindTrack </td>
+          <td class="md" valign="top">(&nbsp;</td>
+          <td class="md" nowrap valign="top">unsigned int&nbsp;</td>
+          <td class="mdname1" valign="top" nowrap>&nbsp; <em>track</em> = 0          </td>
+          <td class="md" valign="top">)&nbsp;</td>
+          <td class="md" nowrap></td>
+        </tr>
+
+      </table>
+    </td>
+  </tr>
+</table>
+<table cellspacing=5 cellpadding=0 border=0>
+  <tr>
+    <td>
+      &nbsp;
+    </td>
+    <td>
+
+<p>
+Move the specified track event reader to the beginning of its track.
+<p>
+The relevant track tempo value is reset as well. If an invalid track number is specified, an <a class="el" href="classStkError.html">StkError</a> exception will be thrown. 
+<p>
+Definition at line <a class="el" href="MidiFileIn_8cpp-source.html#l00163">163</a> of file <a class="el" href="MidiFileIn_8cpp-source.html">MidiFileIn.cpp</a>.
+<p>
+References <a class="el" href="Stk_8cpp-source.html#l00104">Stk::handleError()</a>.
+<p>
+Referenced by <a class="el" href="MidiFileIn_8cpp-source.html#l00021">MidiFileIn()</a>.    </td>
+  </tr>
+</table>
+<a name="a6" doxytag="MidiFileIn::getTickSeconds"></a><p>
+<table width="100%" cellpadding="2" cellspacing="0" border="0">
+  <tr>
+    <td class="md">
+      <table cellpadding="0" cellspacing="0" border="0">
+        <tr>
+          <td class="md" nowrap valign="top"> double MidiFileIn::getTickSeconds </td>
+          <td class="md" valign="top">(&nbsp;</td>
+          <td class="md" nowrap valign="top">unsigned int&nbsp;</td>
+          <td class="mdname1" valign="top" nowrap>&nbsp; <em>track</em> = 0          </td>
+          <td class="md" valign="top">)&nbsp;</td>
+          <td class="md" nowrap></td>
+        </tr>
+
+      </table>
+    </td>
+  </tr>
+</table>
+<table cellspacing=5 cellpadding=0 border=0>
+  <tr>
+    <td>
+      &nbsp;
+    </td>
+    <td>
+
+<p>
+Get the current value, in seconds, of delta-time ticks for the specified track.
+<p>
+This value can change as events are read (via "Set Tempo" Meta-Events). Therefore, one should call this function after every call to <a class="el" href="classMidiFileIn.html#a7">getNextEvent()</a> or <a class="el" href="classMidiFileIn.html#a8">getNextMidiEvent()</a>. If an invalid track number is specified, an <a class="el" href="classStkError.html">StkError</a> exception will be thrown. 
+<p>
+Definition at line <a class="el" href="MidiFileIn_8cpp-source.html#l00175">175</a> of file <a class="el" href="MidiFileIn_8cpp-source.html">MidiFileIn.cpp</a>.
+<p>
+References <a class="el" href="Stk_8cpp-source.html#l00104">Stk::handleError()</a>.    </td>
+  </tr>
+</table>
+<a name="a7" doxytag="MidiFileIn::getNextEvent"></a><p>
+<table width="100%" cellpadding="2" cellspacing="0" border="0">
+  <tr>
+    <td class="md">
+      <table cellpadding="0" cellspacing="0" border="0">
+        <tr>
+          <td class="md" nowrap valign="top"> unsigned long MidiFileIn::getNextEvent </td>
+          <td class="md" valign="top">(&nbsp;</td>
+          <td class="md" nowrap valign="top">std::vector&lt; unsigned char &gt; *&nbsp;</td>
+          <td class="mdname" nowrap>&nbsp; <em>event</em>, </td>
+        </tr>
+        <tr>
+          <td></td>
+          <td></td>
+          <td class="md" nowrap>unsigned int&nbsp;</td>
+          <td class="mdname" nowrap>&nbsp; <em>track</em> = 0</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td class="md">)&nbsp;</td>
+          <td class="md" colspan="2"></td>
+        </tr>
+
+      </table>
+    </td>
+  </tr>
+</table>
+<table cellspacing=5 cellpadding=0 border=0>
+  <tr>
+    <td>
+      &nbsp;
+    </td>
+    <td>
+
+<p>
+Fill the user-provided vector with the next event in the specified track and return the event delta-time in ticks.
+<p>
+MIDI File events consist of a delta time and a sequence of event bytes. This function returns the delta-time value and writes the subsequent event bytes directly to the event vector. The user must parse the event bytes in accordance with the MIDI File Specification. All returned MIDI channel events are complete ... a status byte is provided even when running status is used in the file. If the track has reached its end, no bytes will be written and the event vector size will be zero. If an invalid track number is specified or an error occurs while reading the file, an <a class="el" href="classStkError.html">StkError</a> exception will be thrown. 
+<p>
+Definition at line <a class="el" href="MidiFileIn_8cpp-source.html#l00186">186</a> of file <a class="el" href="MidiFileIn_8cpp-source.html">MidiFileIn.cpp</a>.
+<p>
+References <a class="el" href="Stk_8cpp-source.html#l00104">Stk::handleError()</a>.
+<p>
+Referenced by <a class="el" href="MidiFileIn_8cpp-source.html#l00301">getNextMidiEvent()</a>, and <a class="el" href="MidiFileIn_8cpp-source.html#l00021">MidiFileIn()</a>.    </td>
+  </tr>
+</table>
+<a name="a8" doxytag="MidiFileIn::getNextMidiEvent"></a><p>
+<table width="100%" cellpadding="2" cellspacing="0" border="0">
+  <tr>
+    <td class="md">
+      <table cellpadding="0" cellspacing="0" border="0">
+        <tr>
+          <td class="md" nowrap valign="top"> unsigned long MidiFileIn::getNextMidiEvent </td>
+          <td class="md" valign="top">(&nbsp;</td>
+          <td class="md" nowrap valign="top">std::vector&lt; unsigned char &gt; *&nbsp;</td>
+          <td class="mdname" nowrap>&nbsp; <em>midiEvent</em>, </td>
+        </tr>
+        <tr>
+          <td></td>
+          <td></td>
+          <td class="md" nowrap>unsigned int&nbsp;</td>
+          <td class="mdname" nowrap>&nbsp; <em>track</em> = 0</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td class="md">)&nbsp;</td>
+          <td class="md" colspan="2"></td>
+        </tr>
+
+      </table>
+    </td>
+  </tr>
+</table>
+<table cellspacing=5 cellpadding=0 border=0>
+  <tr>
+    <td>
+      &nbsp;
+    </td>
+    <td>
+
+<p>
+Fill the user-provided vector with the next MIDI channel event in the specified track and return the event delta time in ticks.
+<p>
+All returned MIDI events are complete ... a status byte is provided even when running status is used in the file. Meta and sysex events in the track are skipped though "Set Tempo" events are properly parsed for use by the <a class="el" href="classMidiFileIn.html#a6">getTickSeconds()</a> function. If the track has reached its end, no bytes will be written and the event vector size will be zero. If an invalid track number is specified or an error occurs while reading the file, an <a class="el" href="classStkError.html">StkError</a> exception will be thrown. 
+<p>
+Definition at line <a class="el" href="MidiFileIn_8cpp-source.html#l00301">301</a> of file <a class="el" href="MidiFileIn_8cpp-source.html">MidiFileIn.cpp</a>.
+<p>
+References <a class="el" href="MidiFileIn_8cpp-source.html#l00186">getNextEvent()</a>, and <a class="el" href="Stk_8cpp-source.html#l00104">Stk::handleError()</a>.    </td>
+  </tr>
+</table>
+<hr>The documentation for this class was generated from the following files:<ul>
+<li><a class="el" href="MidiFileIn_8h-source.html">MidiFileIn.h</a><li><a class="el" href="MidiFileIn_8cpp-source.html">MidiFileIn.cpp</a></ul>
+<HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/classMidiFileIn.png b/doxygen/html/classMidiFileIn.png
new file mode 100755
index 0000000..13082f0
--- /dev/null
+++ b/doxygen/html/classMidiFileIn.png
diff --git a/doxygen/html/classRtError-members.html b/doxygen/html/classRtError-members.html
new file mode 100755
index 0000000..da67c30
--- /dev/null
+++ b/doxygen/html/classRtError-members.html
@@ -0,0 +1,27 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>RtError Member List</h1>This is the complete list of members for <a class="el" href="classRtError.html">RtError</a>, including all inherited members.<table>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtError.html#a4">getMessage</a>(void)</td><td><a class="el" href="classRtError.html">RtError</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtError.html#a3">getType</a>(void)</td><td><a class="el" href="classRtError.html">RtError</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtError.html#a2">printMessage</a>(void)</td><td><a class="el" href="classRtError.html">RtError</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtError.html#a0">RtError</a>(const std::string &amp;message, Type type=RtError::UNSPECIFIED)</td><td><a class="el" href="classRtError.html">RtError</a></td><td><code> [inline]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtError.html#s11">Type</a> enum name</td><td><a class="el" href="classRtError.html">RtError</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtError.html#a1">~RtError</a>(void)</td><td><a class="el" href="classRtError.html">RtError</a></td><td><code> [inline, virtual]</code></td></tr>
+</table><HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/classRtError.html b/doxygen/html/classRtError.html
new file mode 100755
index 0000000..535c495
--- /dev/null
+++ b/doxygen/html/classRtError.html
@@ -0,0 +1,56 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>RtError Class Reference</h1>Exception handling class for RtAudio &amp; <a class="el" href="classRtMidi.html">RtMidi</a>. 
+<a href="#_details">More...</a>
+<p>
+<code>#include &lt;<a class="el" href="RtError_8h-source.html">RtError.h</a>&gt;</code>
+<p>
+<a href="classRtError-members.html">List of all members.</a><table border=0 cellpadding=0 cellspacing=0>
+<tr><td></td></tr>
+<tr><td colspan=2><br><h2>Public Types</h2></td></tr>
+<tr><td nowrap align=right valign=top>enum &nbsp;</td><td valign=bottom><a class="el" href="classRtError.html#s11">Type</a> </td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Defined RtError types.</em></font><br><br></td></tr>
+<tr><td colspan=2><br><h2>Public Member Functions</h2></td></tr>
+<tr><td nowrap align=right valign=top><a name="a0" doxytag="RtError::RtError"></a>
+&nbsp;</td><td valign=bottom><a class="el" href="classRtError.html#a0">RtError</a> (const std::string &amp;message, <a class="el" href="classRtError.html#s11">Type</a> type=RtError::UNSPECIFIED)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>The constructor.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="a1" doxytag="RtError::~RtError"></a>
+virtual&nbsp;</td><td valign=bottom><a class="el" href="classRtError.html#a1">~RtError</a> (void)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>The destructor.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="a2" doxytag="RtError::printMessage"></a>
+virtual void&nbsp;</td><td valign=bottom><a class="el" href="classRtError.html#a2">printMessage</a> (void)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Prints "thrown" error message to stdout.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="a3" doxytag="RtError::getType"></a>
+virtual const <a class="el" href="classRtError.html#s11">Type</a> &amp;&nbsp;</td><td valign=bottom><a class="el" href="classRtError.html#a3">getType</a> (void)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Returns the "thrown" error message type.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="a4" doxytag="RtError::getMessage"></a>
+virtual const std::string &amp;&nbsp;</td><td valign=bottom><a class="el" href="classRtError.html#a4">getMessage</a> (void)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Returns the "thrown" error message string.</em></font><br><br></td></tr>
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+Exception handling class for RtAudio &amp; <a class="el" href="classRtMidi.html">RtMidi</a>.
+<p>
+The RtError class is quite simple but it does allow errors to be "caught" by <a class="el" href="classRtError.html#s11">RtError::Type</a>. See the RtAudio and <a class="el" href="classRtMidi.html">RtMidi</a> documentation to know which methods can "throw" an RtError. 
+<p>
+
+<p>
+Definition at line <a class="el" href="RtError_8h-source.html#l00018">18</a> of file <a class="el" href="RtError_8h-source.html">RtError.h</a>.<hr>The documentation for this class was generated from the following file:<ul>
+<li><a class="el" href="RtError_8h-source.html">RtError.h</a></ul>
+<HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/classRtMidi-members.html b/doxygen/html/classRtMidi-members.html
new file mode 100755
index 0000000..dc1fd95
--- /dev/null
+++ b/doxygen/html/classRtMidi-members.html
@@ -0,0 +1,21 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>RtMidi Member List</h1>This is the complete list of members for <a class="el" href="classRtMidi.html">RtMidi</a>, including all inherited members.<table>
+</table><HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/classRtMidi.html b/doxygen/html/classRtMidi.html
new file mode 100755
index 0000000..dc7efe0
--- /dev/null
+++ b/doxygen/html/classRtMidi.html
@@ -0,0 +1,44 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>RtMidi Class Reference</h1>An abstract base class for realtime MIDI input/output. 
+<a href="#_details">More...</a>
+<p>
+<code>#include &lt;<a class="el" href="RtMidi_8h-source.html">RtMidi.h</a>&gt;</code>
+<p>
+<p>Inheritance diagram for RtMidi:
+<p><center><img src="classRtMidi.png" usemap="#RtMidi_map" border="0" alt=""></center>
+<map name="RtMidi_map">
+<area href="classRtMidiIn.html" alt="RtMidiIn" shape="rect" coords="0,56,67,80">
+<area href="classRtMidiOut.html" alt="RtMidiOut" shape="rect" coords="77,56,144,80">
+</map>
+<a href="classRtMidi-members.html">List of all members.</a><table border=0 cellpadding=0 cellspacing=0>
+<tr><td></td></tr>
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+An abstract base class for realtime MIDI input/output.
+<p>
+This class implements some common functionality for the realtime MIDI input/output subclasses <a class="el" href="classRtMidiIn.html">RtMidiIn</a> and <a class="el" href="classRtMidiOut.html">RtMidiOut</a>.<p>
+by Gary P. Scavone, 2003. 
+<p>
+
+<p>
+Definition at line <a class="el" href="RtMidi_8h-source.html#l00018">18</a> of file <a class="el" href="RtMidi_8h-source.html">RtMidi.h</a>.<hr>The documentation for this class was generated from the following files:<ul>
+<li><a class="el" href="RtMidi_8h-source.html">RtMidi.h</a><li><a class="el" href="RtMidi_8cpp-source.html">RtMidi.cpp</a></ul>
+<HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/classRtMidi.png b/doxygen/html/classRtMidi.png
new file mode 100755
index 0000000..4114caf
--- /dev/null
+++ b/doxygen/html/classRtMidi.png
diff --git a/doxygen/html/classRtMidiIn-members.html b/doxygen/html/classRtMidiIn-members.html
new file mode 100755
index 0000000..c314e0c
--- /dev/null
+++ b/doxygen/html/classRtMidiIn-members.html
@@ -0,0 +1,32 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>RtMidiIn Member List</h1>This is the complete list of members for <a class="el" href="classRtMidiIn.html">RtMidiIn</a>, including all inherited members.<table>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtMidiIn.html#a4">closePort</a>(void)</td><td><a class="el" href="classRtMidiIn.html">RtMidiIn</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtMidiIn.html#a9">getMessage</a>(std::vector&lt; unsigned char &gt; *message)</td><td><a class="el" href="classRtMidiIn.html">RtMidiIn</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtMidiIn.html#a5">getPortCount</a>()</td><td><a class="el" href="classRtMidiIn.html">RtMidiIn</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtMidiIn.html#a6">getPortName</a>(unsigned int portNumber=0)</td><td><a class="el" href="classRtMidiIn.html">RtMidiIn</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtMidiIn.html#a8">ignoreTypes</a>(bool midiSysex=true, bool midiTime=true, bool midiSense=true)</td><td><a class="el" href="classRtMidiIn.html">RtMidiIn</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtMidiIn.html#a3">openPort</a>(unsigned int portNumber=0, RtMidiCallback callback=0, void *userData=0)</td><td><a class="el" href="classRtMidiIn.html">RtMidiIn</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtMidiIn.html#s0">RtMidiCallback</a> typedef</td><td><a class="el" href="classRtMidiIn.html">RtMidiIn</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtMidiIn.html#a0">RtMidiIn</a>()</td><td><a class="el" href="classRtMidiIn.html">RtMidiIn</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtMidiIn.html#a1">RtMidiIn</a>(unsigned int portNumber, RtMidiCallback callback=0, void *userData=0)</td><td><a class="el" href="classRtMidiIn.html">RtMidiIn</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtMidiIn.html#a7">setQueueSizeLimit</a>(unsigned int queueSize)</td><td><a class="el" href="classRtMidiIn.html">RtMidiIn</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtMidiIn.html#a2">~RtMidiIn</a>()</td><td><a class="el" href="classRtMidiIn.html">RtMidiIn</a></td><td></td></tr>
+</table><HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/classRtMidiIn.html b/doxygen/html/classRtMidiIn.html
new file mode 100755
index 0000000..9af2a2e
--- /dev/null
+++ b/doxygen/html/classRtMidiIn.html
@@ -0,0 +1,281 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>RtMidiIn Class Reference</h1>A realtime MIDI input class. 
+<a href="#_details">More...</a>
+<p>
+<code>#include &lt;<a class="el" href="RtMidi_8h-source.html">RtMidi.h</a>&gt;</code>
+<p>
+<p>Inheritance diagram for RtMidiIn:
+<p><center><img src="classRtMidiIn.png" usemap="#RtMidiIn_map" border="0" alt=""></center>
+<map name="RtMidiIn_map">
+<area href="classRtMidi.html" alt="RtMidi" shape="rect" coords="0,0,57,24">
+</map>
+<a href="classRtMidiIn-members.html">List of all members.</a><table border=0 cellpadding=0 cellspacing=0>
+<tr><td></td></tr>
+<tr><td colspan=2><br><h2>Public Types</h2></td></tr>
+<tr><td nowrap align=right valign=top><a name="s0" doxytag="RtMidiIn::RtMidiCallback"></a>
+typedef void(*&nbsp;</td><td valign=bottom><a class="el" href="classRtMidiIn.html#s0">RtMidiCallback</a> )(double timeStamp, std::vector&lt; unsigned char &gt; *message, void *userData)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>User callback function type definition.</em></font><br><br></td></tr>
+<tr><td colspan=2><br><h2>Public Member Functions</h2></td></tr>
+<tr><td nowrap align=right valign=top><a name="a0" doxytag="RtMidiIn::RtMidiIn"></a>
+&nbsp;</td><td valign=bottom><a class="el" href="classRtMidiIn.html#a0">RtMidiIn</a> ()</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Default constructor.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top>&nbsp;</td><td valign=bottom><a class="el" href="classRtMidiIn.html#a1">RtMidiIn</a> (unsigned int portNumber, <a class="el" href="classRtMidiIn.html#s0">RtMidiCallback</a> callback=0, void *userData=0)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>An overloaded constructor which can be used to open a MIDI input port during instantiation.</em> <a href="#a1"></a><em></em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="a2" doxytag="RtMidiIn::~RtMidiIn"></a>
+&nbsp;</td><td valign=bottom><a class="el" href="classRtMidiIn.html#a2">~RtMidiIn</a> ()</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>If a MIDI connection is still open, it will be closed by the destructor.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top>void&nbsp;</td><td valign=bottom><a class="el" href="classRtMidiIn.html#a3">openPort</a> (unsigned int portNumber=0, <a class="el" href="classRtMidiIn.html#s0">RtMidiCallback</a> callback=0, void *userData=0)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Open a MIDI input connection and optionally set a user callback function.</em> <a href="#a3"></a><em></em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="a4" doxytag="RtMidiIn::closePort"></a>
+void&nbsp;</td><td valign=bottom><a class="el" href="classRtMidiIn.html#a4">closePort</a> (void)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Close an open MIDI connection (if one exists).</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="a5" doxytag="RtMidiIn::getPortCount"></a>
+unsigned int&nbsp;</td><td valign=bottom><a class="el" href="classRtMidiIn.html#a5">getPortCount</a> ()</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Return the number of available MIDI input ports.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="a6" doxytag="RtMidiIn::getPortName"></a>
+std::string&nbsp;</td><td valign=bottom><a class="el" href="classRtMidiIn.html#a6">getPortName</a> (unsigned int portNumber=0)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Return a string identifier for the specified MIDI input port number.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top>void&nbsp;</td><td valign=bottom><a class="el" href="classRtMidiIn.html#a7">setQueueSizeLimit</a> (unsigned int queueSize)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Set the maximum number of MIDI messages to be saved in the queue.</em> <a href="#a7"></a><em></em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top>void&nbsp;</td><td valign=bottom><a class="el" href="classRtMidiIn.html#a8">ignoreTypes</a> (bool midiSysex=true, bool midiTime=true, bool midiSense=true)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Specify whether certain MIDI message types should be queued or ignored during input.</em> <a href="#a8"></a><em></em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top>double&nbsp;</td><td valign=bottom><a class="el" href="classRtMidiIn.html#a9">getMessage</a> (std::vector&lt; unsigned char &gt; *message)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Fill the user-provided vector with the data bytes for the next available MIDI message in the input queue and return the event delta-time in seconds.</em> <a href="#a9"></a><em></em></font><br><br></td></tr>
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+A realtime MIDI input class.
+<p>
+This class provides a common, platform-independent API for realtime MIDI input. It allows access to a single MIDI input port. Incoming MIDI messages are either saved to a queue for retrieval using the <a class="el" href="classRtMidiIn.html#a9">getMessage()</a> function or immediately passed to a user-specified callback function. Create multiple instances of this class to connect to more than one MIDI device at the same time.<p>
+by Gary P. Scavone, 2003. 
+<p>
+
+<p>
+Definition at line <a class="el" href="RtMidi_8h-source.html#l00053">53</a> of file <a class="el" href="RtMidi_8h-source.html">RtMidi.h</a>.<hr><h2>Constructor &amp; Destructor Documentation</h2>
+<a name="a1" doxytag="RtMidiIn::RtMidiIn"></a><p>
+<table width="100%" cellpadding="2" cellspacing="0" border="0">
+  <tr>
+    <td class="md">
+      <table cellpadding="0" cellspacing="0" border="0">
+        <tr>
+          <td class="md" nowrap valign="top"> RtMidiIn::RtMidiIn </td>
+          <td class="md" valign="top">(&nbsp;</td>
+          <td class="md" nowrap valign="top">unsigned int&nbsp;</td>
+          <td class="mdname" nowrap>&nbsp; <em>portNumber</em>, </td>
+        </tr>
+        <tr>
+          <td></td>
+          <td></td>
+          <td class="md" nowrap><a class="el" href="classRtMidiIn.html#s0">RtMidiCallback</a>&nbsp;</td>
+          <td class="mdname" nowrap>&nbsp; <em>callback</em> = 0, </td>
+        </tr>
+        <tr>
+          <td></td>
+          <td></td>
+          <td class="md" nowrap>void *&nbsp;</td>
+          <td class="mdname" nowrap>&nbsp; <em>userData</em> = 0</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td class="md">)&nbsp;</td>
+          <td class="md" colspan="2"></td>
+        </tr>
+
+      </table>
+    </td>
+  </tr>
+</table>
+<table cellspacing=5 cellpadding=0 border=0>
+  <tr>
+    <td>
+      &nbsp;
+    </td>
+    <td>
+
+<p>
+An overloaded constructor which can be used to open a MIDI input port during instantiation.
+<p>
+If the optional RtMidiCallback argument is non-NULL, the callback function will be invoked whenever MIDI input messages become available. An exception is thrown if an error occurs while attempting to make the port connection. 
+<p>
+Definition at line <a class="el" href="RtMidi_8cpp-source.html#l00040">40</a> of file <a class="el" href="RtMidi_8cpp-source.html">RtMidi.cpp</a>.
+<p>
+References <a class="el" href="classRtMidiIn.html#a3">openPort()</a>.    </td>
+  </tr>
+</table>
+<hr><h2>Member Function Documentation</h2>
+<a name="a3" doxytag="RtMidiIn::openPort"></a><p>
+<table width="100%" cellpadding="2" cellspacing="0" border="0">
+  <tr>
+    <td class="md">
+      <table cellpadding="0" cellspacing="0" border="0">
+        <tr>
+          <td class="md" nowrap valign="top"> void RtMidiIn::openPort </td>
+          <td class="md" valign="top">(&nbsp;</td>
+          <td class="md" nowrap valign="top">unsigned int&nbsp;</td>
+          <td class="mdname" nowrap>&nbsp; <em>portNumber</em> = 0, </td>
+        </tr>
+        <tr>
+          <td></td>
+          <td></td>
+          <td class="md" nowrap><a class="el" href="classRtMidiIn.html#s0">RtMidiCallback</a>&nbsp;</td>
+          <td class="mdname" nowrap>&nbsp; <em>callback</em> = 0, </td>
+        </tr>
+        <tr>
+          <td></td>
+          <td></td>
+          <td class="md" nowrap>void *&nbsp;</td>
+          <td class="mdname" nowrap>&nbsp; <em>userData</em> = 0</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td class="md">)&nbsp;</td>
+          <td class="md" colspan="2"></td>
+        </tr>
+
+      </table>
+    </td>
+  </tr>
+</table>
+<table cellspacing=5 cellpadding=0 border=0>
+  <tr>
+    <td>
+      &nbsp;
+    </td>
+    <td>
+
+<p>
+Open a MIDI input connection and optionally set a user callback function.
+<p>
+An optional port number greater than 0 can be specified. Otherwise, the default or first port found is opened. If the optional RtMidiCallback argument is non-NULL, the callback function will be associated with the port and invoked whenever MIDI input messages become available. An exception is thrown if an error occurs while attempting to make the port connection. 
+<p>
+Referenced by <a class="el" href="RtMidi_8cpp-source.html#l00040">RtMidiIn()</a>.    </td>
+  </tr>
+</table>
+<a name="a7" doxytag="RtMidiIn::setQueueSizeLimit"></a><p>
+<table width="100%" cellpadding="2" cellspacing="0" border="0">
+  <tr>
+    <td class="md">
+      <table cellpadding="0" cellspacing="0" border="0">
+        <tr>
+          <td class="md" nowrap valign="top"> void RtMidiIn::setQueueSizeLimit </td>
+          <td class="md" valign="top">(&nbsp;</td>
+          <td class="md" nowrap valign="top">unsigned int&nbsp;</td>
+          <td class="mdname1" valign="top" nowrap>&nbsp; <em>queueSize</em>          </td>
+          <td class="md" valign="top">)&nbsp;</td>
+          <td class="md" nowrap></td>
+        </tr>
+
+      </table>
+    </td>
+  </tr>
+</table>
+<table cellspacing=5 cellpadding=0 border=0>
+  <tr>
+    <td>
+      &nbsp;
+    </td>
+    <td>
+
+<p>
+Set the maximum number of MIDI messages to be saved in the queue.
+<p>
+If the queue size limit is reached, incoming messages will be ignored. The default limit is 1024.     </td>
+  </tr>
+</table>
+<a name="a8" doxytag="RtMidiIn::ignoreTypes"></a><p>
+<table width="100%" cellpadding="2" cellspacing="0" border="0">
+  <tr>
+    <td class="md">
+      <table cellpadding="0" cellspacing="0" border="0">
+        <tr>
+          <td class="md" nowrap valign="top"> void RtMidiIn::ignoreTypes </td>
+          <td class="md" valign="top">(&nbsp;</td>
+          <td class="md" nowrap valign="top">bool&nbsp;</td>
+          <td class="mdname" nowrap>&nbsp; <em>midiSysex</em> = true, </td>
+        </tr>
+        <tr>
+          <td></td>
+          <td></td>
+          <td class="md" nowrap>bool&nbsp;</td>
+          <td class="mdname" nowrap>&nbsp; <em>midiTime</em> = true, </td>
+        </tr>
+        <tr>
+          <td></td>
+          <td></td>
+          <td class="md" nowrap>bool&nbsp;</td>
+          <td class="mdname" nowrap>&nbsp; <em>midiSense</em> = true</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td class="md">)&nbsp;</td>
+          <td class="md" colspan="2"></td>
+        </tr>
+
+      </table>
+    </td>
+  </tr>
+</table>
+<table cellspacing=5 cellpadding=0 border=0>
+  <tr>
+    <td>
+      &nbsp;
+    </td>
+    <td>
+
+<p>
+Specify whether certain MIDI message types should be queued or ignored during input.
+<p>
+By default, MIDI timing and active sensing messages are ignored during message input because of their relative high data rates. MIDI sysex messages are ignored by default as well. Variable values of "true" imply that the respective message type will be ignored.     </td>
+  </tr>
+</table>
+<a name="a9" doxytag="RtMidiIn::getMessage"></a><p>
+<table width="100%" cellpadding="2" cellspacing="0" border="0">
+  <tr>
+    <td class="md">
+      <table cellpadding="0" cellspacing="0" border="0">
+        <tr>
+          <td class="md" nowrap valign="top"> double RtMidiIn::getMessage </td>
+          <td class="md" valign="top">(&nbsp;</td>
+          <td class="md" nowrap valign="top">std::vector&lt; unsigned char &gt; *&nbsp;</td>
+          <td class="mdname1" valign="top" nowrap>&nbsp; <em>message</em>          </td>
+          <td class="md" valign="top">)&nbsp;</td>
+          <td class="md" nowrap></td>
+        </tr>
+
+      </table>
+    </td>
+  </tr>
+</table>
+<table cellspacing=5 cellpadding=0 border=0>
+  <tr>
+    <td>
+      &nbsp;
+    </td>
+    <td>
+
+<p>
+Fill the user-provided vector with the data bytes for the next available MIDI message in the input queue and return the event delta-time in seconds.
+<p>
+This function returns immediately whether a new message is available or not. A valid message is indicated by a non-zero vector size. An exception is thrown if an error occurs during message retrieval or an input connection was not previously established.     </td>
+  </tr>
+</table>
+<hr>The documentation for this class was generated from the following files:<ul>
+<li><a class="el" href="RtMidi_8h-source.html">RtMidi.h</a><li><a class="el" href="RtMidi_8cpp-source.html">RtMidi.cpp</a></ul>
+<HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/classRtMidiIn.png b/doxygen/html/classRtMidiIn.png
new file mode 100755
index 0000000..224cf6d
--- /dev/null
+++ b/doxygen/html/classRtMidiIn.png
diff --git a/doxygen/html/classRtMidiOut-members.html b/doxygen/html/classRtMidiOut-members.html
new file mode 100755
index 0000000..af47f3d
--- /dev/null
+++ b/doxygen/html/classRtMidiOut-members.html
@@ -0,0 +1,29 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>RtMidiOut Member List</h1>This is the complete list of members for <a class="el" href="classRtMidiOut.html">RtMidiOut</a>, including all inherited members.<table>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtMidiOut.html#a4">closePort</a>()</td><td><a class="el" href="classRtMidiOut.html">RtMidiOut</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtMidiOut.html#a5">getPortCount</a>()</td><td><a class="el" href="classRtMidiOut.html">RtMidiOut</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtMidiOut.html#a6">getPortName</a>(unsigned int portNumber)</td><td><a class="el" href="classRtMidiOut.html">RtMidiOut</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtMidiOut.html#a3">openPort</a>(unsigned int portNumber=0)</td><td><a class="el" href="classRtMidiOut.html">RtMidiOut</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtMidiOut.html#a0">RtMidiOut</a>()</td><td><a class="el" href="classRtMidiOut.html">RtMidiOut</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtMidiOut.html#a1">RtMidiOut</a>(unsigned int portNumber)</td><td><a class="el" href="classRtMidiOut.html">RtMidiOut</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtMidiOut.html#a7">sendMessage</a>(std::vector&lt; unsigned char &gt; *message)</td><td><a class="el" href="classRtMidiOut.html">RtMidiOut</a></td><td></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classRtMidiOut.html#a2">~RtMidiOut</a>()</td><td><a class="el" href="classRtMidiOut.html">RtMidiOut</a></td><td></td></tr>
+</table><HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/classRtMidiOut.html b/doxygen/html/classRtMidiOut.html
new file mode 100755
index 0000000..bb5b0f9
--- /dev/null
+++ b/doxygen/html/classRtMidiOut.html
@@ -0,0 +1,166 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>RtMidiOut Class Reference</h1>A realtime MIDI output class. 
+<a href="#_details">More...</a>
+<p>
+<code>#include &lt;<a class="el" href="RtMidi_8h-source.html">RtMidi.h</a>&gt;</code>
+<p>
+<p>Inheritance diagram for RtMidiOut:
+<p><center><img src="classRtMidiOut.png" usemap="#RtMidiOut_map" border="0" alt=""></center>
+<map name="RtMidiOut_map">
+<area href="classRtMidi.html" alt="RtMidi" shape="rect" coords="0,0,67,24">
+</map>
+<a href="classRtMidiOut-members.html">List of all members.</a><table border=0 cellpadding=0 cellspacing=0>
+<tr><td></td></tr>
+<tr><td colspan=2><br><h2>Public Member Functions</h2></td></tr>
+<tr><td nowrap align=right valign=top><a name="a0" doxytag="RtMidiOut::RtMidiOut"></a>
+&nbsp;</td><td valign=bottom><a class="el" href="classRtMidiOut.html#a0">RtMidiOut</a> ()</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Default constructor.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top>&nbsp;</td><td valign=bottom><a class="el" href="classRtMidiOut.html#a1">RtMidiOut</a> (unsigned int portNumber)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>An overloaded constructor which opens a MIDI output port during instantiation.</em> <a href="#a1"></a><em></em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="a2" doxytag="RtMidiOut::~RtMidiOut"></a>
+&nbsp;</td><td valign=bottom><a class="el" href="classRtMidiOut.html#a2">~RtMidiOut</a> ()</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>The destructor closes any open MIDI connections.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top>void&nbsp;</td><td valign=bottom><a class="el" href="classRtMidiOut.html#a3">openPort</a> (unsigned int portNumber=0)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Open a MIDI output connection.</em> <a href="#a3"></a><em></em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="a4" doxytag="RtMidiOut::closePort"></a>
+void&nbsp;</td><td valign=bottom><a class="el" href="classRtMidiOut.html#a4">closePort</a> ()</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Close an open MIDI connection (if one exists).</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="a5" doxytag="RtMidiOut::getPortCount"></a>
+unsigned int&nbsp;</td><td valign=bottom><a class="el" href="classRtMidiOut.html#a5">getPortCount</a> ()</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Return the number of available MIDI output ports.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="a6" doxytag="RtMidiOut::getPortName"></a>
+std::string&nbsp;</td><td valign=bottom><a class="el" href="classRtMidiOut.html#a6">getPortName</a> (unsigned int portNumber)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Return a string identifier for the specified MIDI port type and number.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top>void&nbsp;</td><td valign=bottom><a class="el" href="classRtMidiOut.html#a7">sendMessage</a> (std::vector&lt; unsigned char &gt; *message)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Immediately send a single message out an open MIDI output port.</em> <a href="#a7"></a><em></em></font><br><br></td></tr>
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+A realtime MIDI output class.
+<p>
+This class provides a common, platform-independent API for MIDI output. It allows one to probe available MIDI output ports, to connect to one such port, and to send MIDI bytes immediately over the connection. Create multiple instances of this class to connect to more than one MIDI device at the same time.<p>
+by Gary P. Scavone, 2003. 
+<p>
+
+<p>
+Definition at line <a class="el" href="RtMidi_8h-source.html#l00170">170</a> of file <a class="el" href="RtMidi_8h-source.html">RtMidi.h</a>.<hr><h2>Constructor &amp; Destructor Documentation</h2>
+<a name="a1" doxytag="RtMidiOut::RtMidiOut"></a><p>
+<table width="100%" cellpadding="2" cellspacing="0" border="0">
+  <tr>
+    <td class="md">
+      <table cellpadding="0" cellspacing="0" border="0">
+        <tr>
+          <td class="md" nowrap valign="top"> RtMidiOut::RtMidiOut </td>
+          <td class="md" valign="top">(&nbsp;</td>
+          <td class="md" nowrap valign="top">unsigned int&nbsp;</td>
+          <td class="mdname1" valign="top" nowrap>&nbsp; <em>portNumber</em>          </td>
+          <td class="md" valign="top">)&nbsp;</td>
+          <td class="md" nowrap></td>
+        </tr>
+
+      </table>
+    </td>
+  </tr>
+</table>
+<table cellspacing=5 cellpadding=0 border=0>
+  <tr>
+    <td>
+      &nbsp;
+    </td>
+    <td>
+
+<p>
+An overloaded constructor which opens a MIDI output port during instantiation.
+<p>
+An exception is thrown if an error occurs while attempting to make the port connection. 
+<p>
+Definition at line <a class="el" href="RtMidi_8cpp-source.html#l00056">56</a> of file <a class="el" href="RtMidi_8cpp-source.html">RtMidi.cpp</a>.
+<p>
+References <a class="el" href="classRtMidiOut.html#a3">openPort()</a>.    </td>
+  </tr>
+</table>
+<hr><h2>Member Function Documentation</h2>
+<a name="a3" doxytag="RtMidiOut::openPort"></a><p>
+<table width="100%" cellpadding="2" cellspacing="0" border="0">
+  <tr>
+    <td class="md">
+      <table cellpadding="0" cellspacing="0" border="0">
+        <tr>
+          <td class="md" nowrap valign="top"> void RtMidiOut::openPort </td>
+          <td class="md" valign="top">(&nbsp;</td>
+          <td class="md" nowrap valign="top">unsigned int&nbsp;</td>
+          <td class="mdname1" valign="top" nowrap>&nbsp; <em>portNumber</em> = 0          </td>
+          <td class="md" valign="top">)&nbsp;</td>
+          <td class="md" nowrap></td>
+        </tr>
+
+      </table>
+    </td>
+  </tr>
+</table>
+<table cellspacing=5 cellpadding=0 border=0>
+  <tr>
+    <td>
+      &nbsp;
+    </td>
+    <td>
+
+<p>
+Open a MIDI output connection.
+<p>
+An optional port number greater than 0 can be specified. Otherwise, the default or first port found is opened. An exception is thrown if an error occurs while attempting to make the port connection. 
+<p>
+Referenced by <a class="el" href="RtMidi_8cpp-source.html#l00056">RtMidiOut()</a>.    </td>
+  </tr>
+</table>
+<a name="a7" doxytag="RtMidiOut::sendMessage"></a><p>
+<table width="100%" cellpadding="2" cellspacing="0" border="0">
+  <tr>
+    <td class="md">
+      <table cellpadding="0" cellspacing="0" border="0">
+        <tr>
+          <td class="md" nowrap valign="top"> void RtMidiOut::sendMessage </td>
+          <td class="md" valign="top">(&nbsp;</td>
+          <td class="md" nowrap valign="top">std::vector&lt; unsigned char &gt; *&nbsp;</td>
+          <td class="mdname1" valign="top" nowrap>&nbsp; <em>message</em>          </td>
+          <td class="md" valign="top">)&nbsp;</td>
+          <td class="md" nowrap></td>
+        </tr>
+
+      </table>
+    </td>
+  </tr>
+</table>
+<table cellspacing=5 cellpadding=0 border=0>
+  <tr>
+    <td>
+      &nbsp;
+    </td>
+    <td>
+
+<p>
+Immediately send a single message out an open MIDI output port.
+<p>
+An exception is thrown if an error occurs during output or an output connection was not previously established.     </td>
+  </tr>
+</table>
+<hr>The documentation for this class was generated from the following files:<ul>
+<li><a class="el" href="RtMidi_8h-source.html">RtMidi.h</a><li><a class="el" href="RtMidi_8cpp-source.html">RtMidi.cpp</a></ul>
+<HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/classRtMidiOut.png b/doxygen/html/classRtMidiOut.png
new file mode 100755
index 0000000..6a41edc
--- /dev/null
+++ b/doxygen/html/classRtMidiOut.png
diff --git a/doxygen/html/classStk-members.html b/doxygen/html/classStk-members.html
new file mode 100755
index 0000000..c38fd67
--- /dev/null
+++ b/doxygen/html/classStk-members.html
@@ -0,0 +1,35 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>Stk Member List</h1>This is the complete list of members for <a class="el" href="classStk.html">Stk</a>, including all inherited members.<table>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#e0">handleError</a>(const std::string &amp;message, StkError::Type type)</td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [protected, static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#d2">rawwavePath</a>(void)</td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [inline, static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#d0">sampleRate</a>(void)</td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [inline, static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#d3">setRawwavePath</a>(std::string path)</td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#d1">setSampleRate</a>(StkFloat rate)</td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [inline, static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#d7">sleep</a>(unsigned long milliseconds)</td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#p3">STK_FLOAT32</a></td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#p4">STK_FLOAT64</a></td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#p1">STK_SINT16</a></td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#p2">STK_SINT32</a></td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#p0">STK_SINT8</a></td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#d4">swap16</a>(unsigned char *ptr)</td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#d5">swap32</a>(unsigned char *ptr)</td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [static]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStk.html#d6">swap64</a>(unsigned char *ptr)</td><td><a class="el" href="classStk.html">Stk</a></td><td><code> [static]</code></td></tr>
+</table><HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/classStk.html b/doxygen/html/classStk.html
new file mode 100755
index 0000000..f3cf78f
--- /dev/null
+++ b/doxygen/html/classStk.html
@@ -0,0 +1,232 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>Stk Class Reference</h1>STK base class. 
+<a href="#_details">More...</a>
+<p>
+<code>#include &lt;<a class="el" href="Stk_8h-source.html">Stk.h</a>&gt;</code>
+<p>
+<p>Inheritance diagram for Stk:
+<p><center><img src="classStk.png" usemap="#Stk_map" border="0" alt=""></center>
+<map name="Stk_map">
+<area href="classMidiFileIn.html" alt="MidiFileIn" shape="rect" coords="0,56,67,80">
+</map>
+<a href="classStk-members.html">List of all members.</a><table border=0 cellpadding=0 cellspacing=0>
+<tr><td></td></tr>
+<tr><td colspan=2><br><h2>Static Public Member Functions</h2></td></tr>
+<tr><td nowrap align=right valign=top><a name="d0" doxytag="Stk::sampleRate"></a>
+StkFloat&nbsp;</td><td valign=bottom><a class="el" href="classStk.html#d0">sampleRate</a> (void)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Static method which returns the current STK sample rate.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top>void&nbsp;</td><td valign=bottom><a class="el" href="classStk.html#d1">setSampleRate</a> (StkFloat rate)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Static method which sets the STK sample rate.</em> <a href="#d1"></a><em></em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="d2" doxytag="Stk::rawwavePath"></a>
+std::string&nbsp;</td><td valign=bottom><a class="el" href="classStk.html#d2">rawwavePath</a> (void)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Static method which returns the current rawwave path.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="d3" doxytag="Stk::setRawwavePath"></a>
+void&nbsp;</td><td valign=bottom><a class="el" href="classStk.html#d3">setRawwavePath</a> (std::string path)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Static method which sets the STK rawwave path.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="d4" doxytag="Stk::swap16"></a>
+void&nbsp;</td><td valign=bottom><a class="el" href="classStk.html#d4">swap16</a> (unsigned char *ptr)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Static method which byte-swaps a 16-bit data type.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="d5" doxytag="Stk::swap32"></a>
+void&nbsp;</td><td valign=bottom><a class="el" href="classStk.html#d5">swap32</a> (unsigned char *ptr)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Static method which byte-swaps a 32-bit data type.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="d6" doxytag="Stk::swap64"></a>
+void&nbsp;</td><td valign=bottom><a class="el" href="classStk.html#d6">swap64</a> (unsigned char *ptr)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Static method which byte-swaps a 64-bit data type.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="d7" doxytag="Stk::sleep"></a>
+void&nbsp;</td><td valign=bottom><a class="el" href="classStk.html#d7">sleep</a> (unsigned long milliseconds)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Static cross-platform method to sleep for a number of milliseconds.</em></font><br><br></td></tr>
+<tr><td colspan=2><br><h2>Static Public Attributes</h2></td></tr>
+<tr><td nowrap align=right valign=top>const StkFormat&nbsp;</td><td valign=bottom><a class="el" href="classStk.html#p0">STK_SINT8</a> = 1</td></tr>
+<tr><td nowrap align=right valign=top>const StkFormat&nbsp;</td><td valign=bottom><a class="el" href="classStk.html#p1">STK_SINT16</a> = 2</td></tr>
+<tr><td nowrap align=right valign=top>const StkFormat&nbsp;</td><td valign=bottom><a class="el" href="classStk.html#p2">STK_SINT32</a> = 8</td></tr>
+<tr><td nowrap align=right valign=top>const StkFormat&nbsp;</td><td valign=bottom><a class="el" href="classStk.html#p3">STK_FLOAT32</a> = 16</td></tr>
+<tr><td nowrap align=right valign=top>const StkFormat&nbsp;</td><td valign=bottom><a class="el" href="classStk.html#p4">STK_FLOAT64</a> = 32</td></tr>
+<tr><td colspan=2><br><h2>Static Protected Member Functions</h2></td></tr>
+<tr><td nowrap align=right valign=top><a name="e0" doxytag="Stk::handleError"></a>
+void&nbsp;</td><td valign=bottom><a class="el" href="classStk.html#e0">handleError</a> (const std::string &amp;message, StkError::Type type)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Function for error reporting and handling.</em></font><br><br></td></tr>
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+STK base class.
+<p>
+Nearly all STK classes inherit from this class. The global sample rate can be queried and modified via Stk. In addition, this class provides error handling and byte-swapping functions.<p>
+by Perry R. Cook and Gary P. Scavone, 1995 - 2003. 
+<p>
+
+<p>
+Definition at line <a class="el" href="Stk_8h-source.html#l00072">72</a> of file <a class="el" href="Stk_8h-source.html">Stk.h</a>.<hr><h2>Member Function Documentation</h2>
+<a name="d1" doxytag="Stk::setSampleRate"></a><p>
+<table width="100%" cellpadding="2" cellspacing="0" border="0">
+  <tr>
+    <td class="md">
+      <table cellpadding="0" cellspacing="0" border="0">
+        <tr>
+          <td class="md" nowrap valign="top"> void Stk::setSampleRate </td>
+          <td class="md" valign="top">(&nbsp;</td>
+          <td class="md" nowrap valign="top">StkFloat&nbsp;</td>
+          <td class="mdname1" valign="top" nowrap>&nbsp; <em>rate</em>          </td>
+          <td class="md" valign="top">)&nbsp;</td>
+          <td class="md" nowrap><code> [inline, static]</code></td>
+        </tr>
+
+      </table>
+    </td>
+  </tr>
+</table>
+<table cellspacing=5 cellpadding=0 border=0>
+  <tr>
+    <td>
+      &nbsp;
+    </td>
+    <td>
+
+<p>
+Static method which sets the STK sample rate.
+<p>
+The sample rate set using this method is queried by all STK classes which depend on its value. It is initialized to the default SRATE set in <a class="el" href="Stk_8h.html">Stk.h</a>. Many STK classes use the sample rate during instantiation. Therefore, if you wish to use a rate which is different from the default rate, it is imperative that it be set <em>BEFORE</em> STK objects are instantiated. 
+<p>
+Definition at line <a class="el" href="Stk_8h-source.html#l00095">95</a> of file <a class="el" href="Stk_8h-source.html">Stk.h</a>.    </td>
+  </tr>
+</table>
+<hr><h2>Member Data Documentation</h2>
+<a name="p0" doxytag="Stk::STK_SINT8"></a><p>
+<table width="100%" cellpadding="2" cellspacing="0" border="0">
+  <tr>
+    <td class="md">
+      <table cellpadding="0" cellspacing="0" border="0">
+        <tr>
+          <td class="md" nowrap valign="top"> const Stk::StkFormat Stk::STK_SINT8 = 1<code> [static]</code>
+      </table>
+    </td>
+  </tr>
+</table>
+<table cellspacing=5 cellpadding=0 border=0>
+  <tr>
+    <td>
+      &nbsp;
+    </td>
+    <td>
+
+<p>
+-128 to +127 
+<p>
+Definition at line <a class="el" href="Stk_8cpp-source.html#l00019">19</a> of file <a class="el" href="Stk_8cpp-source.html">Stk.cpp</a>.    </td>
+  </tr>
+</table>
+<a name="p1" doxytag="Stk::STK_SINT16"></a><p>
+<table width="100%" cellpadding="2" cellspacing="0" border="0">
+  <tr>
+    <td class="md">
+      <table cellpadding="0" cellspacing="0" border="0">
+        <tr>
+          <td class="md" nowrap valign="top"> const Stk::StkFormat Stk::STK_SINT16 = 2<code> [static]</code>
+      </table>
+    </td>
+  </tr>
+</table>
+<table cellspacing=5 cellpadding=0 border=0>
+  <tr>
+    <td>
+      &nbsp;
+    </td>
+    <td>
+
+<p>
+-32768 to +32767 
+<p>
+Definition at line <a class="el" href="Stk_8cpp-source.html#l00020">20</a> of file <a class="el" href="Stk_8cpp-source.html">Stk.cpp</a>.    </td>
+  </tr>
+</table>
+<a name="p2" doxytag="Stk::STK_SINT32"></a><p>
+<table width="100%" cellpadding="2" cellspacing="0" border="0">
+  <tr>
+    <td class="md">
+      <table cellpadding="0" cellspacing="0" border="0">
+        <tr>
+          <td class="md" nowrap valign="top"> const Stk::StkFormat Stk::STK_SINT32 = 8<code> [static]</code>
+      </table>
+    </td>
+  </tr>
+</table>
+<table cellspacing=5 cellpadding=0 border=0>
+  <tr>
+    <td>
+      &nbsp;
+    </td>
+    <td>
+
+<p>
+-2147483648 to +2147483647. 
+<p>
+Definition at line <a class="el" href="Stk_8cpp-source.html#l00021">21</a> of file <a class="el" href="Stk_8cpp-source.html">Stk.cpp</a>.    </td>
+  </tr>
+</table>
+<a name="p3" doxytag="Stk::STK_FLOAT32"></a><p>
+<table width="100%" cellpadding="2" cellspacing="0" border="0">
+  <tr>
+    <td class="md">
+      <table cellpadding="0" cellspacing="0" border="0">
+        <tr>
+          <td class="md" nowrap valign="top"> const Stk::StkFormat Stk::STK_FLOAT32 = 16<code> [static]</code>
+      </table>
+    </td>
+  </tr>
+</table>
+<table cellspacing=5 cellpadding=0 border=0>
+  <tr>
+    <td>
+      &nbsp;
+    </td>
+    <td>
+
+<p>
+Normalized between plus/minus 1.0. 
+<p>
+Definition at line <a class="el" href="Stk_8cpp-source.html#l00022">22</a> of file <a class="el" href="Stk_8cpp-source.html">Stk.cpp</a>.    </td>
+  </tr>
+</table>
+<a name="p4" doxytag="Stk::STK_FLOAT64"></a><p>
+<table width="100%" cellpadding="2" cellspacing="0" border="0">
+  <tr>
+    <td class="md">
+      <table cellpadding="0" cellspacing="0" border="0">
+        <tr>
+          <td class="md" nowrap valign="top"> const Stk::StkFormat Stk::STK_FLOAT64 = 32<code> [static]</code>
+      </table>
+    </td>
+  </tr>
+</table>
+<table cellspacing=5 cellpadding=0 border=0>
+  <tr>
+    <td>
+      &nbsp;
+    </td>
+    <td>
+
+<p>
+Normalized between plus/minus 1.0. 
+<p>
+Definition at line <a class="el" href="Stk_8cpp-source.html#l00023">23</a> of file <a class="el" href="Stk_8cpp-source.html">Stk.cpp</a>.    </td>
+  </tr>
+</table>
+<hr>The documentation for this class was generated from the following files:<ul>
+<li><a class="el" href="Stk_8h-source.html">Stk.h</a><li><a class="el" href="Stk_8cpp-source.html">Stk.cpp</a></ul>
+<HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/classStk.png b/doxygen/html/classStk.png
new file mode 100755
index 0000000..84495a3
--- /dev/null
+++ b/doxygen/html/classStk.png
diff --git a/doxygen/html/classStkError-members.html b/doxygen/html/classStkError-members.html
new file mode 100755
index 0000000..97d7df0
--- /dev/null
+++ b/doxygen/html/classStkError-members.html
@@ -0,0 +1,26 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>StkError Member List</h1>This is the complete list of members for <a class="el" href="classStkError.html">StkError</a>, including all inherited members.<table>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStkError.html#a4">getMessage</a>(void)</td><td><a class="el" href="classStkError.html">StkError</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStkError.html#a3">getType</a>(void)</td><td><a class="el" href="classStkError.html">StkError</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStkError.html#a2">printMessage</a>(void)</td><td><a class="el" href="classStkError.html">StkError</a></td><td><code> [inline, virtual]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStkError.html#a0">StkError</a>(const std::string &amp;message, Type type=StkError::UNSPECIFIED)</td><td><a class="el" href="classStkError.html">StkError</a></td><td><code> [inline]</code></td></tr>
+  <tr bgcolor="#f0f0f0"><td><a class="el" href="classStkError.html#a1">~StkError</a>(void)</td><td><a class="el" href="classStkError.html">StkError</a></td><td><code> [inline, virtual]</code></td></tr>
+</table><HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/classStkError.html b/doxygen/html/classStkError.html
new file mode 100755
index 0000000..cfdb29f
--- /dev/null
+++ b/doxygen/html/classStkError.html
@@ -0,0 +1,53 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>StkError Class Reference</h1>STK error handling class. 
+<a href="#_details">More...</a>
+<p>
+<code>#include &lt;<a class="el" href="Stk_8h-source.html">Stk.h</a>&gt;</code>
+<p>
+<a href="classStkError-members.html">List of all members.</a><table border=0 cellpadding=0 cellspacing=0>
+<tr><td></td></tr>
+<tr><td colspan=2><br><h2>Public Member Functions</h2></td></tr>
+<tr><td nowrap align=right valign=top><a name="a0" doxytag="StkError::StkError"></a>
+&nbsp;</td><td valign=bottom><a class="el" href="classStkError.html#a0">StkError</a> (const std::string &amp;message, Type type=StkError::UNSPECIFIED)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>The constructor.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="a1" doxytag="StkError::~StkError"></a>
+virtual&nbsp;</td><td valign=bottom><a class="el" href="classStkError.html#a1">~StkError</a> (void)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>The destructor.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="a2" doxytag="StkError::printMessage"></a>
+virtual void&nbsp;</td><td valign=bottom><a class="el" href="classStkError.html#a2">printMessage</a> (void)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Prints "thrown" error message to stdout.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="a3" doxytag="StkError::getType"></a>
+virtual const Type &amp;&nbsp;</td><td valign=bottom><a class="el" href="classStkError.html#a3">getType</a> (void)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Returns the "thrown" error message type.</em></font><br><br></td></tr>
+<tr><td nowrap align=right valign=top><a name="a4" doxytag="StkError::getMessage"></a>
+virtual const std::string &amp;&nbsp;</td><td valign=bottom><a class="el" href="classStkError.html#a4">getMessage</a> (void)</td></tr>
+<tr><td>&nbsp;</td><td><font size=-1><em>Returns the "thrown" error message string.</em></font><br><br></td></tr>
+</table>
+<hr><a name="_details"></a><h2>Detailed Description</h2>
+STK error handling class.
+<p>
+This is a fairly abstract exception handling class. There could be sub-classes to take care of more specific error conditions ... or not. 
+<p>
+
+<p>
+Definition at line <a class="el" href="Stk_8h-source.html#l00033">33</a> of file <a class="el" href="Stk_8h-source.html">Stk.h</a>.<hr>The documentation for this class was generated from the following file:<ul>
+<li><a class="el" href="Stk_8h-source.html">Stk.h</a></ul>
+<HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/doxygen.css b/doxygen/html/doxygen.css
new file mode 100755
index 0000000..96680fb
--- /dev/null
+++ b/doxygen/html/doxygen.css
@@ -0,0 +1,49 @@
+H1 { text-align: center; }
+CAPTION { font-weight: bold }
+A.qindex {}
+A.qindexRef {}
+A.el { text-decoration: none; font-weight: bold }
+A.elRef { font-weight: bold }
+A.code { text-decoration: none; font-weight: normal; color: #4444ee }
+A.codeRef { font-weight: normal; color: #4444ee }
+A:hover { text-decoration: none; background-color: #f2f2ff }
+DL.el { margin-left: -1cm }
+DIV.fragment { width: 100%; border: none; background-color: #eeeeee }
+DIV.ah { background-color: black; font-weight: bold; color: #ffffff; margin-bottom: 3px; margin-top: 3px }
+TD.md { background-color: #f2f2ff; font-weight: bold; }
+TD.mdname1 { background-color: #f2f2ff; font-weight: bold; color: #602020; }
+TD.mdname { background-color: #f2f2ff; font-weight: bold; color: #602020; width: 600px; }
+DIV.groupHeader { margin-left: 16px; margin-top: 12px; margin-bottom: 6px; font-weight: bold }
+DIV.groupText { margin-left: 16px; font-style: italic; font-size: smaller }
+BODY { background: white; color: black }
+TD.indexkey { 
+   background-color: #eeeeff; 
+   font-weight: bold; 
+   padding-right  : 10px; 
+   padding-top    : 2px; 
+   padding-left   : 10px; 
+   padding-bottom : 2px; 
+   margin-left    : 0px; 
+   margin-right   : 0px; 
+   margin-top     : 2px; 
+   margin-bottom  : 2px  
+}
+TD.indexvalue { 
+   background-color: #eeeeff; 
+   font-style: italic; 
+   padding-right  : 10px; 
+   padding-top    : 2px; 
+   padding-left   : 10px; 
+   padding-bottom : 2px; 
+   margin-left    : 0px; 
+   margin-right   : 0px; 
+   margin-top     : 2px; 
+   margin-bottom  : 2px  
+}
+span.keyword       { color: #008000 }
+span.keywordtype   { color: #604020 }
+span.keywordflow   { color: #e08000 }
+span.comment       { color: #800000 }
+span.preprocessor  { color: #806020 }
+span.stringliteral { color: #002080 }
+span.charliteral   { color: #008080 }
diff --git a/doxygen/html/doxygen.png b/doxygen/html/doxygen.png
new file mode 100755
index 0000000..96ae72c
--- /dev/null
+++ b/doxygen/html/doxygen.png
diff --git a/doxygen/html/files.html b/doxygen/html/files.html
new file mode 100755
index 0000000..981655b
--- /dev/null
+++ b/doxygen/html/files.html
@@ -0,0 +1,32 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>STK File List</h1>Here is a list of all documented files with brief descriptions:<table>
+  <tr><td class="indexkey"><b>MidiFileIn.cpp</b> <a href="MidiFileIn_8cpp-source.html">[code]</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><b>MidiFileIn.h</b> <a href="MidiFileIn_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><b>midiin.cpp</b> <a href="midiin_8cpp-source.html">[code]</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><b>miditime.cpp</b> <a href="miditime_8cpp-source.html">[code]</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><b>playsmf.cpp</b> <a href="playsmf_8cpp-source.html">[code]</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><b>RtError.h</b> <a href="RtError_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><b>RtMidi.cpp</b> <a href="RtMidi_8cpp-source.html">[code]</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><b>RtMidi.h</b> <a href="RtMidi_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><b>Stk.cpp</b> <a href="Stk_8cpp-source.html">[code]</a></td><td class="indexvalue"></td></tr>
+  <tr><td class="indexkey"><b>Stk.h</b> <a href="Stk_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr>
+</table>
+<HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/functions.html b/doxygen/html/functions.html
new file mode 100755
index 0000000..48492e2
--- /dev/null
+++ b/doxygen/html/functions.html
@@ -0,0 +1,65 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>STK Compound Members</h1>Here is a list of all documented class members with links to the class documentation for each member:<ul>
+<li>closePort()
+: <a class="el" href="classRtMidiOut.html#a4">RtMidiOut</a>, <a class="el" href="classRtMidiIn.html#a4">RtMidiIn</a><li>getDivision()
+: <a class="el" href="classMidiFileIn.html#a4">MidiFileIn</a><li>getFileFormat()
+: <a class="el" href="classMidiFileIn.html#a2">MidiFileIn</a><li>getMessage()
+: <a class="el" href="classStkError.html#a4">StkError</a>, <a class="el" href="classRtMidiIn.html#a9">RtMidiIn</a>, <a class="el" href="classRtError.html#a4">RtError</a><li>getNextEvent()
+: <a class="el" href="classMidiFileIn.html#a7">MidiFileIn</a><li>getNextMidiEvent()
+: <a class="el" href="classMidiFileIn.html#a8">MidiFileIn</a><li>getNumberOfTracks()
+: <a class="el" href="classMidiFileIn.html#a3">MidiFileIn</a><li>getPortCount()
+: <a class="el" href="classRtMidiOut.html#a5">RtMidiOut</a>, <a class="el" href="classRtMidiIn.html#a5">RtMidiIn</a><li>getPortName()
+: <a class="el" href="classRtMidiOut.html#a6">RtMidiOut</a>, <a class="el" href="classRtMidiIn.html#a6">RtMidiIn</a><li>getTickSeconds()
+: <a class="el" href="classMidiFileIn.html#a6">MidiFileIn</a><li>getType()
+: <a class="el" href="classStkError.html#a3">StkError</a>, <a class="el" href="classRtError.html#a3">RtError</a><li>handleError()
+: <a class="el" href="classStk.html#e0">Stk</a><li>ignoreTypes()
+: <a class="el" href="classRtMidiIn.html#a8">RtMidiIn</a><li>MidiFileIn()
+: <a class="el" href="classMidiFileIn.html#a0">MidiFileIn</a><li>openPort()
+: <a class="el" href="classRtMidiOut.html#a3">RtMidiOut</a>, <a class="el" href="classRtMidiIn.html#a3">RtMidiIn</a><li>printMessage()
+: <a class="el" href="classStkError.html#a2">StkError</a>, <a class="el" href="classRtError.html#a2">RtError</a><li>rawwavePath()
+: <a class="el" href="classStk.html#d2">Stk</a><li>rewindTrack()
+: <a class="el" href="classMidiFileIn.html#a5">MidiFileIn</a><li>RtError()
+: <a class="el" href="classRtError.html#a0">RtError</a><li>RtMidiCallback
+: <a class="el" href="classRtMidiIn.html#s0">RtMidiIn</a><li>RtMidiIn()
+: <a class="el" href="classRtMidiIn.html#a1">RtMidiIn</a><li>RtMidiOut()
+: <a class="el" href="classRtMidiOut.html#a1">RtMidiOut</a><li>sampleRate()
+: <a class="el" href="classStk.html#d0">Stk</a><li>sendMessage()
+: <a class="el" href="classRtMidiOut.html#a7">RtMidiOut</a><li>setQueueSizeLimit()
+: <a class="el" href="classRtMidiIn.html#a7">RtMidiIn</a><li>setRawwavePath()
+: <a class="el" href="classStk.html#d3">Stk</a><li>setSampleRate()
+: <a class="el" href="classStk.html#d1">Stk</a><li>sleep()
+: <a class="el" href="classStk.html#d7">Stk</a><li>STK_FLOAT32
+: <a class="el" href="classStk.html#p3">Stk</a><li>STK_FLOAT64
+: <a class="el" href="classStk.html#p4">Stk</a><li>STK_SINT16
+: <a class="el" href="classStk.html#p1">Stk</a><li>STK_SINT32
+: <a class="el" href="classStk.html#p2">Stk</a><li>STK_SINT8
+: <a class="el" href="classStk.html#p0">Stk</a><li>StkError()
+: <a class="el" href="classStkError.html#a0">StkError</a><li>swap16()
+: <a class="el" href="classStk.html#d4">Stk</a><li>swap32()
+: <a class="el" href="classStk.html#d5">Stk</a><li>swap64()
+: <a class="el" href="classStk.html#d6">Stk</a><li>Type
+: <a class="el" href="classRtError.html#s11">RtError</a><li>~MidiFileIn()
+: <a class="el" href="classMidiFileIn.html#a1">MidiFileIn</a><li>~RtError()
+: <a class="el" href="classRtError.html#a1">RtError</a><li>~RtMidiIn()
+: <a class="el" href="classRtMidiIn.html#a2">RtMidiIn</a><li>~RtMidiOut()
+: <a class="el" href="classRtMidiOut.html#a2">RtMidiOut</a><li>~StkError()
+: <a class="el" href="classStkError.html#a1">StkError</a></ul>
+<HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/hierarchy.html b/doxygen/html/hierarchy.html
new file mode 100755
index 0000000..3f2be16
--- /dev/null
+++ b/doxygen/html/hierarchy.html
@@ -0,0 +1,33 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>STK Class Hierarchy</h1>This inheritance list is sorted roughly, but not completely, alphabetically:<ul>
+<li><a class="el" href="classRtError.html">RtError</a>
+<li><a class="el" href="classRtMidi.html">RtMidi</a>
+<ul>
+<li><a class="el" href="classRtMidiIn.html">RtMidiIn</a>
+<li><a class="el" href="classRtMidiOut.html">RtMidiOut</a>
+</ul>
+<li><a class="el" href="classStk.html">Stk</a>
+<ul>
+<li><a class="el" href="classMidiFileIn.html">MidiFileIn</a>
+</ul>
+<li><a class="el" href="classStkError.html">StkError</a>
+</ul>
+<HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/index.html b/doxygen/html/index.html
new file mode 100755
index 0000000..e68c218
--- /dev/null
+++ b/doxygen/html/index.html
@@ -0,0 +1,24 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>STK Documentation</h1>
+<p>
+<ul>
+<li><a class="qindex" href="index.html">Main Page</a> &nbsp; <li><a class="qindex" href="hierarchy.html">Class Hierarchy</a> &nbsp; <li><a class="qindex" href="annotated.html">Compound List</a> &nbsp; <li><a class="qindex" href="files.html">File List</a> &nbsp; <li><a class="qindex" href="functions.html">Compound Members</a> &nbsp; </ul>
+<HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/midiin_8cpp-source.html b/doxygen/html/midiin_8cpp-source.html
new file mode 100755
index 0000000..267d6fb
--- /dev/null
+++ b/doxygen/html/midiin_8cpp-source.html
@@ -0,0 +1,83 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>midiin.cpp</h1><div class="fragment"><pre>00001 <span class="comment">// midiin.cpp</span>
+00002 <span class="comment">//</span>
+00003 <span class="comment">// Simple program to read MIDI input from default port.</span>
+00004 <span class="comment">//</span>
+00005 <span class="comment">// by Gary Scavone, 2003.</span>
+00006 <span class="comment">//</span>
+00007 <span class="comment">// compile: g++ -Wall -D__MACOSX_CORE__ -o midiin midiin.cpp RtMidi.cpp Stk.cpp -framework CoreMIDI -framework CoreFoundation -framework CoreAudio</span>
+00008 
+00009 <span class="preprocessor">#include &lt;iostream&gt;</span>
+00010 <span class="preprocessor">#include &lt;unistd.h&gt;</span>
+00011 <span class="preprocessor">#include &lt;signal.h&gt;</span>
+00012 <span class="preprocessor">#include "RtMidi.h"</span>
+00013 
+00014 <span class="keywordtype">bool</span> done;
+00015 <span class="keyword">static</span> <span class="keywordtype">void</span> finish(<span class="keywordtype">int</span> ignore){ done = <span class="keyword">true</span>; }
+00016 
+00017 <span class="keywordtype">int</span> main()
+00018 {
+00019   <span class="keyword">using</span> <span class="keyword">namespace </span>std;
+00020   <a class="code" href="classRtMidiIn.html">RtMidiIn</a> midi;
+00021   std::vector&lt;unsigned char&gt; message;
+00022 
+00023   <span class="keywordflow">if</span> ( midi.<a class="code" href="classRtMidiIn.html#a5">getPortCount</a>() &lt; 1 ) {
+00024     cout &lt;&lt; <span class="stringliteral">"\nThere are no MIDI input sources available!\n"</span>;
+00025     exit(0);
+00026   }
+00027 
+00028   <span class="keywordflow">try</span> {
+00029     midi.<a class="code" href="classRtMidiIn.html#a3">openPort</a>();
+00030   }
+00031   <span class="keywordflow">catch</span> ( <a class="code" href="classRtError.html">RtError</a> &amp; ) {
+00032     <span class="comment">// You might want to do something more useful here.</span>
+00033     cout &lt;&lt; <span class="stringliteral">"\nAborting program!\n"</span>;
+00034     <span class="keywordflow">goto</span> cleanup;
+00035   }
+00036 
+00037   <span class="comment">// Install an interrupt handler function.</span>
+00038   (void) signal(SIGINT, finish);
+00039 
+00040   <span class="keywordtype">int</span> nBytes, i, value;
+00041   <span class="keywordtype">double</span> stamp;
+00042   done = <span class="keyword">false</span>;
+00043   cout &lt;&lt; <span class="stringliteral">"Reading MIDI from default port ..."</span> &lt;&lt; endl;
+00044   <span class="keywordflow">while</span> ( !done ) {
+00045     stamp = midi.<a class="code" href="classRtMidiIn.html#a9">getMessage</a>( &amp;message );
+00046     nBytes = message.size();
+00047     <span class="keywordflow">for</span> ( i=0; i&lt;nBytes; i++ ) {
+00048       value = message[i];
+00049       cout &lt;&lt; <span class="stringliteral">"Byte "</span> &lt;&lt; i &lt;&lt; <span class="stringliteral">" = "</span> &lt;&lt; value &lt;&lt; <span class="stringliteral">", "</span>;
+00050     }
+00051     <span class="keywordflow">if</span> ( nBytes &gt; 0 )
+00052       cout &lt;&lt; <span class="stringliteral">"stamp = "</span> &lt;&lt; stamp &lt;&lt; <span class="charliteral">'\n'</span>;
+00053 
+00054     <span class="comment">// Sleep for 10 milliseconds.</span>
+00055     usleep( 10000 );
+00056   }
+00057 
+00058   cout &lt;&lt; <span class="stringliteral">"Goodbye!"</span> &lt;&lt; endl;
+00059 
+00060  cleanup:
+00061   midi.<a class="code" href="classRtMidiIn.html#a4">closePort</a>();
+00062   <span class="keywordflow">return</span> 0;
+00063 }
+</pre></div><HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/miditime_8cpp-source.html b/doxygen/html/miditime_8cpp-source.html
new file mode 100755
index 0000000..cf274e6
--- /dev/null
+++ b/doxygen/html/miditime_8cpp-source.html
@@ -0,0 +1,93 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>miditime.cpp</h1><div class="fragment"><pre>00001 <span class="comment">// miditime.cpp</span>
+00002 <span class="comment">//</span>
+00003 <span class="comment">// Simple program to output MIDI to the default port.</span>
+00004 <span class="comment">//</span>
+00005 <span class="comment">// by Gary Scavone, 2003.</span>
+00006 <span class="comment">//</span>
+00007 <span class="comment">// compile: g++ -Wall -o miditime miditime.cpp RtMidi.cpp -framework CoreMIDI -framework CoreFoundation -framework CoreAudio</span>
+00008 
+00009 <span class="preprocessor">#include &lt;iostream&gt;</span>
+00010 <span class="preprocessor">#include &lt;unistd.h&gt;</span>
+00011 <span class="preprocessor">#include &lt;signal.h&gt;</span>
+00012 <span class="preprocessor">#include "RtMidi.h"</span>
+00013 
+00014 <span class="keywordtype">bool</span> done;
+00015 <span class="keyword">static</span> <span class="keywordtype">void</span> finish(<span class="keywordtype">int</span> ignore){ done = <span class="keyword">true</span>; }
+00016 
+00017 <span class="keywordtype">int</span> main()
+00018 {
+00019   <span class="keyword">using</span> <span class="keyword">namespace </span>std;
+00020   <a class="code" href="classRtMidi.html">RtMidi</a> midi( RtMidi::ABSOLUTE_TIME );
+00021 
+00022   <span class="keywordflow">if</span> ( midi.getPortCount( RtMidi::MIDI_OUTPUT ) &lt; 1 ) {
+00023     cout &lt;&lt; <span class="stringliteral">"\nThere are no MIDI output destinations available!\n"</span>;
+00024     exit(0);
+00025   }
+00026 
+00027   <span class="keywordflow">try</span> {
+00028     midi.openPort( RtMidi::MIDI_OUTPUT );
+00029   }
+00030   <span class="keywordflow">catch</span> ( <a class="code" href="classRtError.html">RtError</a> &amp; ) {
+00031     <span class="comment">// You might want to do something more useful here.</span>
+00032     cout &lt;&lt; <span class="stringliteral">"\nAborting program!\n"</span>;
+00033     midi.closePort();
+00034     exit(0);
+00035   }
+00036 
+00037   <span class="comment">// Install an interrupt handler function.</span>
+00038   (void) signal(SIGINT, finish);
+00039 
+00040   RtMidi::MidiMessage message;
+00041   message.bytes.push_back( 144 );
+00042   message.bytes.push_back( 64 );
+00043   message.bytes.push_back( 80 );
+00044 
+00045   cout &lt;&lt; <span class="stringliteral">"Scheduling for 1 second later ..."</span> &lt;&lt; endl;
+00046   timeval tvTime;
+00047   <span class="keywordflow">if</span> ( gettimeofday( &amp;tvTime, NULL ) == 0 ) {
+00048     message.timeStamp = (double) tvTime.tv_sec + 1.0;
+00049     message.timeStamp += (double) (tvTime.tv_usec * 0.000001);
+00050   }
+00051   <span class="comment">//message.timeStamp = 1.0;</span>
+00052   midi.sendMessage( &amp;message );
+00053 
+00054   <span class="comment">// Sleep for 0.5 seconds.</span>
+00055   usleep( 1000000 );
+00056 
+00057   cout &lt;&lt; <span class="stringliteral">"1 second has passed ..."</span> &lt;&lt; endl;
+00058 
+00059   <span class="comment">// Sleep another 1.0 seconds.</span>
+00060   usleep( 1000000 );
+00061 
+00062   cout &lt;&lt; <span class="stringliteral">"Turning note off ... "</span>;
+00063 
+00064   <span class="comment">// Turn the note off.</span>
+00065   message.timeStamp = 0.0;
+00066   message.bytes[2] = 0;
+00067   midi.sendMessage( &amp;message );
+00068 
+00069   midi.closePort();
+00070 
+00071   cout &lt;&lt; <span class="stringliteral">"Goodbye!"</span> &lt;&lt; endl;
+00072   <span class="keywordflow">return</span> 0;
+00073 }
+</pre></div><HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/newRtMidi_8h-source.html b/doxygen/html/newRtMidi_8h-source.html
new file mode 100755
index 0000000..971238f
--- /dev/null
+++ b/doxygen/html/newRtMidi_8h-source.html
@@ -0,0 +1,148 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>newRtMidi.h</h1><div class="fragment"><pre>00001 <span class="comment">/**********************************************************************/</span>
+00012 <span class="comment">/**********************************************************************/</span>
+00013 
+00014 <span class="preprocessor">#ifndef RTMIDI_H</span>
+00015 <span class="preprocessor"></span><span class="preprocessor">#define RTMIDI_H</span>
+00016 <span class="preprocessor"></span>
+00017 <span class="preprocessor">#include &lt;vector&gt;</span>
+00018 <span class="preprocessor">#include &lt;string&gt;</span>
+00019 <span class="preprocessor">#include "RtError.h"</span>
+00020 
+00021 <span class="comment">// Operating system dependent thread functionality.</span>
+00022 <span class="preprocessor">#if defined(__WINDOWS_DS__) || defined(__WINDOWS_ASIO__)</span>
+00023 <span class="preprocessor"></span><span class="preprocessor">  #include &lt;windows.h&gt;</span>
+00024 <span class="preprocessor">  #include &lt;process.h&gt;</span>
+00025 
+00026   <span class="keyword">typedef</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> ThreadHandle;
+00027   <span class="keyword">typedef</span> CRITICAL_SECTION Mutex;
+00028 
+00029 <span class="preprocessor">#else // Various unix flavors with pthread support.</span>
+00030 <span class="preprocessor"></span><span class="preprocessor">  #include &lt;pthread.h&gt;</span>
+00031 
+00032   <span class="keyword">typedef</span> pthread_t ThreadHandle;
+00033   <span class="keyword">typedef</span> pthread_mutex_t Mutex;
+00034 
+00035 <span class="preprocessor">#endif</span>
+00036 <span class="preprocessor"></span>
+00037 <span class="comment">// OS-X CoreMIDI header files.</span>
+00038 <span class="preprocessor">#include &lt;CoreMIDI/CoreMIDI.h&gt;</span>
+00039 <span class="preprocessor">#include &lt;CoreAudio/HostTime.h&gt;</span>
+00040 
+00041 <span class="comment">// Issues yet to resolve:</span>
+00042 <span class="comment">// - how do we make this cross-platform</span>
+00043 <span class="comment">//   - no subclasses</span>
+00044 <span class="comment">//   - instead, attempt an optional api argument for oss/alsa selection</span>
+00045 <span class="comment">// - do we keep both input and output functionality here?</span>
+00046 <span class="comment">//</span>
+00047 <span class="comment">//   - RtMidiIn, RtMidiOut</span>
+00048 <span class="comment">//</span>
+00049 <span class="comment">// - what do we call the ignore() function?</span>
+00050 
+00051 
+00052 
+00053 <span class="keyword">class </span><a class="code" href="classRtMidi.html">RtMidi</a>
+00054 {
+00055  <span class="keyword">public</span>:
+00056 
+<a name="l00058"></a><a class="code" href="classRtMidi.html#s8">00058</a>   <span class="keyword">enum</span> <a class="code" href="classRtMidi.html#s8">PortType</a> { RTMIDI_INPUT, RTMIDI_OUTPUT };
+00059 
+<a name="l00061"></a><a class="code" href="classRtMidi.html#s0">00061</a>   <span class="keyword">typedef</span> void (*RtMidiCallback)( std::vector&lt;unsigned char&gt; *message, <span class="keywordtype">void</span> *userData);
+00062 
+00064   <a class="code" href="classRtMidi.html#a0">RtMidi</a>();
+00065 
+00067 
+00071   <a class="code" href="classRtMidi.html#a0">RtMidi</a>( PortType type, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> portNumber = 0 );
+00072 
+00074   <a class="code" href="classRtMidi.html#a2">~RtMidi</a>();
+00075 
+00077 
+00083   <span class="keywordtype">void</span> <a class="code" href="classRtMidi.html#a3">openPort</a>( PortType type, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> portNumber = 0 );
+00084 
+00086   <span class="keywordtype">void</span> <a class="code" href="classRtMidi.html#a4">closePort</a>( <span class="keywordtype">void</span> );
+00087 
+00089   <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> <a class="code" href="classRtMidi.html#a5">getPortCount</a>( PortType type );
+00090 
+00092   std::string <a class="code" href="classRtMidi.html#a6">getPortName</a>( PortType type, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> portNumber );
+00093 
+00095   <span class="keywordtype">void</span> <a class="code" href="classRtMidi.html#a7">setInputCallback</a>( RtMidiCallback callback, <span class="keywordtype">void</span> *userData);
+00096 
+00097   <span class="keywordtype">void</span> setInputQueueSize( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> queueSize );
+00098 
+00100 
+00107   <span class="keywordtype">void</span> <a class="code" href="classRtMidi.html#a9">setIgnoreTypes</a>( <span class="keywordtype">bool</span> midiSysex = <span class="keyword">true</span>, <span class="keywordtype">bool</span> midiSense = <span class="keyword">true</span>, <span class="keywordtype">bool</span> midiTime = <span class="keyword">true</span> );
+00108 
+00110 
+00117   <span class="keywordtype">double</span> <a class="code" href="classRtMidi.html#a10">getMessage</a>( std::vector&lt;unsigned char&gt; *message );
+00118 
+00120 
+00124   <span class="keywordtype">void</span> <a class="code" href="classRtMidi.html#a11">sendMessage</a>( std::vector&lt;unsigned char&gt; *message );
+00125 
+00126   <span class="comment">// A MIDI structure used internally by the class to store incoming</span>
+00127   <span class="comment">// messages.  Each message represents one and only one MIDI message.</span>
+00128   <span class="keyword">struct </span>MidiMessage { 
+00129     std::vector&lt;unsigned char&gt; bytes; 
+00130     <span class="keywordtype">double</span> timeStamp;
+00131 
+00132     <span class="comment">// Default constructor.</span>
+00133     MidiMessage()
+00134       :bytes(3), timeStamp(0.0) {}
+00135   };
+00136 
+00137   <span class="comment">// This public structure is used to pass private class data to the</span>
+00138   <span class="comment">// MIDI input callback function or thread.</span>
+00139   <span class="keyword">struct </span>RtMidiCallbackInfo {
+00140     <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> writeIndex;
+00141     <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> lastTime;
+00142     MidiMessage buffer[nMessages];
+00143     Mutex mutex;
+00144     <span class="keywordtype">bool</span> usingCallback;
+00145     <span class="keywordtype">void</span> *userCallback;
+00146     <span class="keywordtype">void</span> *userData;
+00147 
+00148     <span class="comment">// Default constructor.</span>
+00149     RtMidiCallbackInfo()
+00150       : writeIndex(0), doDeltaTime(true), lastTime(0),
+00151          usingCallback(false), userCallback(0), userData(0) {}
+00152   };
+00153 
+00154  <span class="keyword">private</span>:
+00155 
+00156   <span class="comment">// A basic error reporting function for internal use in the RtMidi</span>
+00157   <span class="comment">// class.  The behavior of this function can be modified to suit</span>
+00158   <span class="comment">// specific needs.</span>
+00159   <span class="keywordtype">void</span> error( RtError::Type type );
+00160   
+00161   MidiMessage currentMessage_;
+00162   <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> nMessages;
+00163   <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> readIndex_;
+00164   MIDIClientRef client_;
+00165   MIDIPortRef port_;
+00166   MIDIEndpointRef destinationId_;
+00167   RtMidiCallbackInfo callbackInfo_;
+00168   <span class="keywordtype">bool</span> connected_;
+00169   <span class="keywordtype">bool</span> isInputPort_;
+00170   std::string errorString_;
+00171 
+00172 };
+00173 
+00174 <span class="preprocessor">#endif</span>
+</pre></div><HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/oldRtMidi_8cpp-source.html b/doxygen/html/oldRtMidi_8cpp-source.html
new file mode 100755
index 0000000..90c3f47
--- /dev/null
+++ b/doxygen/html/oldRtMidi_8cpp-source.html
@@ -0,0 +1,385 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>oldRtMidi.cpp</h1><div class="fragment"><pre>00001 <span class="comment">// RtMidi class declaration</span>
+00002 <span class="comment">// Realtime MIDI input/output class.</span>
+00003 <span class="comment">//</span>
+00004 <span class="comment">// This class provides access to a single MIDI input or output port.</span>
+00005 <span class="comment">// Create multiple instances of this class to connect to more than</span>
+00006 <span class="comment">// one MIDI device at the same time.</span>
+00007 <span class="comment">//</span>
+00008 <span class="comment">// by Gary P. Scavone, 2003.</span>
+00009 
+00010 <span class="preprocessor">#include "RtMidi.h"</span>
+00011 <span class="preprocessor">#include &lt;sstream&gt;</span>
+00012 <span class="preprocessor">#include &lt;sys/time.h&gt;</span>
+00013 
+00014 <span class="keywordtype">void</span> midiInputCallback( <span class="keyword">const</span> MIDIPacketList *list, <span class="keywordtype">void</span> *procRef, <span class="keywordtype">void</span> *srcRef )
+00015 {
+00016   RtMidi::RtMidiCallbackInfo *info = static_cast&lt;RtMidi::RtMidiCallbackInfo *&gt; (procRef);
+00017 
+00018   RtMidi::MidiMessage *message;
+00019   <span class="keyword">const</span> MIDIPacket *packet = &amp;list-&gt;packet[0];
+00020   <span class="keywordflow">for</span> ( <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> i=0; i&lt;list-&gt;numPackets; ++i ) {
+00021 
+00022     <span class="comment">// For the moment, we're limiting ourselves to basic MIDI messages</span>
+00023     <span class="comment">// and ignoring the (real) possibility that multiple MIDI messages</span>
+00024     <span class="comment">// can be packed into a single MIDIPacket.  FIXME!!!</span>
+00025     <span class="keywordflow">if</span> ( packet-&gt;length &gt; 3 ) <span class="keywordflow">continue</span>;
+00026 
+00027     message = static_cast&lt;RtMidi::MidiMessage *&gt; (&amp;info-&gt;buffer[info-&gt;writeIndex++]);
+00028     message-&gt;bytes.assign( packet-&gt;data, &amp;packet-&gt;data[packet-&gt;length] );
+00029 
+00030     <span class="comment">// - have status byte:</span>
+00031     <span class="comment">//   - look for subsequent data bytes of known number (unless sysex ... unknown number)</span>
+00032     <span class="comment">//   - if find a system realtime:</span>
+00033     <span class="comment">//     - copy incomplete message to next buffer</span>
+00034     <span class="comment">//     - clear current buffer and write realtime message</span>
+00035     <span class="comment">//     - continue parsing data bytes</span>
+00036     <span class="comment">// while !finished parsing:</span>
+00037     <span class="comment">//   if data byte</span>
+00038     <span class="comment">// if ( incomplete ) {</span>
+00039     <span class="comment">//  for ( int i = 0; i &lt; packet-&gt;length; i++ ) {</span>
+00040     <span class="comment">//    if while ( packet-&gt;data[</span>
+00041     <span class="comment">//  }</span>
+00042     <span class="comment">//}</span>
+00043 
+00044     <span class="comment">// Calculate time stamp.</span>
+00045     message-&gt;timeStamp = 0.0;
+00046     <span class="keywordflow">if</span> ( info-&gt;doDeltaTime ) {
+00047       <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> time = packet-&gt;timeStamp;
+00048       time -= info-&gt;lastTime;
+00049       info-&gt;lastTime = packet-&gt;timeStamp;
+00050       time = AudioConvertHostTimeToNanos( time );
+00051       message-&gt;timeStamp = time * 0.000000001;
+00052     }
+00053     <span class="keywordflow">else</span> { <span class="comment">// absolute time in seconds since midnight (0 hour), January 1, 1970</span>
+00054       timeval time;
+00055       <span class="keywordflow">if</span> ( gettimeofday( &amp;time, NULL ) != 0 ) {
+00056         std::cerr &lt;&lt; <span class="stringliteral">"RtMidi: error in midiInputCallback calculating time stamp."</span>;
+00057       }
+00058       <span class="keywordflow">else</span> {
+00059         message-&gt;timeStamp = (double) time.tv_sec;
+00060         message-&gt;timeStamp += (double) (time.tv_usec * 0.000001);
+00061       }
+00062     }
+00063 
+00064     <span class="keywordflow">if</span> ( info-&gt;writeIndex &gt;= nMessages )
+00065       info-&gt;writeIndex = 0;
+00066 
+00067     <span class="keywordflow">if</span> ( info-&gt;usingCallback ) {
+00068       <a class="code" href="classRtMidi.html#s0">RtMidi::RtMidiCallback</a> callback = (RtMidi::RtMidiCallback) info-&gt;userCallback;
+00069       callback( message, info-&gt;userData );
+00070     }
+00071 
+00072     packet = MIDIPacketNext(packet);
+00073   }
+00074 }
+00075 
+00076 <a class="code" href="classRtMidi.html#a0">RtMidi :: RtMidi</a>( TimeType time )
+00077 {
+00078   <span class="keywordflow">if</span> ( time == ABSOLUTE_TIME ) callbackInfo_.doDeltaTime = <span class="keyword">false</span>;
+00079   callbackInfo_.lastTime = AudioGetCurrentHostTime();
+00080   readIndex_ = 0;
+00081   connected_ = <span class="keyword">false</span>;
+00082 }
+00083 
+00084 <a class="code" href="classRtMidi.html#a0">RtMidi :: RtMidi</a>( PortType type, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> portNumber, TimeType time )
+00085 {
+00086   <span class="keywordflow">if</span> ( time == ABSOLUTE_TIME ) callbackInfo_.doDeltaTime = <span class="keyword">false</span>;
+00087   callbackInfo_.lastTime = AudioGetCurrentHostTime();
+00088   readIndex_ = 0;
+00089   connected_ = <span class="keyword">false</span>;
+00090 
+00091   <span class="comment">// Attempt to make the connection.</span>
+00092   this-&gt;<a class="code" href="classRtMidi.html#a3">openPort</a>( type, portNumber );
+00093 }
+00094 
+<a name="l00095"></a><a class="code" href="classRtMidi.html#a2">00095</a> <a class="code" href="classRtMidi.html#a2">RtMidi :: ~RtMidi</a>()
+00096 {
+00097   <span class="keywordflow">if</span> ( connected_ ) {
+00098     MIDIClientDispose( client_ );
+00099     MIDIPortDispose( port_ );
+00100   }
+00101 }
+00102 
+<a name="l00103"></a><a class="code" href="classRtMidi.html#a3">00103</a> <span class="keywordtype">void</span> <a class="code" href="classRtMidi.html#a3">RtMidi :: openPort</a>( PortType type, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> portNumber )
+00104 {
+00105   <span class="keywordflow">if</span> ( connected_ ) {
+00106     errorString_ = <span class="stringliteral">"RtMidi::openPort: a valid connection already exists."</span>;
+00107     error( RtError::WARNING );
+00108     <span class="keywordflow">return</span>;
+00109   }
+00110 
+00111   <span class="keywordflow">if</span> ( portNumber &lt; 0 ) {
+00112     errorString_ = <span class="stringliteral">"RtMidi::openPort: the 'portNumber' argument must be greater than zero."</span>;
+00113     error( RtError::INVALID_PARAMETER );
+00114   }
+00115 
+00116   std::ostringstream ost;
+00117   <span class="keywordflow">if</span> ( type == MIDI_INPUT ) {
+00118     <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> nSrc = MIDIGetNumberOfSources();
+00119     <span class="keywordflow">if</span> (nSrc &lt; 1) {
+00120       errorString_ = <span class="stringliteral">"RtMidi::openPort: no MIDI input sources found!"</span>;
+00121       error( RtError::NO_DEVICES_FOUND );
+00122     }
+00123 
+00124     <span class="keywordflow">if</span> ( portNumber &gt;= nSrc ) {
+00125       ost &lt;&lt; <span class="stringliteral">"RtMidi::openPort: the 'portNumber' argument ("</span> &lt;&lt; portNumber &lt;&lt; <span class="stringliteral">") is invalid."</span>;
+00126       errorString_ = ost.str();
+00127       error( RtError::INVALID_PARAMETER );
+00128     }
+00129 
+00130     OSStatus result = MIDIClientCreate( CFSTR(<span class="stringliteral">"RtMidi Input Client"</span>), NULL, NULL, &amp;client_ );
+00131     <span class="keywordflow">if</span> ( result != noErr ) {
+00132       errorString_ = <span class="stringliteral">"RtMidi::openPort: error creating OS-X MIDI client object."</span>;
+00133       error( RtError::DRIVER_ERROR );
+00134     }
+00135 
+00136     result = MIDIInputPortCreate( client_, CFSTR(<span class="stringliteral">"RtMidi Virtual MIDI Input Port"</span>), midiInputCallback, (<span class="keywordtype">void</span> *)&amp;callbackInfo_, &amp;port_ );
+00137     <span class="keywordflow">if</span> ( result != noErr ) {
+00138       MIDIClientDispose( client_ );
+00139       errorString_ = <span class="stringliteral">"RtMidi::openPort: error creating OS-X MIDI input port."</span>;
+00140       error( RtError::DRIVER_ERROR );
+00141     }
+00142 
+00143     <span class="comment">// Get the desired input source identifier.</span>
+00144     MIDIEndpointRef src = MIDIGetSource( portNumber );
+00145     <span class="keywordflow">if</span> ( src == NULL ) {
+00146       MIDIPortDispose( port_ );
+00147       MIDIClientDispose( client_ );
+00148       errorString_ = <span class="stringliteral">"RtMidi::openPort: error getting MIDI input source reference."</span>;
+00149       error( RtError::DRIVER_ERROR );
+00150     }
+00151 
+00152     <span class="comment">// Make the connection.</span>
+00153     result = MIDIPortConnectSource(port_, src, NULL );
+00154     <span class="keywordflow">if</span> ( result != noErr ) {
+00155       MIDIPortDispose( port_ );
+00156       MIDIClientDispose( client_ );
+00157       errorString_ = <span class="stringliteral">"RtMidi::openPort: error connecting OS-X MIDI input port."</span>;
+00158       error( RtError::DRIVER_ERROR );
+00159     }
+00160 
+00161     isInputPort_ = <span class="keyword">true</span>;
+00162     callbackInfo_.lastTime = AudioGetCurrentHostTime();
+00163   }
+00164   <span class="keywordflow">else</span> { <span class="comment">// MIDI_OUTPUT</span>
+00165     <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> nDest = MIDIGetNumberOfDestinations();
+00166     <span class="keywordflow">if</span> (nDest &lt; 1) {
+00167       errorString_ = <span class="stringliteral">"RtMidi::openPort: no MIDI output destinations found!"</span>;
+00168       error( RtError::NO_DEVICES_FOUND );
+00169     }
+00170 
+00171     <span class="keywordflow">if</span> ( portNumber &gt;= nDest ) {
+00172       ost &lt;&lt; <span class="stringliteral">"RtMidi::openPort: the 'portNumber' argument ("</span> &lt;&lt; portNumber &lt;&lt; <span class="stringliteral">") is invalid."</span>;
+00173       errorString_ = ost.str();
+00174       error( RtError::INVALID_PARAMETER );
+00175     }
+00176 
+00177     OSStatus result = MIDIClientCreate( CFSTR(<span class="stringliteral">"RtMidi Output Client"</span>), NULL, NULL, &amp;client_ );
+00178     <span class="keywordflow">if</span> ( result != noErr ) {
+00179       errorString_ = <span class="stringliteral">"RtMidi::openPort: error creating OS-X MIDI client object."</span>;
+00180       error( RtError::DRIVER_ERROR );
+00181     }
+00182 
+00183     result = MIDIOutputPortCreate( client_, CFSTR(<span class="stringliteral">"RtMidi Virtual MIDI Output Port"</span>), &amp;port_ );
+00184     <span class="keywordflow">if</span> ( result != noErr ) {
+00185       MIDIClientDispose( client_ );
+00186       errorString_ = <span class="stringliteral">"RtMidi::openPort: error creating OS-X MIDI output port."</span>;
+00187       error( RtError::DRIVER_ERROR );
+00188     }
+00189 
+00190     <span class="comment">// Get the desired output port identifier.</span>
+00191     destinationId_ = MIDIGetDestination( portNumber );
+00192     <span class="keywordflow">if</span> ( destinationId_ == NULL ) {
+00193       MIDIPortDispose( port_ );
+00194       MIDIClientDispose( client_ );
+00195       errorString_ = <span class="stringliteral">"RtMidi::openPort: error getting MIDI output destination reference."</span>;
+00196       error( RtError::DRIVER_ERROR );
+00197     }
+00198 
+00199     isInputPort_ = <span class="keyword">false</span>;
+00200   }
+00201 
+00202   connected_ = <span class="keyword">true</span>;
+00203 }
+00204 
+<a name="l00205"></a><a class="code" href="classRtMidi.html#a4">00205</a> <span class="keywordtype">void</span> <a class="code" href="classRtMidi.html#a4">RtMidi :: closePort</a>( <span class="keywordtype">void</span> )
+00206 {
+00207   <span class="keywordflow">if</span> ( connected_ ) {
+00208     MIDIClientDispose( client_ );
+00209     MIDIPortDispose( port_ );
+00210   }
+00211   <span class="keywordflow">else</span> {
+00212     errorString_ = <span class="stringliteral">"RtMidi::closePort: a port connection was not open!"</span>;
+00213     error( RtError::WARNING );
+00214   }
+00215   connected_ = <span class="keyword">false</span>;
+00216 }
+00217 
+<a name="l00218"></a><a class="code" href="classRtMidi.html#a5">00218</a> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> <a class="code" href="classRtMidi.html#a5">RtMidi :: getPortCount</a>( PortType type )
+00219 {
+00220   <span class="keywordflow">if</span> ( type == MIDI_INPUT )
+00221     <span class="keywordflow">return</span> MIDIGetNumberOfSources();
+00222   <span class="keywordflow">else</span> <span class="comment">// MIDI_OUTPUT</span>
+00223     <span class="keywordflow">return</span> MIDIGetNumberOfDestinations();
+00224 }
+00225 
+<a name="l00226"></a><a class="code" href="classRtMidi.html#a6">00226</a> std::string <a class="code" href="classRtMidi.html#a6">RtMidi :: getPortName</a>( PortType type, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> portNumber )
+00227 {
+00228   CFStringRef nameRef;
+00229   MIDIEndpointRef portRef;
+00230   std::ostringstream ost;
+00231   <span class="keywordtype">char</span> name[128];
+00232   <span class="keywordflow">if</span> ( type == MIDI_INPUT ) {
+00233     <span class="keywordflow">if</span> ( portNumber &lt; 0 || portNumber &gt;= MIDIGetNumberOfSources() ) {
+00234       ost &lt;&lt; <span class="stringliteral">"RtMidi::getPortName: the 'portNumber' argument ("</span> &lt;&lt; portNumber &lt;&lt; <span class="stringliteral">") is invalid."</span>;
+00235       errorString_ = ost.str();
+00236       error( RtError::INVALID_PARAMETER );
+00237     }
+00238     portRef = MIDIGetSource( portNumber );
+00239   }
+00240   <span class="keywordflow">else</span> { <span class="comment">// MIDI_OUTPUT</span>
+00241     <span class="keywordflow">if</span> ( portNumber &lt; 0 || portNumber &gt;= MIDIGetNumberOfDestinations() ) {
+00242       ost &lt;&lt; <span class="stringliteral">"RtMidi::getPortName: the 'portNumber' argument ("</span> &lt;&lt; portNumber &lt;&lt; <span class="stringliteral">") is invalid."</span>;
+00243       errorString_ = ost.str();
+00244       error( RtError::INVALID_PARAMETER );
+00245     }
+00246     portRef = MIDIGetDestination( portNumber );
+00247   }
+00248 
+00249   MIDIObjectGetStringProperty( portRef, kMIDIPropertyName, &amp;nameRef );
+00250   CFStringGetCString( nameRef, name, <span class="keyword">sizeof</span>(name), 0);
+00251   CFRelease( nameRef );
+00252   std::string stringName = name;
+00253   <span class="keywordflow">return</span> stringName;
+00254 }
+00255 
+<a name="l00256"></a><a class="code" href="classRtMidi.html#a7">00256</a> <span class="keywordtype">void</span> <a class="code" href="classRtMidi.html#a7">RtMidi :: setInputCallback</a>( RtMidiCallback callback, <span class="keywordtype">void</span> *userData)
+00257 {
+00258   callbackInfo_.userCallback = (<span class="keywordtype">void</span> *) callback;
+00259   callbackInfo_.userData = userData;
+00260   callbackInfo_.usingCallback = <span class="keyword">true</span>;
+00261 }
+00262 
+00263 <span class="keyword">const</span> RtMidi::MidiMessage* <a class="code" href="classRtMidi.html#a10">RtMidi :: getMessage</a>( <span class="keywordtype">void</span> )
+00264 {
+00265   currentMessage_.bytes.clear();
+00266   <span class="keywordflow">if</span> ( !connected_ ) {
+00267     errorString_ = <span class="stringliteral">"RtMidi::getNextMessage: a port is not open!"</span>;
+00268     error( RtError::WARNING );
+00269     <span class="keywordflow">return</span> &amp;currentMessage_;
+00270   }
+00271 
+00272   <span class="keywordflow">if</span> ( !isInputPort_ ) {
+00273     errorString_ = <span class="stringliteral">"RtMidi::getNextMessage: this is not an input port!"</span>;
+00274     error( RtError::WARNING );
+00275     <span class="keywordflow">return</span> &amp;currentMessage_;
+00276   }
+00277 
+00278   <span class="keywordflow">if</span> ( callbackInfo_.usingCallback ) {
+00279     errorString_ = <span class="stringliteral">"RtMidi::getNextMessage: a user callback is currently set for this port."</span>;
+00280     error( RtError::WARNING );
+00281     <span class="keywordflow">return</span> &amp;currentMessage_;
+00282   }
+00283 
+00284   <span class="keywordflow">if</span> ( readIndex_ == callbackInfo_.writeIndex ) <span class="keywordflow">return</span> &amp;currentMessage_;
+00285 
+00286   currentMessage_ = callbackInfo_.buffer[readIndex_++];
+00287   <span class="keywordflow">if</span> ( readIndex_ &gt;= nMessages ) readIndex_ = 0;
+00288 
+00289   <span class="keywordflow">return</span> &amp;currentMessage_;
+00290 }
+00291 
+00292 <span class="keywordtype">bool</span> <a class="code" href="classRtMidi.html#a11">RtMidi :: sendMessage</a>( <span class="keyword">const</span> MidiMessage *message )
+00293 {
+00294   <span class="keywordflow">if</span> ( !connected_ ) {
+00295     errorString_ = <span class="stringliteral">"RtMidi::sendMessage: a port is not open!"</span>;
+00296     error( RtError::WARNING );
+00297     <span class="keywordflow">return</span> <span class="keyword">false</span>;
+00298   }
+00299 
+00300   <span class="keywordflow">if</span> ( isInputPort_ ) {
+00301     errorString_ = <span class="stringliteral">"RtMidi::sendMessage: this is not an output port!"</span>;
+00302     error( RtError::WARNING );
+00303     <span class="keywordflow">return</span> <span class="keyword">false</span>;
+00304   }
+00305 
+00306   <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> nBytes = message-&gt;bytes.size();
+00307   <span class="comment">// Pad the buffer for extra (unknown) structure data.</span>
+00308   Byte buffer[nBytes+32];
+00309   MIDIPacketList *pktlist = (MIDIPacketList *) buffer;
+00310   MIDIPacket *curPacket = MIDIPacketListInit( pktlist );
+00311 
+00312   MIDITimeStamp timeStamp = 0;
+00313   <span class="comment">// If a non-zero delta or absolute time, convert to CoreMIDI's host time.</span>
+00314   <span class="keywordflow">if</span> ( message-&gt;timeStamp != 0.0 ) {
+00315     <span class="keywordflow">if</span> ( callbackInfo_.doDeltaTime ) {
+00316       timeStamp = AudioConvertHostTimeToNanos( AudioGetCurrentHostTime() );
+00317       timeStamp += (UInt64) (message-&gt;timeStamp * 1000000000.0);
+00318       timeStamp = AudioConvertNanosToHostTime( timeStamp );
+00319     }
+00320     <span class="keywordflow">else</span> {
+00321       timeval tvTime;
+00322       <span class="keywordtype">double</span> time;
+00323       <span class="keywordflow">if</span> ( gettimeofday( &amp;tvTime, NULL ) != 0 ) {
+00324         errorString_ = <span class="stringliteral">"RtMidi::sendMessage: error calculating time stamp."</span>;
+00325         error( RtError::WARNING );
+00326       }
+00327       <span class="keywordflow">else</span> {
+00328         time = (double) tvTime.tv_sec;
+00329         time += (double) (tvTime.tv_usec * 0.000001);
+00330         time = message-&gt;timeStamp - time;
+00331         <span class="keywordflow">if</span> ( time &gt; 0.0 ) {
+00332           timeStamp = AudioConvertHostTimeToNanos( AudioGetCurrentHostTime() );
+00333           timeStamp += (UInt64) (time * 1000000000.0);
+00334           timeStamp = AudioConvertNanosToHostTime( timeStamp );
+00335         }
+00336       }
+00337     }
+00338   }
+00339   curPacket = MIDIPacketListAdd( pktlist, <span class="keyword">sizeof</span>(buffer), curPacket, timeStamp, nBytes, &amp;message-&gt;bytes[0]);
+00340 
+00341   OSStatus result = MIDISend( port_, destinationId_, pktlist );
+00342   <span class="keywordflow">if</span> ( result != noErr ) {
+00343     errorString_ = <span class="stringliteral">"RtMidi::sendMessage: error sending MIDI message."</span>;
+00344     error( RtError::WARNING );
+00345     <span class="keywordflow">return</span> <span class="keyword">false</span>;
+00346   }
+00347 
+00348   <span class="keywordflow">return</span> <span class="keyword">true</span>;
+00349 }
+00350 
+00351 <span class="keywordtype">void</span> RtMidi :: error( RtError::Type type )
+00352 {
+00353   <span class="keywordflow">if</span> (type == RtError::WARNING) {
+00354     std::cerr &lt;&lt; <span class="charliteral">'\n'</span> &lt;&lt; errorString_ &lt;&lt; <span class="stringliteral">"\n\n"</span>;
+00355   }
+00356   <span class="keywordflow">else</span> <span class="keywordflow">if</span> (type == RtError::DEBUG_WARNING) {
+00357 <span class="preprocessor">#if defined(__RTMIDI_DEBUG__)</span>
+00358 <span class="preprocessor"></span>    std::cerr &lt;&lt; <span class="charliteral">'\n'</span> &lt;&lt; errorString_ &lt;&lt; <span class="stringliteral">"\n\n"</span>;
+00359 <span class="preprocessor">#endif</span>
+00360 <span class="preprocessor"></span>  }
+00361   <span class="keywordflow">else</span> {
+00362     std::cerr &lt;&lt; <span class="charliteral">'\n'</span> &lt;&lt; errorString_ &lt;&lt; <span class="stringliteral">"\n\n"</span>;
+00363     <span class="keywordflow">throw</span> <a class="code" href="classRtError.html">RtError</a>( errorString_, type );
+00364   }
+00365 }
+</pre></div><HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/oldRtMidi_8h-source.html b/doxygen/html/oldRtMidi_8h-source.html
new file mode 100755
index 0000000..26ea396
--- /dev/null
+++ b/doxygen/html/oldRtMidi_8h-source.html
@@ -0,0 +1,163 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>oldRtMidi.h</h1><div class="fragment"><pre>00001 <span class="comment">/**********************************************************************/</span>
+00011 <span class="comment">/**********************************************************************/</span>
+00012 
+00013 <span class="preprocessor">#ifndef RTMIDI_H</span>
+00014 <span class="preprocessor"></span><span class="preprocessor">#define RTMIDI_H</span>
+00015 <span class="preprocessor"></span>
+00016 <span class="preprocessor">#include &lt;vector&gt;</span>
+00017 <span class="preprocessor">#include &lt;string&gt;</span>
+00018 <span class="preprocessor">#include "RtError.h"</span>
+00019 
+00020 <span class="comment">// Operating system dependent thread functionality.</span>
+00021 <span class="preprocessor">#if defined(__WINDOWS_DS__) || defined(__WINDOWS_ASIO__)</span>
+00022 <span class="preprocessor"></span><span class="preprocessor">  #include &lt;windows.h&gt;</span>
+00023 <span class="preprocessor">  #include &lt;process.h&gt;</span>
+00024 
+00025   <span class="keyword">typedef</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> ThreadHandle;
+00026   <span class="keyword">typedef</span> CRITICAL_SECTION Mutex;
+00027 
+00028 <span class="preprocessor">#else // Various unix flavors with pthread support.</span>
+00029 <span class="preprocessor"></span><span class="preprocessor">  #include &lt;pthread.h&gt;</span>
+00030 
+00031   <span class="keyword">typedef</span> pthread_t ThreadHandle;
+00032   <span class="keyword">typedef</span> pthread_mutex_t Mutex;
+00033 
+00034 <span class="preprocessor">#endif</span>
+00035 <span class="preprocessor"></span>
+00036 <span class="comment">// OS-X CoreMIDI header files.</span>
+00037 <span class="preprocessor">#include &lt;CoreMIDI/CoreMIDI.h&gt;</span>
+00038 <span class="preprocessor">#include &lt;CoreAudio/HostTime.h&gt;</span>
+00039 
+00040 <span class="comment">// Set the size of the circular MIDI input message buffer.</span>
+00041 <span class="keyword">const</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> nMessages = 100;
+00042 
+00043 <span class="keyword">class </span><a class="code" href="classRtMidi.html">RtMidi</a>
+00044 {
+00045  <span class="keyword">public</span>:
+00046 
+00047   <span class="comment">// A MIDI message structure.  Each message represents one and only</span>
+00048   <span class="comment">// one MIDI message.  Given the variable length of the bytes member,</span>
+00049   <span class="comment">// this structure can contain sysex messages of arbitrary length.</span>
+00050   <span class="keyword">struct </span>MidiMessage { 
+00051     std::vector&lt;unsigned char&gt; bytes; 
+00052     <span class="keywordtype">double</span> timeStamp;
+00053 
+00054     <span class="comment">// Default constructor.</span>
+00055     MidiMessage()
+00056       :bytes(3), timeStamp(0.0) {}
+00057   };
+00058 
+00059   <span class="comment">// Defined MIDI port types.</span>
+00060   <span class="keyword">enum</span> <a class="code" href="classRtMidi.html#s8">PortType</a> { MIDI_INPUT, MIDI_OUTPUT };
+00061 
+00062   <span class="comment">// Defined MIDI time stamp types.  Times are saved in a</span>
+00063   <span class="comment">// double-precision floating-point variable.  Delta time is in</span>
+00064   <span class="comment">// seconds (between events).  Absolute time is in seconds since</span>
+00065   <span class="comment">// midnight (0 hour), January 1, 1970.</span>
+00066   <span class="keyword">enum</span> TimeType { DELTA_TIME, ABSOLUTE_TIME };
+00067 
+00068   <span class="comment">// User callback function type definition.</span>
+00069   <span class="keyword">typedef</span> void (*RtMidiCallback)( MidiMessage *message, <span class="keywordtype">void</span> *userData);
+00070 
+00071   <span class="comment">// Default constructor.</span>
+00072   <a class="code" href="classRtMidi.html#a0">RtMidi</a>( TimeType time = DELTA_TIME );
+00073 
+00074   <span class="comment">// An overloaded constructor which can be used to open a MIDI port</span>
+00075   <span class="comment">// during instantiation.  An exception is thrown if an error occurs</span>
+00076   <span class="comment">// while attempting to make the port connection.</span>
+00077   <a class="code" href="classRtMidi.html#a0">RtMidi</a>( PortType type, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> portNumber = 0, TimeType time = DELTA_TIME );
+00078 
+00079   <span class="comment">// The destructor closes any open MIDI connections.</span>
+00080   <a class="code" href="classRtMidi.html#a2">~RtMidi</a>();
+00081 
+00082   <span class="comment">// Open a MIDI connection of the specified type.  An optional port</span>
+00083   <span class="comment">// number greater than 0 can be specified.  Otherwise, the default</span>
+00084   <span class="comment">// or first port found is opened.  An exception is thrown if an</span>
+00085   <span class="comment">// error occurs while attempting to make the port connection.</span>
+00086   <span class="keywordtype">void</span> <a class="code" href="classRtMidi.html#a3">openPort</a>( PortType type, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> portNumber = 0 );
+00087 
+00088   <span class="comment">// Close an open MIDI connection (if one exists).</span>
+00089   <span class="keywordtype">void</span> <a class="code" href="classRtMidi.html#a4">closePort</a>( <span class="keywordtype">void</span> );
+00090 
+00091   <span class="comment">// Return the number of available MIDI ports of the specified type.</span>
+00092   <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> <a class="code" href="classRtMidi.html#a5">getPortCount</a>( PortType type );
+00093 
+00094   <span class="comment">// Return a string identifier for the specified MIDI port type and number.</span>
+00095   std::string <a class="code" href="classRtMidi.html#a6">getPortName</a>( PortType type, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> portNumber );
+00096 
+00097   <span class="comment">// Set a user-defined callback function for notification of Midi input.</span>
+00098   <span class="keywordtype">void</span> <a class="code" href="classRtMidi.html#a7">setInputCallback</a>( RtMidiCallback callback, <span class="keywordtype">void</span> *userData);
+00099 
+00100   <span class="comment">// Return a reference to a vector containing the next available</span>
+00101   <span class="comment">// incoming MIDI message.  This function returns immediately whether</span>
+00102   <span class="comment">// a new message is available or not.  A valid message is indicated</span>
+00103   <span class="comment">// by a non-zero vector size in the MidiMessage structure.  An</span>
+00104   <span class="comment">// exception is thrown if an error occurs during message retrieval</span>
+00105   <span class="comment">// or an input connection was not previously established.</span>
+00106   <span class="keyword">const</span> RtMidi::MidiMessage *<a class="code" href="classRtMidi.html#a10">getMessage</a>( <span class="keywordtype">void</span> );
+00107 
+00108   <span class="comment">// Send a single message out an open MIDI port.  If the message time</span>
+00109   <span class="comment">// stamp is non-zero, the message will be scheduled for output</span>
+00110   <span class="comment">// accordingly.  Otherwise, it will be output immediately.  An</span>
+00111   <span class="comment">// exception is thrown if an error occurs during output or an output</span>
+00112   <span class="comment">// connection was not previously established.</span>
+00113   <span class="keywordtype">bool</span> <a class="code" href="classRtMidi.html#a11">sendMessage</a>( <span class="keyword">const</span> MidiMessage *message );
+00114 
+00115   <span class="comment">// This public structure is used to pass private class data to the</span>
+00116   <span class="comment">// MIDI input callback function or thread.</span>
+00117   <span class="keyword">struct </span>RtMidiCallbackInfo {
+00118     <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> writeIndex;
+00119     <span class="keywordtype">bool</span> doDeltaTime;
+00120     <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> lastTime;
+00121     MidiMessage buffer[nMessages];
+00122     Mutex mutex;
+00123     <span class="keywordtype">bool</span> usingCallback;
+00124     <span class="keywordtype">void</span> *userCallback;
+00125     <span class="keywordtype">void</span> *userData;
+00126 
+00127     <span class="comment">// Default constructor.</span>
+00128     RtMidiCallbackInfo()
+00129       : writeIndex(0), doDeltaTime(true), lastTime(0),
+00130          usingCallback(false), userCallback(0), userData(0) {}
+00131   };
+00132 
+00133  <span class="keyword">private</span>:
+00134 
+00135   <span class="comment">// A basic error reporting function for internal use in the RtMidi</span>
+00136   <span class="comment">// class.  The behavior of this function can be modified to suit</span>
+00137   <span class="comment">// specific needs.</span>
+00138   <span class="keywordtype">void</span> error( RtError::Type type );
+00139   
+00140   MidiMessage currentMessage_;
+00141   <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> readIndex_;
+00142   MIDIClientRef client_;
+00143   MIDIPortRef port_;
+00144   MIDIEndpointRef destinationId_;
+00145   RtMidiCallbackInfo callbackInfo_;
+00146   <span class="keywordtype">bool</span> connected_;
+00147   <span class="keywordtype">bool</span> isInputPort_;
+00148   std::string errorString_;
+00149 
+00150 };
+00151 
+00152 <span class="preprocessor">#endif</span>
+</pre></div><HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
diff --git a/doxygen/html/playsmf_8cpp-source.html b/doxygen/html/playsmf_8cpp-source.html
new file mode 100755
index 0000000..5db53c4
--- /dev/null
+++ b/doxygen/html/playsmf_8cpp-source.html
@@ -0,0 +1,117 @@
+<HTML>
+<HEAD>
+<TITLE>The Synthesis ToolKit in C++ (STK)</TITLE>
+<LINK HREF="doxygen.css" REL="stylesheet" TYPE="text/css">
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<CENTER>
+<img src="princeton.gif"> &nbsp; <img src="ccrma.gif"><P>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<HR>
+<!-- Generated by Doxygen 1.3-rc3 -->
+<h1>playsmf.cpp</h1><div class="fragment"><pre>00001 <span class="comment">// playsmf.cpp</span>
+00002 <span class="comment">//</span>
+00003 <span class="comment">// Simple program to test the MidiFileIn class by reading and playing</span>
+00004 <span class="comment">// a single track from a given Standard MIDI file.</span>
+00005 <span class="comment">//</span>
+00006 <span class="comment">// by Gary Scavone, 2003.</span>
+00007 <span class="comment">//</span>
+00008 <span class="comment">// compile: g++ -Wall -o playsmf playsmf.cpp RtMidi.o MidiFileIn.cpp Stk.cpp -framework CoreMIDI -framework CoreFoundation -framework CoreAudio</span>
+00009 
+00010 <span class="preprocessor">#include "MidiFileIn.h"</span>
+00011 <span class="preprocessor">#include "RtMidi.h"</span>
+00012 <span class="preprocessor">#include &lt;signal.h&gt;</span>
+00013 <span class="preprocessor">#include &lt;unistd.h&gt;</span>
+00014 
+00015 <span class="keywordtype">bool</span> done = <span class="keyword">false</span>;
+00016 <span class="keyword">static</span> <span class="keywordtype">void</span> finish(<span class="keywordtype">int</span> ignore){ done = <span class="keyword">true</span>; }
+00017 
+00018 <span class="keywordtype">void</span> usage(<span class="keywordtype">void</span>) {
+00019   <span class="comment">// Error function in case of incorrect command-line</span>
+00020   <span class="comment">// argument specifications.</span>
+00021   std::cout &lt;&lt; <span class="stringliteral">"\nusage: testmidi file track\n"</span>;
+00022   std::cout &lt;&lt; <span class="stringliteral">"   where file = a standard MIDI file,\n"</span>;
+00023   std::cout &lt;&lt; <span class="stringliteral">"   and track = the track to play (0 = 1st track).\n\n"</span>;
+00024   exit(0);
+00025 }
+00026 
+00027 <span class="keywordtype">int</span> main( <span class="keywordtype">int</span> argc, <span class="keywordtype">char</span> *argv[] )
+00028 {
+00029   <span class="keywordflow">if</span> ( argc != 3 ) usage();
+00030 
+00031   <a class="code" href="classRtMidiOut.html">RtMidiOut</a> midi;
+00032 
+00033   <span class="keywordflow">if</span> ( midi.<a class="code" href="classRtMidiOut.html#a5">getPortCount</a>() &lt; 1 ) {
+00034     std::cout &lt;&lt; <span class="stringliteral">"\nThere are no MIDI output destinations available!\n\n"</span>;
+00035     exit(0);
+00036   }
+00037 
+00038   <span class="keywordflow">try</span> {
+00039     midi.<a class="code" href="classRtMidiOut.html#a3">openPort</a>();
+00040   }
+00041   <span class="keywordflow">catch</span> ( <a class="code" href="classRtError.html">RtError</a> &amp; ) {
+00042     <span class="comment">// You might want to do something more useful here.</span>
+00043     std::cout &lt;&lt; <span class="stringliteral">"\nAborting program!\n"</span>;
+00044     exit(0);
+00045   }
+00046 
+00047   <span class="comment">// Install an interrupt handler function.  Type "ctrl-c" to quit the</span>
+00048   <span class="comment">// program.</span>
+00049   (void) signal(SIGINT, finish);
+00050   
+00051   <span class="keywordflow">try</span> {
+00052     <a class="code" href="classMidiFileIn.html">MidiFileIn</a> midiFile( argv[1] );
+00053 
+00054     <span class="comment">// Print a little information about the file.</span>
+00055     std::cout &lt;&lt; <span class="stringliteral">"\nThe MIDI file ("</span> &lt;&lt; argv[1] &lt;&lt; <span class="stringliteral">") information:\n"</span>;
+00056     std::cout &lt;&lt; <span class="stringliteral">"  - format = "</span> &lt;&lt; midiFile.<a class="code" href="classMidiFileIn.html#a2">getFileFormat</a>() &lt;&lt; <span class="stringliteral">"\n"</span>;
+00057     std::cout &lt;&lt; <span class="stringliteral">"  - tracks = "</span> &lt;&lt; midiFile.<a class="code" href="classMidiFileIn.html#a3">getNumberOfTracks</a>() &lt;&lt; <span class="stringliteral">"\n"</span>;
+00058     std::cout &lt;&lt; <span class="stringliteral">"  - seconds / ticks = "</span> &lt;&lt; midiFile.<a class="code" href="classMidiFileIn.html#a6">getTickSeconds</a>() &lt;&lt; <span class="stringliteral">"\n"</span>;
+00059 
+00060     <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> track = (<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span>) atoi( argv[2] );
+00061     <span class="keywordflow">if</span> ( midiFile.<a class="code" href="classMidiFileIn.html#a3">getNumberOfTracks</a>() &lt;= track ) {
+00062       std::cout &lt;&lt; <span class="stringliteral">"\nInvalid track number ... playing track 0.\n"</span>;
+00063       track = 0;
+00064     }
+00065 
+00066     std::cout &lt;&lt; <span class="stringliteral">"\nPress &lt;enter&gt; to start reading/playing.\n"</span>;
+00067     <span class="keywordtype">char</span> input;
+00068     std::cin.get(input);
+00069     
+00070     std::vector&lt;unsigned char&gt; event;
+00071     <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> ticks = midiFile.<a class="code" href="classMidiFileIn.html#a8">getNextMidiEvent</a>( &amp;event, track );
+00072     <span class="keywordflow">while</span> ( !done &amp;&amp; event.size() ) {
+00073 
+00074       <span class="comment">// Pause for the MIDI event delta time.</span>
+00075       <a class="code" href="classStk.html#d7">Stk::sleep</a>( (<span class="keywordtype">unsigned</span> <span class="keywordtype">long</span>) (ticks * midiFile.<a class="code" href="classMidiFileIn.html#a6">getTickSeconds</a>() * 1000 ) );
+00076 
+00077       midi.<a class="code" href="classRtMidiOut.html#a7">sendMessage</a>( &amp;event );
+00078 
+00079       <span class="comment">// Get a new event.</span>
+00080       ticks = midiFile.<a class="code" href="classMidiFileIn.html#a8">getNextMidiEvent</a>( &amp;event, track );
+00081     }
+00082 
+00083     <span class="comment">// Send a "reset" to the synthesizer.</span>
+00084     event.clear();
+00085     event.push_back( 0xff );
+00086     midi.<a class="code" href="classRtMidiOut.html#a7">sendMessage</a>( &amp;event );
+00087   }
+00088   <span class="keywordflow">catch</span> ( <a class="code" href="classStkError.html">StkError</a> &amp; ) {
+00089     <span class="comment">// You might want to do something more useful here.</span>
+00090     std::cout &lt;&lt; <span class="stringliteral">"\nAborting program!\n"</span>;
+00091     midi.<a class="code" href="classRtMidiOut.html#a4">closePort</a>();
+00092     exit(0);
+00093   }
+00094 
+00095   std::cout &lt;&lt; <span class="stringliteral">"Goodbye!\n"</span>;
+00096   <span class="keywordflow">return</span> 0;
+00097 }
+</pre></div><HR>
+
+<table>
+  <tr><td><A HREF="http://www-ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
+  <tr><td>&copy;1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+</table>
+
+</BODY>
+</HTML>
author	Gary Scavone <gary@music.mcgill.ca>	2013-10-11 15:04:06 +0200
committer	Stephen Sinclair <sinclair@music.mcgill.ca>	2013-10-11 15:04:06 +0200
commit	1f910fbc187d2f50004bb0f7e619bd39f043b5b5 (patch)
tree	8254a3a788c9cbf1e34a22f1320e865f525cfb36 /doxygen/html
parent	eeca35408122b9fc020139a20255f3c1ad8254cd (diff)