Advanced Sound Programming

PROFESSIONAL SOUND PROGRAMMING ON THE ST by Holger Gehrmann

The  fashion  of  programming complex pieces  of  music  on  home 
computers   started  already  at  the  very  beginning  of   home 
computing,  when  the VIC 20 from Commodore hit the  market.  The 
soundchip  has one noise-and three tone  generators,  that  could 
only  produce  a  pulse  waveform.   The  volume  could  only  be 
controlled  for  all  tone  generators  at  once.   The  idea  of 
programming  complex  musical compositions didn't even  find  its 
origin  then,  because the musical capabilities were  simply  too 
limited.

All changed when the Commodore 64 appeared. And already two years 
after  its launch,  very complex songs were finding their way  to 
the users which were packed with sound effects.  No  wonder:  The 
sound capabilities of this computer could easily match those of a 
small and cheap synthesizer system.

One would think that a new computer like the Atari ST should even 
outdo the sound possibilities of the 64, but the ST unfortunately 
contains  a  regular  Yamaha chip.  It offers  three  pulse  tone 
generators,  to which noise can be mixed individually. The volume 
can  be defined for every voice independently (that is  quite  an 
advantage).  Except  for  these,  a  kind  of  waveform  also  is 
implemented, that can not be used properly.

The musical qualities of the ST are thus significantly less  than 
those of the Commodore 64.  The tone  reproduction,  however,  is 
better:  The  SID of the 64 works analogue (so there'll  be  more 
ground  noise),  whereas the Yamaha chip of the ST works  digital 
(which takes care that a clearer note appears).

After programming many songs on the VIC 20 and Commodore 64, I of 
course  wanted to expand my sound programming experience  to  the 
ST.  Since  I had already programmed small  test-compositions  on 
the  Amstrad  (which  has the same  soundchip),  it  wasn't  that 
difficult to re-program my soundtool for the ST.  But I did  want 
to  build in a few extra options into my soundtool (which  I,  by 
the way, called SOund PROgramming Language) that would allow some 
extra sound effect possibilities.
The following sound effects can be established:

 The GLIDE effect:
The current note is continually increased and decreased.

 The MODULATION effect:
The  current  note is increased and than decreased all the  time. 
This produces a kind of VIBRATO, which makes the very 'flat' note 
of the ST sound a bit 'weaker'.

 The DOUBLE-TONE mode:
This  takes care that two different notes are toggled using  only 
one  tone generator.  This creates the impression that one  sound 
generator becomes two sound generators. The use of chords is much 
easier this way, and doesn't use that much sound generators.

 The BEND effect:
The next note is not directly played, but the program starts from 
the last played note and then increases/decreases to the  current 
note  (a  bit like the GLIDE effect).  This is  often  used  with 
electrical guitars.

 Volume modulation:
This is much alike the MODULATION effect,  but here the volume is 
continually increased or decreased.

 The TWO-VOLUMES mode:
Much  like the DOUBLE-TONE mode,  but here the volume is  toggled 
between two values continually.

 The NOISE-GLIDE effect:
This  sound effect is just like the GLIDE effect,  but this  time 
the  noise  genarators  that  can be mixed  into  the  sound  are 
increased and decreased all the time.  This effect can very  well 
be used to imitate drumming sounds.

Even  with all these features,  a proper tone quality  cannot  be 
reached.  That's  why I simulate the on the Commodore 64 so  well 
known waveform generator (ADSR). With SOPROL, this functions much 
like that on the 64,  but I included an additional  option:   The 
Attack-,  Decay-,  Sustain-and  Release  TIME  is  not  the  only 
variable thing,  but it's also possible to specify the step  size 
of  those.  This  feature  makes it easy  to  program  alienating 
effects.
The last problem is the use of the sound data in the source code. 
Since I only work with the K-Seka assembler from Kuma, this whole 
business became a bit tough, also because Seka doesn't offer that 
much user-service.
SOPROL controls every byte that it reads, to check if it's larger 
or equal to $F0.   If it is, that means that is has encountered a 
command.

The commands are:

$F0  JUMP      Jump to another position of the song
$F1  CALL      Call a sound-subroutine (e.g. if a part of a song
                has to be used several times)
$F2  RECALL    Jump back from a sound-subroutine
$F3  CHANGE    Change the sound effect settings
$F4  NOP       No operation

When the byte that was read comprised no  command,  SOPROL checks 
if  the  byte is larger than $C0.  If so,  that  means  that  the 
current tone-length has to be changed. The new tone-length can be 
calculated by: Length=Byte-$C0.

Whenever the byte that was just read is smaller than $C0,  SOPROL 
knows  that  an  actual  note  is  meant  here.  The  high-nibble 
comprises the octave and the low nibble the tone you wish.

Since  SOPROL  works  on  Interrupt  (using the  Vertical   Blank 
Interrupt queue,  ED.),  the main program has to write a  certain 
value on a certain memory location (I call this SONGFLAG most  of 
the time). The song corresponding with that number will be played 
until the value 0 is stored on SONGFLAG.

The first time I used SOPROL on the ST,  I used it in my  program 
called "Extensor",  which features five different songs. The next 
program I used it for was "Hollywood Poker".  Both programs  were 
published  through  Golden Games,  which I owned  for  50%  until 
recently.  Since I retreat from this company and will be  running 
my own software company called "ReLINE Software",  only  programs 
from "ReLINE" will feature SOPROL songs in the future.

I hope to have stimulated you to program sound on the ST by means 
of this article. Professional music is not only possibile through 
MIDI,  but  can  also be used if one works good enough  with  the 
generators of a sound tool or so.
Editorial Note:
Holger  Gehrmann  is a guy that programs  software  for  Amstrad, 
Commodore  64,  Commodore Amiga,  Atari ST and no  doubt  several 
other computers. It is amazing that he does things like this with 
the means he has (remember? He only uses K-Seka!). I hope he will 
continue  this  article  in the future,  in which  he  will  then 
explain the specific routines,  etc. But that's not sure. Anyway, 
he  will  soon supply us with some pieces of music  that  can  be 
included into our Synth Sample V...