Outline#

• Filters (analogue, digital, vcf~, bob~, filter math (light)
• Subtractive Synthesis (from phasor to Moog Model-D clone))
• Audio and Pattern Effects in Strudel
• FM Synthesis (recall week 3, feedback, algorithms, operator-based design)
• Phase Vocoder + spectral synthesis.

Subtractive Synthesis#

Subtractive Synthesis#

Let’s take a complex sound and remove some content.

Popular Subtractive Synths#

Subtractive synthesis is often used in analogue synth designs, particular with those associated with Bob Moog (famous synth designer).

E.g.,:

• Minimoog Model-D (1970)
• Moog Mother 32 (2015) ~AUD1100
• Korg Volca Keys (2013) ~AUD250
• Arturia Microfreak (2014) ~AUD550

It’s good for analogue designs because you can get a lot of timbral variation out of few (2 or 3) basic oscillators.

Subtractive Synth Layout#

• Sound is produced by 1+ summed oscillators and/or noise generator, processed by filter
• Two envelope generators: output volume and to change the filter cut-off frequency
• Missing: low frequency oscillator for modulation

Minimoog in Strudel#

We can create a similar synth in Strudel by using the sawtooth oscillator sound, and applying low pass filter and envelope effects.

note("<[c2 c3]*4 [f2 f3]*4>".mul("[1,1.01]"))
  .gain(0.5)
  .sound("sawtooth") // also try "supersaw"
  .lpf(300).lpq(20)
  .lpa(.5).lpr(.5)
  .lpenv("4")

.lpf and .lpq are the cutoff frequency and resonance of the low-pass filter effect. .lpenv, .lpa and `.lpr are envelope parameters for the filter frequency.

Remember that all the audio effects like .lpf, .lpq, lpenv can and should be sequenced to modulate them in interesting ways.

Effects in Strudel#

The previous example showed how to use some of the audio effects built into Strudel.

In Strudel’s functional design, effects are implemented by adding function calls to your pattern.

Some effects modify the sound of a pattern and others modify the sequence. It’s not always obvious which (e.g., does rev mean reverb or reverse the sequence?)

Note! I’m not going to explain the whole API here, you have to use Strudel’s documentation and the “reference” tab in the REPL to understand what is available.

Audio Effects#

We introduced Strudel’s filters already, but let’s look at the other typical effects. E.g., gain and pan:

s("hh").gain("0.4|0.5|0.6").pan("0|.5|1").fast(16)

delay, delaytime and delayfeedback (N.B. shortcut in mininotation to all params)

note("c a f e").delay(0.65).delaytime(0.27).delayfeedback(0.8)
note("c a f e").delay("0.65:0.27:0.8")

Reverb room (reverb level) and rsize (“room” size), also with mininotation shortcuts.

s("bd sd [bd bd] [sd bd], [hh*8]").room(.8).rsize(4)
s("bd sd [bd bd] [sd bd], [hh*8]").room(".8:4")

Pattern Effects#

These effects modify your pattern of notes giving you lots of options for variation and algorithmic composition, e.g., rev plays a pattern backwards:

n("0 1 2 3 4 5 6 7").scale("C:minor").rev()
n("0 1 2 3 4 5 6 7").scale("C:minor").jux(rev) // left: forward, right: backward

There are arithmetic effects add, sub, mul, div: (Note .add is effecting the mininotation!)

n("0 1 2 3".add("<0 2 5 3>")).scale("C:minor")

Changing speed with fast or slow

n("0 1 2 3 4 5 6 7").scale("C:minor").slow("1,1.5,4.5")

Signal Patterns#

Signal patterns are waveforms that you can use to modulate or generate patterns.

Use as a low frequency oscillator, e.g., tri controlling a lowpass filter cutoff frequency:

note("c3*16").s("sawtooth")
  .lpf(tri.range(100,8000).slow(2))

Use for note patterns, n creates a pattern of indices interpreted by scale, e.g.:

n(saw.range(0,15).segment(16)).scale("C:minor")
n(tri.range(0,15).euclid(7,16)).scale("C:scriabin")

In the above, segment and euclid turn the signal into a discrete sequence.

Random Variations#

There’s (at least) two kinds of useful randomness paradigms in Strudel: random signals, and random modifiers. The signals work similarly to the regular signals:

n(irand(16).euclid(7,16)).scale("C:scriabin")
n(perlin.range(-7,24).segment(16)).scale("C:scriabin").s("kawai")

Random modifiers like sometimes, almostNever, and often take an action sometimes.

note("c2".sometimesBy(.2, x=>x.add("12"))).fast(16)

Note the arrow function in there. Nice.

Don’t forget: you can still have randomness in mininotation with | and ?

FM Synthesis#

Can we do this in Strudel?#

Not terribly easily (6-op synths are complicated) and Strudel itself isn’t designed for creating new synths on the fly.

For any “new” synth, i.e., where you want to build the signal graph yourself like in Pd, the two options would be:

1. Extend Strudel with a new sound by hacking web audio API
2. Using Strudel’s CSound integration and write the synth in CSound instead

Option 2 would be likely to be easier but involves learning another programming language.

CSound in Strudel#

CSound is among the oldest computer music languages (first released in 1985) and it’s still used today. Although you would typically run CSound as a regular application, there’s now an implementation on the web.

Here’s a simple CSound synth in Strudel:

await loadCsound`
instr charlessynth
  iduration = p3
  ifreq = p4
  igain = p5
  kenv = linen(igain, 0.1, iduration, 0.2)
  asig = vco2(kenv, ifreq, 4, .5)
  out(asig,asig)
