Function generator gen02 allows us to type in the exact values we wish to place within a table. If we want a table of five numbers, we need a table size of "8" (since function tables must be powers-of-two or powers-of-two plus one). One other minor problem is that by default most Csound gen routines, including gen 2, normalize the values within the tables they create to a maximum value of floating point "1." Thus, the following call to gen2

would be normalized, with "1720" becoming "1." in the table and the first four values scaled proportionately. Preceding the call to gen02 with a minus sign, however :

will cause the normalization procedure to be skipped, giving us precisely the five integer values we have asked for in locations 0 through 4 of function table "90."

With all of the foregoing clear (yes?), we present the following instrument algorithm and score, in which we run an alternating series of white noise, pulse train and cymbal audio signals through a filter network that imposes a series of vowel-like formants upon these three sound sources. since the white noise sources tend to sound loud, and the cymbal sources soft, we have included amplitude adjustments to attentuate the white noise signals and boost the cymbal sources.

;  #############################################################
;  soundfile ex5-6 : 5 band-pass filters for vowel-like formant resonances
;  #############################################################
nchnls=1

instr 1
ivowelfunc=p10 ; table with resonances for male and female vowels 
kamp envlpx p5,  p6,  p3,  p7,  1,  p8,  .01 ; amplitude envelope
; ==== get source audio signal, determined by p9 =======
if (p9 == 0) then 
   asource  rand  kamp* .6 ; white noise source signal; these tend to 
     ;sound loud, so reduce amplitude of white noise sources by 40 % 
elseif (p9 == 1) then
;  generate a pulse train source signal :
   ipitch = cpspch(p4)  ; pitch for buzz
  if (ivowelfunc <= 87) then
     iharmonics = (5000/ipitch)  ; top frequency of 5000 for male resonances
       else
     iharmonics = (9000/ipitch) ; top frequency of 9000 for female resonances
   endif
   asource  buzz  kamp, ipitch,  iharmonics, 100  ; pulse train source signal
elseif (p9 == 2) then
    asource  soundin  p12 , p13
    asource = asource * 1.2 * (kamp/32767)  ; impose new envelope on soundfile
      ; the cymbals tend to sound soft, so increase their amp. by 20 %
else  ; user error; invalid p10 argument given 
   print p2, p10
   printks "ERROR. p10 must be 0, 1 or 2 . Aborting this note.\n", 1
   turnoff

endif
  ; - - - - - - - - - - -
;FILTER CENTER FREQUENCIES & RELATIVE AMPS. FROM FUNCTIONS 80-87, 90-94
iformant1 table 0, ivowelfunc   ; 1st formant frequency
iformant2 table 1, ivowelfunc   ; 2nd   "   "   "
iformant3 table 2, ivowelfunc   ; 3rd   "   "   "
iformant4 table 3, ivowelfunc   ; 4th   "   "   "
iformant5 table 4, ivowelfunc   ; 5th   "   "   "
iamp1 table 5, ivowelfunc   ; relative amplitude of 1st formant
iamp2 table 6, ivowelfunc   ;    "    "    "    "   2nd
iamp3 table 7, ivowelfunc  ;    "    "    "    "   3rd
iamp4 table 8, ivowelfunc  ;    "    "    "    "   4th
iamp5 table 9, ivowelfunc  ;    "    "    "    "   5th

;  5 first order BANDPASS FILTERS TO SUPPLY THE 5 FORMANTS
a2 resonx iamp1*asource, iformant1, 1.2*p11 * iformant1,1, 1	
a3 resonx iamp2*asource, iformant2, 1.05*p11 * iformant2,1, 1
a4 resonx iamp3*asource, iformant3, .9*p11 * iformant3,1, 1
a5 resonx iamp4*asource, iformant4, .8*p11 * iformant4,1, 1
a6 resonx iamp5*asource, iformant5, .7*p11 * iformant5,1, 1
aformants  = a2 + a3 + a4 + a5 + a6
aout   balance aformants , asource   ; restore amplitude lost in filtering
   out aout
endin
----------------------------------------------------------- 
 < score11 file  for ex5-6

   < Score11 file used to create Eastman Csound Tutorial soundfile example
   < ex5-6 : 5 bandpass filters used to create vowel-like timbres
* f1 0 65 7 0 40 .75 4 .70 20 1.;	

     ares comb   asig, krvt, ilpt [, iskip] [, insmps]
     ares alpass asig, krvt, ilpt [, iskip] [, insmps] 

loop-feedback time  SR = 44100   SR = 96000   Frequency of lowest peak
                    # of peaks   # of peaks   (and spacing between peaks)%
     .001              22          48           1000Herz
     .002              44          96            500
     .003              66          144           333.33
     .004              88          192           250
     .005             110          240           200
     .006             132          288           166.67
     .007             154          336           166.67
     .008             176          384           142.86
     .009             198          432           111.11
     .01              220          480           100
     .02              441          960            50

; #############################################################
 ;  soundfile ex5-7    :  Comb filter        Csound Tutorial
 ;  #############################################################
 nchnls=1

 ; p4  = soundin.#   sflink  number
 ; p5 = amplitude multiplier      ; p6 = skip from front of soundfile
 ; p7 = exponential fade in time ; p8 = exponential fade out time
 ;  comb filter:  p9  =  comb reverb time , p10  =  comb loop time

instr 10

indur=p3 ; duration of input signal specified in the score
 p3 = p3 + .5 ; add .5 seconds to output duration for comb output
              ; reverberation to decay to 0
 audio soundin p4 , p6

 ;    output amplitude envelope: includes optional fade-in & fade-out  and
 ;    .5 seconds at end to mute any input signal
 iamp  = (p5 = 0 ? 1: p5 )
         ifadein  = (p8 =0?.001:p8 )
         ifadeout  = (p8 =0?.001:p8 )
 kamp expseg .01,ifadein ,iamp,indur-(ifadein +ifadeout ),iamp,ifadeout ,.01 , .5 , .001
 audio = audio * kamp

 aout  comb audio ,p9, p10
 out aout
 endin
 -----------------------------------------------------------
  < ECMC Csound Library Tutorial score11 input file >>  ex5-7 << : 
   < Score11 file used to create Eastman Csound Tutorial soundfile examples
   < ex5-7 & ex5-8: comb & alpass filter examples
