# Modulation Synthesis and Waveshaping

## Lecture Slides

A series of gif images of the lecture slides... (only accesible from within Stanford University)

### Modulation Synthesis

• short description of linear and non-linear systems

## Examples

• A very simple ring modulation instrument (ringmod.ins)
• A very simple ring modulation instrument with wavetable oscillators (ringmodw.ins)
• A very simple amplitude modulation instrument (ampmod.ins)
• A very simple amplitude modulation instrument with wavetable oscillators (ampmodw.ins)
• A very simple frequency modulation instrument (fmmod.ins)

Here are a bunch of fm instruments, mostly coming from the clm area ("/usr/ccrma/lisp/src/clm"). You should explore, there's a wealth of information and examples hiding there...

### bell.ins

The eternal "fm bell". Here is the header of the instrument and a short description of its parameters:

(definstrument fm-bell (start-time duration frequency amplitude
amp-env index-env index
&optional (degree 0.0)
(distance 1.0)
(reverb-amount 0.005))

#### Mandatory parameters

start-time
starting time in seconds
duration
duration of the note in seconds
frequency
frequency of the note in Hertz
amplitude
amplitude of the note (between 0 and 1)
amp-env
amplitude envelope. A list of time-value coordinates that determines the evolution of loudness over time. The time values are relative and are scaled to the duration of the note (for example I usually use a time axis that stretches between 0 and 1).
index-env
modulation index envelope. A list of time-value coordinates that determines the evolution of modulation index over time. The modulation index controls the "brightness" of the sound (the higher the index the brighter the resulting sound).
index
modulation index. The scaler for the index envelope.

#### Optional parameters

degree
angle in degrees from where the sound is coming from in a stereo rendition. "0" is left and "90" is right; "45" is right in the middle of the stereo field.
distance
distance in feet from where the sound is coming from.
reverb-amount
amount of reverberation added to the sound. For this to work you must have a reverberator loaded and the with-sound call has to specify it.

#### Some random with-sound's

doesn't sound like a bell...

(with-sound()(fm-bell 0 4 440 0.1
'(0 0 0.05 1 0.2 0.4 0.8 0.2 1 0)
'(0 0 0.02 1 0.2 0.2 0.8 0.1 1 0)
1))
so let's tweak envelopes a bit...

(with-sound()(fm-bell 0 4 440 0.1
'(0 0 0.002 1 0.2 0.4 0.8 0.2 1 0)
'(0 0 0.001 1 0.1 0.08 0.8 0.01 1 0)
1))
maybe try a duller bell?

(with-sound()(fm-bell 0 4 440 0.1
'(0 0 0.002 1 0.2 0.4 0.8 0.2 1 0)
'(0 0 0.001 1 0.1 0.08 0.8 0.01 1 0)
0.3))
but with a different envelope and a lower frequency it's not a bell any longer... (but sounds like the typical fm wow)

(with-sound()(fm-bell 0 4 78 0.1
'(0 0 0.3 1 0.4 0.9 0.8 0.2 1 0)
'(0 0 0.35 1 0.38 0.9 0.8 0.01 1 0)
0.7))

### drum.ins

A drum simulation. Here is the header of the instrument and a short description of its parameters:

(definstrument fm-drum (start-time duration frequency amplitude index
&optional
(high nil)
(degree 0.0)
(distance 1.0)
(reverb-amount 0.01))

#### Mandatory parameters

start-time
duration
frequency
amplitude
index
modulation index.

#### Optional parameters

high
"t" introduces an upwards glissando in the end of the note (the glissando function is a constant hardwired into the instrument, it could be made a parameter, of course).
degree
distance
reverb-amount

#### Some example with-sound's

(with-sound ()
(fm-drum 0 1.5 55 .3 5 nil)
(fm-drum 2 1.5 66 .3 4 t))

### gong.ins

A very nice gong simulation. Here is the header of the instrument and a short description of its parameters:

(definstrument gong (start-time duration frequency amplitude
&key
(degree 0.0)
(distance 1.0)
(reverb-amount 0.005))

start-time
duration
frequency
amplitude

degree
distance
reverb-amount

#### Some example with-sound's

(with-sound () (gong 0 3 261.61 .6))

### Fm violin

A generic and very versatile fm instrument created by Bill Schottstaedt. A nice example of multipurpose coding. Almost everything has reasonable defaults but can be changed. If you examine the code you'll see another feature common to good instruments. The key parameters are defaulted to the value of special (global) variables. That opens the possibility of globally changing the behaviour of a bunch of notes by just encasing them in a "let" with redefinitions of those global variables. Here is the header of the instrument and a short description of its parameters (which has plenty off):

(definstrument fm-violin
(startime dur frequency amplitude &key
(fm-index                   fm-violin-fm-index)
(amp-env                    fm-violin-amp-env)
(periodic-vibrato-rate      fm-violin-periodic-vibrato-rate)
(random-vibrato-rate        fm-violin-random-vibrato-rate)
(periodic-vibrato-amplitude fm-violin-periodic-vibrato-amplitude)
(random-vibrato-amplitude   fm-violin-random-vibrato-amplitude)
(noise-amount               fm-violin-noise-amount)
(ind-noise-freq             fm-violin-ind-noise-freq)
(ind-noise-amount           fm-violin-ind-noise-amount)
(amp-noise-freq             fm-violin-amp-noise-freq)
(amp-noise-amount           fm-violin-amp-noise-amount)
(noise-freq                 fm-violin-noise-freq)
(gliss-env                  fm-violin-gliss-env)
(glissando-amount           fm-violin-glissando-amount)
(fm1-env                    fm-violin-fm1-env)
(fm2-env                    fm-violin-fm2-env)
(fm3-env                    fm-violin-fm3-env)
(fm1-rat                    fm-violin-fm1-rat)
(fm2-rat                    fm-violin-fm2-rat)
(fm3-rat                    fm-violin-fm3-rat)
(fm1-index                  fm-violin-index1)
(fm2-index                  fm-violin-index2)
(fm3-index                  fm-violin-index3)
(base                       fm-violin-base)
(frobber                    fm-violin-frobber)
(reverb-amount              fm-violin-reverb-amount)
(index-type                 fm-violin-index-type)
(degree                     nil)
(distance                   1.0)
(no-waveshaping             nil)
(denoise                    fm-violin-denoise)
(denoise-dur                .1) ;used to be .5
(denoise-amp                .005)
&allow-other-keys)

startime
dur
frequency
amplitude

#### Optional parameters

fm-violin-fm-index 1.0
overall modulation index.
fm-violin-amp-env '(0 0 25 1 75 1 100 0)
amplitude envelope.
fm-violin-periodic-vibrato-rate 5.0
periodic vibrato frequency (periodic vibrato is a triangular wave).
fm-violin-random-vibrato-rate 16.0
random vibrato rate (random noise added to the vibrato).
fm-violin-periodic-vibrato-amplitude 0.0025
amplitude of the periodic vibrato.
fm-violin-random-vibrato-amplitude 0.005
amplitude of the random vibrato.
fm-violin-noise-amount 0.0
add index and amplitude noise (internal movement of the sound).
fm-violin-noise-freq 1000.0
bandwidth of the index and amplitude noise.
fm-violin-ind-noise-amount 0.0
index noise amount
fm-violin-ind-noise-freq 10.0
bandwidth of index noise.
fm-violin-amp-noise-amount 0.0
amplitude noise amount
fm-violin-amp-noise-freq 20.0
bandwidth of amplitude noise.
fm-violin-gliss-env '(0 0 100 0)
glissando envelope (pitch envelope)
fm-violin-glissando-amount 0.0
scaler for the pitch envelope.
fm-violin-fm1-env '(0 1 25 .4 75 .6 100 0)
index envelope for first modulator
fm-violin-fm2-env fm-violin-fm1-env
fm-violin-fm3-env fm-violin-fm1-env
fm-violin-fm1-rat 1.0
modulator / carrier frequency ratio for first modulator.
fm-violin-fm2-rat 3.0
fm-violin-fm3-rat 4.0
fm-violin-base nil
kind of interpolation to be done between envelope points.
fm-violin-frobber nil
fm-violin-reverb-amount 0.01
reverberation amount.
fm-violin-index-type :violin
fm-violin-denoise nil
whether to try to reduce quantization noise in envelopes.
fm-violin-index1 nil
modulation index for the first modulator.
fm-violin-index2 nil
fm-violin-index3 nil

#### Some example with-sound's

For a compilation of examples on how the fm-violin can sound load the fmviolin.clm file. The 20 Mbyte soundfile created by loading fmviolin.clm into lisp after compiling and loading both v.ins and jcrev.ins is at /usr/ccrma/web/CCRMA/Courses/220a/Lectures/4/Examples/fmviolin.snd (this will save you some time since the soundfile take quite a long time to be created). Start a copy of "snd" and load the file in it to play the example. Please be aware that for this example to work you will also have to compile and load a reverberator (jcrev.ins). If you want to play with the lisp code inside fmviolin.clm I strongly suggest you take apart the file and create a small with-sound for each example you are interested in... the whole soundfile is almost 20Mbytes long.

### Fm voice

Chowning's fm voice instrument.

(definstrument fm-voice (beg dur pitch amp
vowel-1 sex-1 ampfun1 ampfun2 ampfun3
indxfun skewfun vibfun ranfun
dis pcrev deg vibscl pcran skewscl ranpower
glissfun glissat glissdc glissamt at1 at2 dc1 dc2)

#### Some example with-sound's

(let ((ampf '(0 0 1 1 2 1 3 0)))
(with-sound (:wait t)
(fm-voice 0 1 300 .8 3 1 ampf ampf ampf ampf ampf ampf ampf 1 0 0 .25 1 .01 0 ampf .1 .1 0 .1 .1 .1 .1)))

## Real Time CLM instruments

### Ring Modulation

"ringo-forever" is the name of a simple real time ring modulator clm instrument that lets you control the frequencies of the two sine wave oscillators in real time. The instrument can be "plugged" into a "tester" (another clm real time instrument) to display the resulting waveform and fourier transform in real time.

ringo.cl is the ring modulation instrument definition and tester.cl is the "tester" instrument that will display the waveform and fft. There are several steps to be done (and none must be missed to start the real time instrument:

• compile and load both "tester.cl" (has to be compiled first!) and then "ringo.cl". This will create two separate programs. The instrument itself (which runs within lisp) and the Motif/X graphical interface program that will be used to control the instrument in real time (which can be run from a terminal).
• if this is the first time you run a real time instrument since you started lisp type "(open-controls 4096)" into the lisp interpreter. This will create the shared memory that is used by both lisp and the c program.
• start the "tester" program. Normally the program will be compiled in the directory where you copied to source to "ringo.cl". So go to a terminal, "cd" to the proper directory "tester &". You'll get a graphical interface window with two panes (waveform and spectrum displays) that will show nothing for now.
• start the "ringo" program. This is the graphical interface for the "ringo-forever" real time instrument. Same as before, go to the proper directory and type "ringo &" to start it. Again, nothing will happen as this is just the graphical interface to the instrument.
• make sure both programs have the on/off button in the "on" position.
• go to the lisp interface and start the real time instrument by typing "(with-psound()(tester)(ringo-forever t))"... and off you go!!

• to stop the instrument: click the on/off buttons in both the tester and ringo graphical interfaces to the "off" position. The real time instrument will automatically exit its sample generation loop.
• before quitting lisp remember to deallocate the shared memory by doing a "(close-controls)".

### Amplitude Modulation

"ampo-forever" is the name of a simple real time amplitude modulation clm instrument that lets you control the frequencies of the two sine wave oscillators in real time. The instrument can be "plugged" into the same "tester" that was used for the previous example ("ringo-forever").

ampo.cl is the amplitude modulation instrument definition and tester.cl is the "tester" instrument that will display the waveform and fft.

### Frequency Modulation

"ffm-forever-parallel" is the name of a real time frequency modulation instrument with built in fft and waveform displays. This instrument features one carrier oscillator and three separate modulators. You can change the modulation index and carrier to modulator frequency ratios of all modulators. The "ffm-forever-series" instrument has a different configuration. One carrier is modulated by a modulator which in turn is modulated by another two modulators.

bessiecl is the frequency modulation instrument definition. It will create an interface program named "bessie" that you should execute prior to starting the infinite with-psound...

## Assignment

Create a "Modulation Song" using the example instruments (or custom versions of them, needless to say adding envelopes to control parameters would make most of them much more interesting...). Plug in parameters and experiment with them. Experiment with different amplitude envelopes (for example: create percussive attacks). Doesn't have to be very long, 1 minute tops! Have fun!

Email me the source code for the instruments you used (so I don't have to go hunting for them in the filesystem) and the note list that you used to create the Modulation Song...