The following enhancements have been made to the Polyphonic Music package 
version 1.0:

Playing routines:

Version:      Date:        Description:
--------    ---------      ------------                             
 1.01        6/15/89         Relative tempo change implemented. Starting tempo
                                is modified in the text file by the 'T'
                                command:

                                Syntax:

                                 Tn  -- Changes starting tempo value:
                                        where n = a number between 1 and
                                        8191. n consists of a sum of numbers:
                                        
                                        n = REFVAL + CHANGEVAL

                                        REFVAL = 0 or 4096 only.
                                        CHANGEVAL = 1 to 4095 inclusive.

                                How it works:

                                 To add an absolute value to current tempo,
                                        call Tn with n = 4096 + amount you
                                        want to add (amount is CHANGEVAL).
                                 To subtract an absolute value from current 
                                        tempo, call Tn with n = 0 + amount 
                                        you want to subtract (amount is 
                                        CHANGEVAL).

                             I know this causes crude coding, but it works
                             well! A MakePoly update for Tn and T-n (Tempo 
                             Add and Subtract) is in the works.

 1.02        6/15/89         Tempo value now entered in maximal range.
                             The second parameter to playpoly can now have
                             a value in the range of 1 (way too fast) to
                             65535 (or maxint) (way too slow). This addition
                             allows faster computers to use the play 
                             routines with no problem. When using the poly()
                             routine from inside C programs, the first value
                             of the array (whether a command or not) is
                             assumed as a tempo. DO NOT OR (|) the TEMPO value
                             (previously defined in POLY.H) with your tempo! 
                             This will create a tempo which is too long! 
                             Notice the change in POLY.H (and the chord 
                             arrays in POLYCHRD.H). TEMPO define is now 
                             TCHANGE and this command only changes the 
                             starting tempo as decribed above. Note: you must 
                             OR (|) the value of n described above with 
                             TCHANGE (in C programs) to change tempo 
                             effectively. When using the playpoly()/looppoly() 
                             functions the second parameter sent can have 
                             the value 1-65535 described above. You only
                             need to alter your programs if using the poly()
                             function.

 1.10        6/19/89         Eureka! This is, what I believe to be, a major
                             breakthrough in the three voice world!
 			     
                             By re-vamping the play routine, voice 1 has
                             been diminished in strength greatly. Its volume
                             difference above the other two voices is now
                             only slight, if detectable.
                             
                             The sound quality also turned out incredibly
                             better, as there is minimal "sqwak" (peculiar 
                             beeps, buzzes, and hums). 
                             The playing routines of Polyphonic Music 1.0
                             (as well as VMUSIC, I believe) used this code
                             almost verbatim. Unfortunately his code 
                             (usually) produces a high pitched tone during
                             playing. This can be distracting, as it 
                             diminishes the music quality signifigantly.
                             This version's (1.10) technique seems to
                             have only a dull hum sound every once in a
                             while and few (if any) beeps or high pitched
                             tones in the background. See for yourself!
                             (Compare the sound quality of the old routines
                             - in PlayPoly 1.0 or VMUSIC - to the new one
                             by playing the PACHCAN.SNG. You'll notice the
                             difference).
                             
                             With the improved sound and voice volume
                             qualities, these play routines have gained a
                             greater capability for good use in the PC world.
                             
                             Note: Tried four voices. The noise level 
                             increased signifigantly (so much it distracts!).
                             I have discovered how to possibly allow for up
                             to five voices (if I was using a 386 machine
                             I could do this without noise!). I may implement 
                             it, attempting to obtain minimal noise, although
                             updating the MakePoly routine for 4 or more
                             voices may not appear so quickly!

                             P.S. Have discovered an avenue to play
                             up to 16 different voices with little
                             loss to sound quality
                             
 1.20        7/11/89         The playpoly routines (based on poly()) 
                             are now accessable in Turbo Pascal (4.0 and 
                             greater).

                             Also some memory allocation bugs fixed.

                             Added the polykb() function which checks
                             for a keypress after each note and
                             continues playing only if no keypress 
                             was detected.
                             