< This score uses inputsoundfile /snd/sflib/perc/bongo1.roll.wav
< To create a link numbered 13 to this soundfile type:  
<    sflinksfl bongo1.roll 13
i10 0 0 7;         < mono input, default mono output
p3 2;                                                     
du  301.17 ;  < .5" will be added to this duration in the orchestra
p4 13;  < soundin.# : soundin.13 points to /sflib/perc/bongo1.roll
p5 .5;                             < ampfac
p6                                 < duration skipped from front of sf
p7                                   < fade in time
p8 .05;                              < fade out time
p9 nu 0/.1/.25/.7/.3///;    < comb or alpass reverb time
p10 nu .002*4/.005/.017/.033;  < comb or alpass loop time
end; 
 ----------------------------------------------------------- 

Notice in the score that the first value in p9 (which sets the reverberation time for the comb filter) is 0, so the comb filter has no effect on this note. In notes 2,3 and 4 p9 is increased (from .1 to .7), so the reverberation becomes progressively longer and the pitched coloration more pronounced.

With alpass filters, the peaks and nulls, and the resulting coloration of the input sound, are less pronounced, especially when the reverberation time is low. alpass filters do add a coloration to a sound resulting from phase cancellation and reinforcement, but the emphasized frequencies are continuously changing, so that over time the alpass filter passes all frequencies equally.

Orchestra file ex5-8 is identical to orchestra ex5-7 above, except that an alpass filter is substituted for the comb filter. If you listen to and compare soundfiles /sflib/x/ex5-7.wav and /sflib/x/ex5-8.wav, the principal audible differences between comb and alpass filtering should be evident.

 ; #############################################################
 ;  soundfile ex5-8    :  Alpass filter        Csound Tutorial
; Note: score11 file ex5-7 is used as the score for this instrument
 ;  #############################################################

 nchnls=1
instr 10

indur=p3 ; duration of input signal specified in the score
 p3 = p3 + .5 ; add .5 seconds to output duration for alpass output
              ; reverberation to decay to 0
 audio soundin p4 , p6

 ;    output amplitude envelope: includes optional fade-in & fade-out  and
 ;    .5 seconds at end to mute any input signal
 iamp  = (p5 = 0 ? 1: p5 )
         ifadein  = (p8 =0?.001:p8 )
         ifadeout  = (p8 =0?.001:p8 )
 kamp expseg .01,ifadein ,iamp,indur-(ifadein +ifadeout ),iamp,ifadeout ,.01 , .5 , .001
 audio = audio * kamp

 aout  alpass audio ,p9, p10
 out aout
 endin

In both of the preceding examples, 100 % of the input soundfile was sent through the comb or alpass filter, and the output from the instrument consisted solely of the filtered output. More often, however, only a portion of the input signal (say, somewhere between 20% and 60 %) is sent to comb or alpass, and the remaining direct signal is sent straight out. Generally a p-field is introduced in the orchestra and score to handle this wet/dry mix, as in ex5-9 below.

It is easy to tune the resonant output of a comb filter to a particular pitch. ex5-9 imposes the pitches of a harmonic minor scale on an alternating series of bongo roll, tam tam, babbling brook and gong input soundfiles. If you want to compile a soundfile yourself with this orc/sco pair you must create links to these soundfile so that unit generator soundin can find them. Do this by typing: mktutsflinks if you have not already done this for earlier orc/sco examples.

; #############################################################
 ;  soundfile ex5-9  :  Tuning comb filters        Csound Tutorial
 ;  #############################################################
 nchnls=1

 ; p4  = soundin.#   sflink  number
 ; p5 = amplitude multiplier      ; p6 = skip from front of soundfile
 ; p7 = exponential fade in time ; p8 = exponential fade out time
 ;  comb filter: p9  =  comb reverb time , p10 = comb  resonant. freq.
 ; p11 = wet/dry mix

instr 10
indur=p3 ; duration of input signal specified in the score
 p3 = p3 + .5 ; add .5 seconds to output duration for comb output
              ; reverberation to decay to 0
 ain soundin p4 , p6

 ;    output amplitude envelope: includes optional fade-in & fade-out  and
 ;    .3 seconds at end to mute any input signal
 iamp  = (p5 = 0 ? 1: p5 )
         ifadein  = (p8 =0?.001:p8 )
         ifadeout  = (p8 =0?.001:p8 )
 amp expseg .01,ifadein ,iamp,indur-(ifadein +ifadeout ),iamp,ifadeout ,.01 , .3 , .001
 ain = ain * amp
icombpitch = (p10 < 13.0 ? cpspch(p10) : p10 ) ; comb pitch in cps or pch
iloop = 1/icombpitch
print p10, icombpitch, iloop
 acomb  comb ain ,p9, iloop
 out (p11 * acomb ) + ((1. -p11) * ain)
 endin
----------------------------------------------
  < ECMC Csound Library Tutorial score11 input file >>  ex5-9 << : 
< This orc/sco pair uses soundin to read in sflib soundfiles
< Before you can run this orc/sco you must create links to these soundfile
< The easiest way to do this is to type:   mktutsflinks
i10 0 0 8;         < mono input, default mono output
p3 1;                                                     
du  301.17 ;  < .5" will be added to this duration in the orchestra
p4 nu 13/5/20/7; < soundin.# : 
 < 13 = bongo1.roll, 5 = tam, 20 = brook 7 = gong.ef3
p5 .4;                                 < ampfac
p6                                     < duration skipped from front of sf
p7  .2;                                   < fade in time
p8 .2;                                 < fade out time
p9 nu .1/.3/.6/.9;          < comb or alpass reverb time
< p10 desired output resonant pitch or freq. of the comb filter
p10 no c4/d4/ef/f/g/af/b/c5; < harmonic minor scale
p11 nu .8/.7/.6/.5;      < wet/dry mix : % wet signal
end;
----------------------------------------------

