## Fifteen dissection part two: Instruments

*[Previous instalments: part zero,
part one.]*

So we need to calculate PCM audio, and we have very little space to do it in. First we need some instruments.

I wrote a tool to play around with generating sounds algorithmically. (I've tidied it up a bit since the compo; here is the original for the curious. Particularly of note is the fact that sample values for both the old version and the entry itself were in the range -32768..32767, whereas now they're -1..1. Hence the code samples differ slightly.)

In the tune we have the following: lead, bass, bass drum, hihat, snare, two bongoids and two thud-type things.^{1}

### Notes

Melodic instruments can be pretty simple: just take a periodic waveform and decay it exponentially over time.

We start with a sine wave, which is pretty periodic.
```
var freq = 440;
return Math.sin(i * freq * 2*Math.PI / 32000);
```

And add some decay:
```
var freq = 440, decay = 0.0004;
return Math.sin(i * freq * 2*Math.PI / 32000) * Math.exp(-i*decay);
```

Sine waves sound really "thin", having just a single frequency. We need harmonics. A cheap way of doing this I discovered was to generate *sin ^{n}x* instead of

*sin x*: higher values of n give more harmonics. Here's n=9, the value used for the lead melody:

```
var freq = 440, decay = 0.0004, exponent = 9;
return Math.pow(Math.sin(i * freq * 2*Math.PI / 32000), exponent) * Math.exp(-i*decay);
```

Frequency isn't too useful by itself; instead we need pitches in more useful units such as semitones. The actual function I ended up with was:
```
function r(o,p,f,e) {
return 4000*Math.pow(Math.sin(o*Math.pow(2,(p-53)/12)),e) * Math.exp(-o * f);
}
```

Here o is the offset in samples from the start of the note, p is the pitch in semitones (adjusted so that useful values are just above zero), f is the decay constant, and e is the exponent. This generate sample values in the range -4000..4000, which will fit about 8 such notes in the 16-bit output range.

And the calling code:
```
z += (t||(l==3))?
(r(u, p[l], 3e-4,25) + 2*r(u, p[l]-24, 2e-4, 80)):
r(u, p[l]-10?p[l]:13+((i/960)&2), 4e-4,9);
```

This takes some breaking down.

`(t||(l==3))`

This determines whether we want the bass sound (when channel == 3, or always during the thuddy chords) or the lead sound.

`(r(u, p[l], 3e-4,25) + 2*r(u, p[l]-24, 2e-4, 80))`

The bass sound is made up of two calls to r, one with exponent of 25, and one twice as loud and two octaves (24 semitones) lower with an exponent of 80. When the exponent is even the fundamental frequency is doubled so it's actually only one octave lower. The decay constants are slightly different so that the timbre changes over time.

`r(u, p[l]-10?p[l]:13+((i/960)&2), 4e-4,9);`

This is the melody sound, previously dissected.

`p[l]-10?p[l]:13+((i/960)&2)`

A hack for the
mordent. p[l] is the pitch stored in the pattern data, which is updated every event, or 3840 samples. If the pitch is not equal to 10, then it is used directly. Pitch 10—a value not needed for the tune—is used as a sentinel to mean "pitch 13 for half an event, then pitch 15 for half an event".

### Noises

The bass drum is simply a sine wave with descending frequency:
`return Math.sin(2e5/(i+1948));`

The number 1948 was chosen so that after 3840 samples (one event) the result will be approximately zero to avoid clicking.

The remaining percussion (hi-hat and snare—I had to jettison the bongoids for space reasons) were something resembling white noise with exponential decay. I decided to avoid Math.random() in favour of some deterministic bit-twiddling.

Here's the snare:
`return ((8e10/(i+6e3))&14)*Math.exp(-i/900)/14;`

The hat has three different variants with slightly different decay constants.
Here's the longest:
`return ((8e10/(i+3e5)*(i*17|5)&511))*Math.exp(-i/1000)/500;`

The percussion sequences are simple enough to be hard-coded. The hi-hats in context:
```
var o = i%3840;
var n = (i/3840) |0;
return ((8e10/(o+3e5)*(o*17|5)&511)) * Math.exp(-o*(n%3+1)/1000)/500;
```

And finally the percussion in its entirety:
```
var z = 0;
var m = ((i / 3840 / 15) | 0) + 9;
var o = i%3840;
var n = (i/3840) |0;
if(m<20) {
/* hat */
if(m>9)
z += ((8e10/(o+3e5)*(o*17|5)&511)) *
Math.exp(-o*(n%3+1)/1000) * 8;
/* bd, snare */
z += [m>11 && Math.sin(2e5/(o+1948))*10,0,m>15 && ((8e10/(o+6e3))&14)
* Math.exp(-o/900),0][n&3] * 800;
}
return z / 32768;
```

So there you have it. Despite all of this, the instruments were easily the weakest part of the demo.

Still to come: pattern encoding.

[1] One of the fun things about making music electronically is that it's entirely possible to get by without knowing what your instruments are conventionally called, or whether they even have a physical counterpart at all.