endin`

"0 3 1 2 5@4"
.scale('D minor')
.note()
.csound('charlessynth')

CSound Instrument#

There’s some weird stuff about CSound. It’s original syntax looks like assembly and types of variables are determined by the first letter of their names.

instr charlessynth
  iduration = p3 ; CSound has special parameter variables, p3 is duration
  ifreq = p4 ; p4 is frequency
  igain = p5 ; p5 is volume
  kenv = linen(igain, 0.1, iduration, 0.2) ; linen is a basic envelope
  asig = poscil(kenv, ifreq) ; poscil is sine tone 
  out(asig,asig) ; output the signal
endin

There’s two good resources for learning CSound, the reference manual and the flossmanual

Why introduce CSound? To make complex synths in Strudel.#

It might seem a bit unhinged to introduce a new complete computer music system at this stage of the course.

The point is: I want you to have the tools to explore computer music deeply.

CSound in Strudel gives you a very good balance of convenience to depth for defining complex instruments in a live coding environment.

There’s a learning curve to understanding the syntax and getting a feel for the system, but it’s not that hard now that you know the concepts.

tl;dr: to do feedback phase-modulation synthesis in Strudel, you should use CSound, and see this paper

Phase Modulation Feedback Synth in CSound#

await loadCSound`
giSine ftgen 0, 0, 8192, 10, 1 ; makes a sine tone table

instr feedback_PM
 kCarFreq = p4
 kFeedbackAmountEnv linseg 0, 2, 0.2, 0.1, 0.3, 0.8, 0.2, 1.5, 0
 aAmpEnv expseg .001, 0.001, 1, 0.3, 0.5, 8.5, .001
 aPhase phasor kCarFreq
 aCarrier init 0 ; init for feedback
 aCarrier tablei aPhase+(aCarrier*kFeedbackAmountEnv), giSine, 1, 0, 1
 outs aCarrier*aAmpEnv, aCarrier*aAmpEnv
endin`

n(sine.range(0,15).segment(8).slow(16)).scale("C:minor")
.csound('feedback_PM')

This is just one operator with feedback controlled by an envelope (example adapted from the CSound flossmanual)

String Synthesis#

Karplus-Strong string synthesis is a famous algorithm for creating a string-like sound with a noise source, a delay and a filter.

It can be considered a special case of digital waveguide synthesis, used for string, tube, and membrane sounds.

K-S synthesis is quite common in digital synthesisers (e.g., Arturia Microfreak) and it’s fun to do in Pd.

String Synthesis in CSound#

await loadCSound`
instr kstest
  ifreq = p4
  iamp = p5
  ipluck = 0.6   ; pluck position (0-1)
  idamp = 0.999    ; damping factor (0-1)
  idelaytime = 1 / ifreq  
  anoise rand iamp
  aexcite = anoise * ipluck
  kenv linseg 1, 0.01, 0, 0.01, 0
  ainitial = aexcite * kenv
  afeedback init 0
  adelay delay ainitial + afeedback, idelaytime
  afilt = (adelay + delay1(adelay)) * 0.5 * idamp
  afeedback = afilt
  out afilt,afilt
endin`

n(sine.range(0,15).segment(8)).scale("C:minor")
.csound('kstest')

Note the simple LPF: (adelay + delay1(adelay)) * 0.5

Physical Modelling Synthesis#

Physical modelling synthesis is an interesting area with lots of possibilities and challenges.

Have a look at Julius O Smith’s Stanford Courses (Music 420A) to learn more.

Note that you can do a lot of awesome physical modelling synthesis in CSound. Take a look at the book.

Back to the frequency domain#

Remember the Fourier transform? This allowed us to extract the amplitude each frequency component of a sound.

In practice, the FT can’t be used as it requires an infinite input (who has time for that).

We can use a similar construction called: Short-Time Discrete Fourier Transform (STDFT):

• short-time: operates on a finite-length signal instead of an infinite signal

• discrete: operates on sampled information

We often refer to STDFT as FFT, or “fast Fourier transform” (e.g., the fft~ object in Pd). FFT is actually a clever algorithm for accomplishing a DSTFT quickly, so it’s ok to use the acronyms interchangeably.

Short-Time Discrete Fourier Transform#

For a signal with $N$ samples, the STDFT equations providing the sine and cosine amplitudes at certain frequencies are:

• $R_k = \sum\limits_{i=0}^{N-1} x_i cos(2\pi k i \ N)$

• $X_k = - \sum\limits_{i=0}^{N-1} x_i sin(2\pi k i \ N)$

The STDFT also only focuses on $N$ frequencies that we call “bins” between 0 and the sampling frequency.

• If the sampling rate is $S$ then the frequency of the $k$th bin is: $k * \frac{S}{N}$

N.B.: the frequency “resolution” is limited by the length of the signal we are analysing!

Inverse FFT#

The FFT procedure actually also works backwards!

• From a finite sequence of frequencies we can (re-)create a sampled signal!

The exclamation mark is doing a lot of work here! Imagine what we can do with full control over a spectrum!!

In fact, the IFFT algorithm is almost identical to the FFT algorithm

It is important when doing an FFT to cope with the sine and cosine elements (or the real and complex outputs of a frequency. These interact in a certain way to make the ouput sound “work”.)

FFT in Pd#

Pure Data can perform a STDFT with the fft~ object (yes it’s that easy).

The two outputs give you the real and imaginary part of the signal. You can also do rfft~ just to get the real output (saves CPU).

Similarly, you can do an inverse FFT with rifft~ and ifft~.

In Pd, N is the same as the “block size” (number of samples processed at once), so Pd patches often adjust block size just for the FFT patch to get the right number of FFT bins.

Phase Vocoder in CSound#

You can do similar procedures in CSound as outlined in the manual