For the adventurous, the opcodes vcomb and valpass allow one to vary the loop time (and thus the coloration, or "pitch") as well as the reverberation time within a "note" or "event."

Reverberation unit generators

There are two basic ways to employ digital signal processing today to add "artificial" reverberation to computer-generated sounds:

1. Algorithms based on delay lines (comb, alpass and other types of filters). This is the traditional approach. The results can sound cheesy or quite good, depending upon the quality of the reverberation algorithm. High quality algorithms tend to be slow and resource-intensive.
2. Convolution algorithms, which require an impulse response file of a resonant space, such as a concert hall like Kilbourn. Several convolution opcodes, including convolve, dconv and pconvolve, are available in Csound for performing this type of reverberation. can be a trickly process.

   The convolve opcode employs Fast Fourier Transform (fft) procedures similar to (though considerably faster than) convolution procedures) to filter an input soundfile through the time varying impulse response characteristics of a particular concert hall or other acoustic space. Several steps are necessary to accompish this operation. We will describe these steps briefly here, but a full orc/sco example is beyond the current scope of this tutorial.

   • One must obtain or record a suitable impulse response soundfile. Typically, such soundfiles contain the recording of a single, sharp, very short impulse (a sample value of 1 followed by many zeros) recorded in a particular hall, to capture the reverberant qualities of this acoustical space. Some suitable impulse resonse soundfiles can be downloaded over the Internet. (For example, links to collections of impulse response soundfiles can be found at http://www.csounds.com/resources/impulses.html).
   • Next, one must convert this impulse response soundfile into an FFT frame with the Csound cvanal utility.
   • Finally, one constructs an orchestra file, similar to the example provided in the Csound manual discussion of convolve, along with a companion score file, to apply the reverberant qualities of the impulse response file to an input soundfile. At times, this can be a complicated process, particularly with regard to achieving accurate time synchronization between the dry input signal and the reverberant convolution signal.

For accurate and effective spatial imaging of sounds, left to right, front to back and high to low, ambisonic processing and decoding over 2, 4, 6, 8 or more loudspeakers can be very effective. If you want to add ambisonic processing to one of your Csound instruments, you can use a script called mkob and, for score files, getscb to add Csound code and p-fields to existing orchestra and score files. The ecmchelp file named mkob can get you started, but this help file is not yet complete, and you should see me for additional help if you wish to try this out. (Warning: It will take you a few hours to get a handle on how to use mkob and getscb.) Ambisonic processing, by itself, does not create reverberation, but rather relies upon the use of an existing reverberation algorithm for this aspect of the sound spatialization.

Sometimes we do not need or wish to devote the time and energy to fussing with ambisonic processing or convolution reverb, and simply need to add some decent-sounding reverberation to audio signals. This is the situation we will address here, and we will look at some relatively quick procedures for adding delay line-based reverberation to the output of existing Csound instruments.

Delay line-based reverberators: freeverb

The original Csound unit generator, called reverb, was based on an algorithm developed by Schroeder that combines four comb filters in parallel followed by two alpass filters in series :

                         -----comb 1--------
                         |                 |
                         |-- -comb 2-------|
                         |                 |
    audio input signal ->>                 + --alpass1---alpass2 --> out
                         |                 |
                         |----comb 3-------|
                         |                 |
                         |----comb 4-------|

Each of the filters has a different, prime number loop time (none of which are related by simple ratios). As a result, the overall frequency response is relatively flat, without the obvious pitch coloration of individual comb filters. However, the design of opcode reverb, now more than thirty years old, is not very sophisticated by today's standards. The reverberant signal sometimes includes an annoying flutter or twang, or may hiss like a rattlesnake, and I do not recommend using this old geezer. Opcodes nreverb and reverbsc are better, but of the available delay-line based reverberators available in Csound, I recommend using freeverb, a Csound implementation of the free software stereo out freeverb reverberation algorithm that uses 8 comb filters in parallel followed by four alpass filters in series -- a total of 12 filters per channel.

The arguments to freeverb are

 aoutL, aoutR freeverb ainL, ainR, kRoomSize, kHFDamp[, iSRate[, iSkip]] 

1. aout and aoutR are the left and right channel reverbated outputs
2. ainL and ainR are the left and right channel inputs; for mono-in, stereo-out, the same signal can be sent to both of these inputs.
3. kRoomSiz, which should be given an argument between 0 and 1, controls the reverberation time and thus the virtual size of the room. The higher the value, up to 1.0, the "larger" the room and the longer the reverberation time.
4. kHFDam, which also should be set between 0 and 1, attempts to simulate control of high frequency diffusion (how quickly high frequencies decay relative to lower frequencies). In natural (acoustic) room reverberation, high frequencies almost always decay more quickly than lower frequencies. The more sound aborptive material in a room, and the larger the size of the room, the greater the discrepancy between high and low frequency decay rates. High kHFdamp values, between about .7 and 1. (the maximum usable value), tend to produce a "drier", "pingier" (more "staccato") reverberant ambience, like a room with high absorptive coefficients (e.g. a room with thick rugs and drapes and many soft, porous surfaces). When kHFdamp is set to a low value (between about .2 and 0), the reverberation is "wetter," "brighter" for sounds with high frequency spectra and "boomier" for lower pitched sounds, simulating the ambience of a room with hard, reflective surfaces (e.g. cement block walls). Think of the reverberation time (kRoomSize) argument as determining the size of the reverberant room and the (kHFdamp) diffusion parameter as determining the "acoustical treatment" of this room and season to taste. kHFdamp values between about .5 and .8 are most common.
5. The optional iSRate argument normally should be set to the global variable sr. The output of freeverb may sound slightly different at different sampling rates.
6. Unless you really know what you are doing, the optional iSkip argument should be left blank (set to 0).

Note that both kRoomSize and kHFdamp are k-rate arguments, and thus can be varied withan a "note event" by a control signal, and thus it theoretically is possible to vary the size of the reverberant space (turning Kilbourn into the Eastman Theatre) or its absorptive characteristics (removing the curtains and carpets) while a note is being played. Obviously this is not common, however, and may lead to artifacts.

Without breaking much of a sweat, we could modify the orchestra and score files of ex5-9 to add post-processing reverberation, rather than comb filtering, to our soundfile. We would substitute unit generator freeverb for comb within the orchestra file, use score p9 to control kRoomSize, change p10 to control kHFdamp, and continue to use p11 to determine the wet/dry signal mix. We also could change the output to stereo, and add another score p-field to control the left-right pan location of each output note:

    ; p9 = room size (0 to 1 )
    ; p10 = high freq. damping (0 to 1)
    ; p12 = 0 to 1, hard left to right stereo pan location
   ipanL = sqrt(p12) ;  % of mono input to left channel
   ipanR = sqrt(1. -p12) ; % of mono input to right channel
   arevL, arevR freeverb ipanL * ain, ipanR * ain, p9 , p10, sr; apply reverberation to input signal 
   aoutL = (p11 * arevL) + ((1. - p11) * ain) ; wet-dry mix, left channel 
   aoutR = (p11 * arevL) + ((1. - p11) * ain) ; wet-dry mix, right channel 
   outs aoutL, aoutR

Then, with random selection score values for p9, p10, p11 and p12 such as the following

p9 1. .2 .8 ;  < randomly vary room size, small to large, for each note
p10 1. .1 .6;  < randomly vary   high freq. damping, dull ti=o fairly bright
p11 1. .1 .6;  <  randomly vary wet/dry mix
p12 .5 .1 .4 .5 .6 .9 ;   < randomly vary L/R pan location 

we could randomly place each output note in a different left-right and "close-distant" ("dry-wet") location, and also vary the apparent room size (reverberation) time and high frequency diffusion ("room brightness") to place each "note" in a "different hall."

This probably seems a little extravagant, and it also may make our instrument slow and a resource hog. If we create a score in which ten or so notes are sounding simultaneously, each with its own freeverb opcode containing 12 delay-line filters per channel crunching away and consuming RAM, our Csound compile job may slow to a crawl.

Moreover, we generally do not wish to vary all such post-processing operations so radically from one note to the next. Most often, we simply wish to mix together all of the notes being produced by a given instrument, and then apply a uniform reverberant quality this passage. In order to perform such "global" signal processing operations with Csound, we need to create a separate global instrument within our orchestra file.

5.6. Global Instruments

Global instruments often do not generate any audio signal themselves, but instead are often used for post-processing, modifying audio signals that have been generated and mixed together by other instruments within the orchestra file. Often, a global post-processing instrument such as a reverberator or delay line will "play" only one "note," or "event." The instrument is turned on at the beginning of a passage, receives audio input from all of the notes created by one or more 'source" instruments, processes this audio input (e.g. by adding reverberation) and sends it to Csounds output buffer(s), and then is turned off when all input and output are completed. (Occasionally, however, global instruments are employed by advanced users instead as pre-processors, establishing certain variables that will be accessed by other instruments within an orchestra file, or even turning copies of other instruments on and off.) There are a few unique aspects to dealing with global instruments that we have not yet encountered.

Local and Global Variables
[ Recommended: See the discussion of global variables within the discussion of Constants and variables in the Csound Reference manual. However, this page also includes information on topics not directly related to global variables, so you may find portions of this reference page confusing. ] manual ]