MakePoly:

Version:      Date:        Description:
--------    ---------      ------------
 1.01	     6/14/89	     An allowance has been made for RELATIVE
 			     change of tempo (see Playing routines update 
 			     1.01 above). No specific interpretation 
 			     (i.e. T-n) of the text music file has been 
 			     implemented yet; only the crude implementation 
 			     described above.
 			     
 1.02        6/15/89	     To add compatability with the VMUSIC software,
 			     MakePoly now allows comments to be delimited
 			     by the '!' character. MakePoly interprets this
 			     character in an identical fashion as the '*'
 			     character. Unlike VMUSIC however, the beginning
 			     and ending comment delimiters need not be
 			     on the SAME line. Comments can go on for several
 			     lines. Note: You must use the same closing
 			     character as the opening one for comments, i.e.
 			     the comment '* voice 1: !' is invalid because
 			     the '!' is not recognized as the close of a '*'
 			     comment.
 			     
 			     Example:
 			     
 			     v1o3 eefg bcdef a2g2
 			     * 
 			     then it repeats
 			     *
 			     v1o3 eefg bcdef a2g2
 			     
 1.03	     6/16/89	     Again to add compatability with VMUSIC, MakePoly
 			     now supports the printable comment feature which
 			     prints the text delimited by '$' characters to
 			     screen while compiling to a ".ply" file. Again,
 			     unlike VMUSIC, the starting and ending '$' need
 			     not be on the SAME line (but MakePoly will still
 			     print a line feed at the start of a printable
 			     comment if they are).
 			     
 			     To further compatability with BASIC (the 
 			     language which MakePoly's commands were derived
 			     from), the '?' character also will delimit
 			     printable comments. Since, in BASIC, the '?'
 			     represents "print", it is suggested to use
 			     the '?' character in the music text file 
 			     for clarity.
 			     
 			     Example:
 			     
 			     v1o3 aagg fefe a2a2
 			     $
 			     	Line One: la la so so fa mi fa mi la.. la..
 			     $
 			     v1o5 ccdd eeff g2g2
 			     ?
 			     	Line Two: do do re re mi mi fa fa so.. so..
 			     ?
 			     
 1.04	     7/9/89	     Bug fixed in MAKEPOLY.  It wouldn't provide
 			     for one voice songs (the bug caused notes of 
 			     indefinate length).  One voice songs can now
 			     be played (any voice) [I thought I fixed this
 			     bug once before!].

 1.10        7/9/89          Relative pitch values implemented!  Now when
 			     a song is compiled, the 'frequency' of the
 			     Middle C note can be set (in the MAKEPOLY.EXE
 			     command line) and all other 'frequencies' are
 			     derived from this value (these are not true HERTZ
 			     frequencies, only computer values).
 			     It is implemented as follows:
 			     
 			     MAKEPOLY <textfile> [<polyfile>] [/nval]
 			     
 			     where: <textfile>,<polyfile> are unchanged
 			     	    (see POLY.DOC).
 			     	    nval = 'frequency' to set middle C at.
 			     	    	   nval can be in the range of 1
 			     	    	   to 8191 although, nval values at
 			     	    	   the extremes (1-150,7000-8191)
 			     	    	   may produce crude sounds when
 			     	    	   playing other octaves than the 
 			     	    	   middle one. If this parameter is
 			     	    	   not specified nval = 390 is assumed.
 			     	    	   This value is the true HERTZ value
 			     	    	   of middle C on a Turbo XT.
 			     	    	   Higher values produce higher 
 			     	    	   pitches; lower values produce lower
 			     	    	   pitches.
 			     
 			     So if pitches seem too high on your machine,
 			     try halving 390 (195).  If too low, try doubling
 			     390 (780).  Try using this function and let me
 			     know how it works and next update I can implement
 			     the processor check to return a ballpark value
 			     for this parameter.