All of the i-rate, k-rate and a-rate variables we have looked at so far, with the exception of the header arguments sr, kr, ksmps and nchnls, have been local variables. Local variables, such as "p4," "ipitch," "kenv," "kmart" (remember?) and "a1," are only used, and can only be accessed, by one copy (created by one note event, or I statement, within the score file) of one instrument. Several copies of an instrument can be "playing" simultaneously ("polyphonically"), each with a different ipitch and/or kenv value, without colliding. This is because the ipitch or kenv value for each copy is written to a unique ("local") RAM memory location that can only be accessed by this copy.

After Csound computes a sample for one instrument copy, it zeros out all of the a-rate local variables, creating these values from scratch on each sample pass. When it completes a control (k-rate) cycle of samples for an instrument copy, it zeros out all the local k values, updating them at the beginning of the next k-rate pass.

Global variables, by contrast, can be accessed by all copies of all instruments currently in memory. Global variables can be created and updated at the i-rate, k-rate or a-rate, and are preceded by a "g", with output variable names such as gireverbtime (a global initialization variable), gkpitch, (a global k-rate variable) and gaudio. The values a1 and ga1 within an instrument are entirely distinct.

One other important distinction must be noted : global k-rate and a-rate values are not zeroed out at the end of each control or sample pass. Rather, these values are CARRIED OVER from one pass to the next. For this reason, it is necessary to initialize these variables -- to set them to some initial value (most often to zero) -- with statements such as :

All global variables that will be used in an orchestra must be initialized before the first i-block, immediately after the header and before the first instrument definition (just as variables normally are declared near the top of programs in languages such as C). These variables can then be accessed and operated upon by any instrument, through such operations as:

This means : Add the current value of local variable audio to the current value of global variable ga1, then assign the result as the new value of ga1

After all processing has been completed at the end of a sample calculation, or at the end of a control (k) rate cycle of sample calculations, it often is necessary to zero out global control and audio signals to prevent feedback, like this:

The following orchestra file contains two instruments. The first instrument, wich provides the source audio signals, is a reworking of the gbuzz based orchestra file used in ex4-4. The output has been modified, so that the output of this instrument now is stereo rather than mono. Additionally, the instrument does not write its output to a hard disk soundfile, or send it directly to the DACs for realtime playback, but rather sends its outputs to a global reverberation instrument based on unit generator freeverb.

;  #############################################################
;  Orchestra file  ex5-10 : global instrument freeverb
; used to create sflib/x soundfiles ex5-10-1.wav and ex5-10-2.wav
;  #############################################################
nchnls=2
; global variables:
galeft init 0 ; global variable
garight init 0 ; global variable

instr 1
kamp expseg 1,.2*p3,20000,.7*p3,8000,.3*p3,1    ; amplitude envelope
iampmult = (p10 = 0 ? 1. : p10)
kamp = kamp * iampmult

; glissando :
   ipitch1 = (p4 > 0 ? cpspch(p4) : abs(p4)) ; negative values = cps
   ipitch2 = (p5 > 0 ? cpspch(p5) : abs(p5)) ; negative values = cps
kgliss expseg ipitch1,.2*p3,ipitch1,.6*p3,ipitch2,.2*p3,ipitch2

krenv expseg p8,.5*p3,p9, .5*p3,p8 ; kr envelope

abuzz gbuzz kamp,kgliss,p7,p6,krenv,1 
afilt tone abuzz,1500            ; filter out spurious high freuqncies
;  outs sqrt(p11) * afilt, (sqrt(1. - p11) * afilt)
galeft = galeft + (sqrt(p11) * afilt)
garight = garight + (sqrt(1. - p11) * afilt)
endin
; -----  global reverberation instrument ------------
instr 99
   iroomsize = p4
   ihifreqdamp=p6
   iwet = p7
   iglobalamp = (p5 = 0 ? 1. : p5)
denorm galeft, garight ; guard against denormals on Intel processors
aoutL, aoutR freeverb galeft, garight, iroomsize, ihifreqdamp, sr
  aoutL = aoutL * iglobalamp
  aoutR = aoutR * iglobalamp
  galeft = galeft * iglobalamp
  garight = garight * iglobalamp
outs1 (iwet * aoutL) + (( 1. - iwet) * galeft) ; left channel output
outs2 (iwet * aoutR) + (( 1. - iwet) * garight) ; right channel output
   galeft=0
   garight=0
endin
--------------------------------------

The denorm opcode immediately above freeverb in the global instrument addresses a long-standing bug on Intel processors, which sometimes slow to a crawl when dealing with very small numbers such as might be produced by the end of a reverberant fade-out. denorm mixes a tiny amount of noise into low level signals, which generally eliminates the problem. In this case, noise is added to both of the two global audio signals, galeft and garight.

Two very similar scores are provided for this instrument. Example score ex5-10-1 adds just a touch of reverberation to the output of the gubzz instrument. p7 in instr 99 (the global reverb instrument) sets the wet/dry mix to 60 % direct (dry) signal and 40 % reverberant signal. p6 in the score for the reverberant instrument sets the kHFdamp to .6, which will cause higher frequencies to decay rather quickly. (See the discussion of the kHFdamp argument to freeverb above.)

  < ECMC Csound Library Tutorial score11 input file >>  ex5-10-1 << : 
   < Score11 file used to create Eastman Csound Tutorial soundfile example
 < /sflib/x/ex5-10-1.wav
   < source sounds from ex4-4 gbuzz sub-audio fundamental and glissando
* f1 0 2048 9 1 1 90;          < cosine function required by gbuzz

i1 0 0 4;   < gbuzz instrument -- creates source sounds
p3 nu 2/2.5/3./3.5;
du nu 307./306/305.5/305;
p4 nu -16/-8.5/-53/-22;           < 1st fundmental freq.
p5 nu -14.5/-9/-49/-37;          < 2nd fundmental freq.

p6 nu 3/42/13/7;              < lowest harmonic (1=fundamental)
p7 nu 40/10/40/12;               < number of harmonics

p8 nu .5/.8/.3/ 1.2;               < kr1 (amplitude multiplier) 1 (start & end)
p9 nu .9/1.4/.9/.4;               < kr2 (amplitude multiplier) 1 (middle)
p10  nu 1.2/1./.7/1.;        < amp. multiplier
p11 nu .2/.6/.9/.3;              < spatial placement 0 = L, 1. = R
end;
< -   -   -   -   -   -   -   -   -   -   -   -
i99 0 0 1;   < global reverberation instrument
p3 13.3 ; 
p4 .6;        < room size, 0 (very small) to 1, (very large)
p5            < global amplitude multiplier
 < fairly dry mix (p7 = .4), high freqs. decay fairly quickly (p6 = .6)
p6  .6;       < high freq. damping, 0 (very bright) to 1. ( dull)
p7  .4;       < wet dry mix: 0 = all wet, 1 = all dry
end;
-------------------------------------------------

Our second score for orchestra file ex5-10, score file ex5-10-2, is nearly identical to the score file above, but differing only in the values for p6 and p7 in the global instruments. This time the wet/dry mix is set to 70 % wet, 30 % dry, and a low p6 value of .2 causes high frequencies to ring much longer than in the previous score.

  < ECMC Csound Library Tutorial score11 input file >>  ex5-10-2 << : 
   < Score11 file used to create Eastman Csound Tutorial soundfile example
 < /sflib/x/ex5-10-2.wav
   < source sounds from ex4-4 gbuzz sub-audio fundamental and glissando
* f1 0 2048 9 1 1 90;          < cosine function required by gbuzz

i1 0 0 4;   < gbuzz instrument -- creates source sounds
p3 nu 2/2.5/3./3.5;
du nu 307./306/305.5/305;
p4 nu -16/-8.5/-53/-22;           < 1st fundmental freq.
p5 nu -14.5/-9/-49/-37;          < 2nd fundmental freq.
p6 nu 3/42/13/7;              < lowest harmonic (1=fundamental)
p7 nu 40/10/40/12;               < number of harmonics

p8 nu .5/.8/.3/ 1.2;               < kr1 (amplitude multiplier) 1 (start & end)
p9 nu .9/1.4/.9/.4;               < kr2 (amplitude multiplier) 1 (middle)
p10  nu 1.2/1./.7/1.;        < amp. multiplier
p11 nu .2/.6/.9/.3;              < spatial placement 0 = L, 1. = R
end;
< ---------------------------------------------------
i99 0 0 1;   < global reverberation instrument
p3 13.3 ; 
p4 .6;        < room size, 0 (very small) to 1, (very large)
p5            < global amplitude multiplier 
 < wet mix (p7 = .7, high freqs. decay slowly (p6 = .2)
p6  .2;       < high freq. damping, 0 (very bright) to 1. ( dull)
p7  .7;      < wet dry mix: 0 = all wet, 1 = all dry
end;
------------------------------------------------

Often, when learning or using a powerful but potentially complex sound synthesis or processing language such as Csound, Pure Data or Super Collider, it is necessary or more efficient to break a complex task into a series of manageable stages, and to make sure that each stage or module works, and is under your control, before adding more processing operations. If you try to do all of these stages at once, you may get a slew of error messages and not be sure where to begin to correct all of your problems. Part of designing synthesis algorithms is knowing how to break down multi-stage tasks into workable modules. The final two orc/sco examples in this chapter will provide an example.

I would like to modify and extend the gbuzz instrument in example ex4-4, changing it from mono output to 4 channel quad (not ambisonic B format, but traditional cinema-style quad output). Additionally, I would like to add a delay line with feedback to create echos, and to distribute these echos through the four channel output. We will break this potentially complicated task into two stages:

1. In ex5-11 we will modify the original ex4-4 instrument for quad playback, without delay line echos.
2. Once this is working, we will add a global isntrument to produce the echos.

Quad output

The quad audio channels and four Genelec loudspeakers in the Linux sound room are numbered as two stereo pairs:

     channel 1: left front speaker      channel 2: right front speaker
     channel 3: left rear speaker       channel 4: right rear speaker

To modify our orchestra for quad playback one of the first things we need to do is to devise a way to specify quad sound localization points on a simple numberical scale. There are several methods we could use to do this. The method we will employ here is to think of the four speakers as comprising the corners of a square, and sound locations, with values ranging from 0 to 1.0, falling along four imaginary perimeter lines connecting the four speakers. Zero (0) will represent the left front speaker; .25 (25 % of the way along the perimeter) will represent the right front speaker; .5 will represent the right rear speaker and .75 the left rear speaker, and 1.0 againrepresenting the left front speaker. The four speakers are denoted by an X in this diagram:

  0,1.0     .125     .25
     X---------------X
     |    front      |
     |               |
.875 |   Listeners   | .375
     |               |
     |    rear       |
     X---------------X
   .75     .675      .5

Note that we will try to position sounds only along the perimeter of the square and not inside the square, which is rarely sucessful with standard quad processing. (The limitations of cinema-style multichannel playback are discussed in section 7.2 of the ECMC Users' Guide). Now, with a single p-field (p12 in score1 files ex5-11 and ex5-12 below), we can specify the quad perimeter localization for each sound with a numerical values ranging between 0 and 1.0. (p11 is not used in orchestra or score file ex5-11. We are saving this p-field to specify the ratio of direct to delayed signal when we add code for a delay line in ex5-12 which follows.)

In the orchestra and score files for ex5-11 below, additions to the Csound code and score file to ex4-4 that we have added here to implement quad spatialization are provided in bold font:

;  #############################################################
;  Orchestra file  ex5-11 : reworking of ex4-4 gbuzz orchestra
; for quad output
;  #############################################################
nchnls=4

instr 1
kamp expseg 1,.2*p3,20000,.7*p3,8000,.3*p3,1    ; amplitude envelope
iampmult = (p10 = 0 ? 1. : p10)
kamp = kamp * iampmult

; glissando :
   ipitch1 = (p4 > 0 ? cpspch(p4) : abs(p4)) ; negative values = cps
   ipitch2 = (p5 > 0 ? cpspch(p5) : abs(p5)) ; negative values = cps
kgliss expseg ipitch1,.2*p3,ipitch1,.6*p3,ipitch2,.2*p3,ipitch2

krenv expseg p8,.5*p3,p9, .5*p3,p8 ; kr envelope

abuzz gbuzz kamp,kgliss,p7,p6,krenv,1 
afilt tone abuzz,1500            ; filter out spurious high freuqncies
 ; quad spatial placement ----------------------------------------
 ; audio signal spatial locatization to four output channels:
if ((p12 >= 0) && (p12 <= .25))  then   ; p12 is btw 0 & .25
  ileftfront = sqrt((.25 - p12) * 4)
  irightfront = sqrt(p12 * 4)
     print p2, p12, ileftfront, irightfront
   outq1 ileftfront * afilt
   outq2  irightfront * afilt
elseif ((p12 > .25) && (p12 <= .5))  then   ; p12 is btw  .25 & .5
  irightfront = sqrt((.5 - p12) * 4)
  irightrear = sqrt(1. - irightfront)
      print p2, p12 , irightfront , irightrear
  outq2 irightfront * afilt 
  outq3 irightrear * afilt
elseif ((p12 > .5) && (p12 <= .75))  then   ; p12 is btw  .5 & .75
  irightrear = sqrt((.75 - p12) * 4)
  ileftrear = sqrt(1. - irightrear)
      print p2, p12 , irightrear , ileftrear
  outq3 irightfront * afilt
  outq4 irightrear * afilt
elseif ((p12 > .75) && (p12 <= 1.))  then   ; p12 is btw  .75 & 1.
  ileftrear = sqrt((1. - p12) * 4)
  ileftfront = sqrt(1. - ileftrear)
      print p2, p12 , ileftrear , ileftfront
  outq4 ileftrear * afilt
  outq1 ileftfront * afilt
else  ; bad  argument, either > 1. or negative
  print p2, p12
  printks "ERROR: Invalid value for p12, which must be between 0 and 1.0. Aborting this note.", 1
  turnoff
endif

endin
------------------------------------------------------
  < ECMC Csound Library Tutorial score11 input file >>  ex5-11 << : 
   < quadraphonic remake of ex4-4 gbuzz orchestra
* f1 0 8192 9 1 1 90;          < cosine function required by gbuzz

i1 0 0  4;  < gbuzz instrument -- creates source sounds
p3 nu 2/2.5/3./3.5;
du  nu 307./306/305.5/305;
p4 nu -16/-8.5/-53/-22;           < 1st fundmental freq.
p5 nu -14.5/-9/-49/-37;          < 2nd fundmental freq.

p6 nu 3/42/13/7;              < lowest harmonic (1=fundamental)
p7 nu 40/10/40/12;               < number of harmonics

p8 nu .5/.8/.3/ 1.2;               < kr1 (amplitude multiplier) 1 (start & end)
p9 nu .9/1.4/.9/.4;               < kr2 (amplitude multiplier) 1 (middle)
p10  nu 1.2/1./.7/1.;        < amp. multiplier
< p11  not used
 < p12 : quad: counter-clockwise circular spatial placement: 0 to 1.0
 < 0 & 1. = left front, .25 = right front, .5 = right rear, .75 = left rear
< p12 = spatial placement clockwise 0 (front left) to 1 (front left)
< .25 = front right, .5 = rear right, .75 = rear left, 1. = front left
p12 nu .1/.3/.6/.85;              
end;
-------------------------------------------------------

     p12 nu .1/.3/.6/.85;

;  #############################################################
;  Orchestra file  ex5-12 : quad global delay line w/ feedback
; used to create sflib/x soundfiles ex5-12
;  #############################################################
nchnls=4
gadelfrontleft init 0 ; global delay variable for front left speaker
gadelfrontright init 0 ; global delay variable for front right speaker
gadelrearright init 0 ; global delay variable for rear right speaker
gadelrearleft init 0 ; global delay variable for rear left speaker
gadelfeedback1 init 0 ; global feedback delay signal front left
gadelfeedback2 init 0 ; global feedback delay signal front right
gadelfeedback3 init 0 ; global feedback delay signal rear right
gadelfeedback4 init 0 ; global feedback delay signal rear left

instr 1   ; source gbuzz instrument
kamp expseg 1,.2*p3,20000,.7*p3,8000,.3*p3,1    ; amplitude envelope
iampmult = (p10 = 0 ? 1. : p10)
kamp = kamp * iampmult

; glissando :
   ipitch1 = (p4 > 0 ? cpspch(p4) : abs(p4)) ; negative values = cps
   ipitch2 = (p5 > 0 ? cpspch(p5) : abs(p5)) ; negative values = cps
kgliss expseg ipitch1,.2*p3,ipitch1,.6*p3,ipitch2,.2*p3,ipitch2

krenv expseg p8,.5*p3,p9, .5*p3,p8 ; kr envelope

abuzz gbuzz kamp,kgliss,p7,p6,krenv,1 
afilt tone abuzz,1500            ; filter out spurious high freuqncies
 ; quad spatial placement ----------------------------------------
idelay=p11  ; % delayed signal
idirect = (1. - p11) ; % direct signal
adirect = idirect * afilt 
adelay = idelay * afilt
 ; direct signal spatial locatization:
if ((p12 >= 0) && (p12 <= .25))  then   ; p12 is btw 0 & .25
  ileftfront = sqrt((.25 - p12) * 4)
  irightfront = sqrt(p12 * 4)
     print p2, p12, ileftfront, irightfront
   outq1 ileftfront * adirect ; output direct signal, left front
   outq2  irightfront * adirect ; output direct signal, right front
elseif ((p12 > .25) && (p12 <= .5))  then   ; p12 is btw  .25 & .5
  irightfront = sqrt((.5 - p12) * 4)
  irightrear = sqrt(1. - irightfront)
      print p2, p12 , irightfront , irightrear
  outq2 irightfront * adirect 
  outq3 irightrear * adirect
elseif ((p12 > .5) && (p12 <= .75))  then   ; p12 is btw  .5 & .75
  irightrear = sqrt((.75 - p12) * 4)
  ileftrear = sqrt(1. - irightrear)
      print p2, p12 , irightrear , ileftrear
  outq3 irightfront * adirect
  outq4 irightrear * adirect
elseif ((p12 > .75) && (p12 <= 1.))  then   ; p12 is btw  .75 & 1.
  ileftrear = sqrt((1. - p12) * 4)
  ileftfront = sqrt(1. - ileftrear)
      print p2, p12 , ileftrear , ileftfront
  outq4 ileftrear * adirect
  outq1 ileftfront * adirect
else  ; bad  p12 argument, either > 1. or negative
  print p2, p12
  printks "ERROR: Invalid value for p12, which must be between 0 and 1.0. Aborting this note.", 1
  turnoff
endif
; --------------  delay line  quad location ---------
idelspace = frac(p12 + .5) ; shift direct signal spacial placement by 180 degrees
if ((idelspace >= 0) && (idelspace <= .25))  then   ; idelspace is btw 0 & .25
  idelleftfront = sqrt((.25 - idelspace) * 4)
  idelrightfront = sqrt(idelspace * 4)
     print  idelspace, idelleftfront, idelrightfront
   gadelfrontleft = gadelfrontleft + (idelleftfront * adelay)
   gadelfrontright = gadelfrontright + (idelrightfront * adelay)
elseif ((idelspace > .25) && (idelspace <= .5))  then   ; idelspace is btw  .25 & .5
  idelrightfront = sqrt((.5 - idelspace) * 4)
  idelrightrear = sqrt(1. - idelrightfront)
      print  idelspace , idelrightfront , idelrightrear
  gadelfrontright = gadelfrontright + (idelrightfront * adelay)
  gadelrearright = gadelrearright + (idelrightrear * adelay)
elseif ((idelspace > .5) && (idelspace <= .75))  then   ; idelspace is btw  .5 & .75
  idelrightrear = sqrt((.75 - idelspace) * 4)
  idelleftrear = sqrt(1. - idelrightrear)
      print  idelspace , idelrightrear , idelleftrear
  gadelrearright = gadelrearright + (idelrightrear * adelay)
  gadelrearleft = gadelrearleft + (idelleftrear * adelay)
elseif ((idelspace > .75) && (idelspace <= 1.))  then   ; idelspace is btw  .75 & 1.
  idelleftrear = sqrt((1. - idelspace) * 4)
  idelleftfront = sqrt(1. - idelleftrear)
      print  idelspace , idelleftrear , idelleftfront
  gadelrearleft = gadelrearleft + (idelleftrear * adelay)
  gadelfrontleft = gadelfrontleft + (idelleftfront * adelay)
endif
endin
; -----  global delay line instrument ------------
instr 99
ideltime = p4
ifeedback=p5
adelayfrontleft  delay gadelfrontleft + gadelfeedback1, ideltime ; 4 delay lines, one
adelayfrontright  delay gadelfrontright + gadelfeedback2, ideltime ; for each channel
adelayrearright  delay gadelrearright + gadelfeedback3, ideltime
adelayrearleft  delay gadelrearleft + gadelfeedback4, ideltime
 ; delay line outputs for each of the 4 channels:
;  -------global feedback signal for each of the 4 channels: ----
; optional fade-out  of feedback
kfadeout init 1
if (p6 != 0 ) then
   kfadeout expseg 1,p3 - p6,1, p6, .001
endif
gadelfeedback1 = kfadeout * ifeedback * adelayfrontleft
gadelfeedback2 = kfadeout * ifeedback * adelayfrontright
gadelfeedback3 = kfadeout * ifeedback * adelayrearright
gadelfeedback4 = kfadeout * ifeedback * adelayrearleft
; quad output:
outq1 adelayfrontleft 
outq2 adelayfrontright
outq3 adelayrearleft 
outq4 adelayrearright 
; --- clear global signals from gbuzz instrument into delay instrument:
gadelfrontleft = 0 ; clear signal for front left speaker
gadelfrontright = 0 ; clear signal for front right speaker
gadelrearright = 0 ; clear signal for rear right speaker
gadelrearleft = 0 ; clear signal for left right speaker
; note: do NOT clear feedback variables gadelfeedback1 thru gadelfeedback4
endin
-----------------------------------------------------------
  < ECMC Csound Library Tutorial score11 input file >>  ex5-12 << : 
   < source sounds from ex4-4 gbuzz sub-audio fundamental and glissando
 < quad global delay instrument with feedback
* f1 0 8192 9 1 1 90;          < cosine function required by gbuzz

i1 0 0  4;  < gbuzz instrument -- creates source sounds
p3 nu 2/2.5/3./3.5;
du  nu 307./306/305.5/305;
p4 nu -16/-8.5/-53/-22;           < 1st fundmental freq.
p5 nu -14.5/-9/-49/-37;          < 2nd fundmental freq.

p6 nu 3/42/13/7;              < lowest harmonic (1=fundamental)
p7 nu 40/10/40/12;               < number of harmonics

p8 nu .5/.8/.3/ 1.2;               < kr1 (amplitude multiplier) 1 (start & end)
p9 nu .9/1.4/.9/.4;               < kr2 (amplitude multiplier) 1 (middle)
p11 nu .55/.4/.55/.4;  <  delay/direct mix, 0 to 1.: % delayed signal
 < quad: counter-clockwise circular spatial placement: 0 to 1.0
 < 0 & 1. = left front, .25 = right front, .5 = right rear, .75 = left rear
< p12 = spatial placement clockwise 0 (front left) to 1 (front left)
< .25 = front right, .5 = rear right, .75 = rear left, 1. = front left
p12 nu .9/.6/.4/.1;              
end;
< -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -
i99 0 0 1;   < global instrument for quad delay & feedback
p3 14.8 ;  < allow time for feedback of last note
p4 1.;           < delay time  ; if 0 bypassed, no delay 
p5 .54;          < delay feedback % 0 to 1., usualy .3-.8
p6 1.;           < optional fade-out time for feedback
end;
--------------------------------------------------

Because we have chosen to make this a quad orchestra, our orchestra files looks a good deal more complicated than it otherwise might appear, because many of the operations we need to perform must be done four times, once for each audio channel and delay line. We could have simplified this orchestra by using the specialized 4-channel delay line opcode vdelayxq rather than opcode delay, but our discussion and usage example of the delay will be of more use to you in constructing delay lines for mono and stereo orchestra files.

At the top of the orchestra, as required by Csound, all global variables are declared. As is often the case, they are initialized to a value of 0. All eight of the global variables run at the audio (sampling) rate and create "channels" for audio signals. Four of these variables, gadelfrontleft through gadelrearleft, are used to pass signals to be delayed from the source instrument to the global delay instrument. The other four global variables, gadelfeedback1 through gadelfeedback4, are used for feedback created by, and fed back into, the four delay lines.

p11 in the score determines the amount of signal to be sent to the global delay instrument. The reciprocal value (1.0 - p11) is an amplitude multiplier for the direct signal. Note that in the score we have set p11 rather high for the first and third notes:

 score file:    p11 nu .55/.4/.55/.4;  <  delay/direct mix, 0 to 1.: % delayed signal

orchestra file:   idelay=p11  ; % delayed signal
                   idirect = (1. - p11) ; % direct signal
                   adirect = idirect * afilt
                   adelay = idelay * afilt 

The delay time, specified in p4 of the global instrument score, is set to one second, and the feedback % is set to 54 % in p5:

     p4 1.;           < delay time  ; if 0 bypassed, no delay
     p5  .54;         < delay feedback % 0 to 1., usually .3-.8

     ideltime = p4
     ifeedback=p5

We have included an optional fade-out envelope, controlled by score p-field 6, which sets -out time, for the feedback from the delay lines:

   kfadeout init 1
   if (p6 != 0 ) then
      kfadeout expseg 1,p3 - p6,1, p6, .001
   endif
   gadelfeedback1 = kfadeout * ifeedback * adelayfrontleft ; fadeback for channel 1
   gadelfeedback2 = kfadeout * ifeedback * adelayfrontright ; fadeback for channel 2
   gadelfeedback3 = kfadeout * ifeedback * adelayrearright ; fadeback for channel 3
   gadelfeedback4 = kfadeout * ifeedback * adelayrearleft ; fadeback for channel 4<

In addition to unit generator delay, which we have used here Csound provides man other delay line unit generators. Some of these opcodes (such as vdelay3 provide for varying the delay time, while others (such as multitap enable us to tap into a delay line at 2, 3 or more points.

Assignment

1. Try out some of the following unit generators: tonex, atonex, resonx, balance, comb, alpass, freeverb and delay
2. Learn how to construct global instruments.

   TOP of this chapter  -- NEXT CHAPTER (Chapter 6) --   Table of Contents
   CHAPTER 1  --  CHAPTER 2  --  CHAPTER 3  --   CHAPTER 4  --  CHAPTER 5  --  CHAPTER 6
        APPENDIX 1  --  APPENDIX 2