Sam Sounds

A held note is a Fourier series

A string that rings on one pitch is close to periodic. A periodic wave can be written as a sum of sines: the fundamental, then twice that frequency, three times, and so on. That sum is a Fourier series.

1. The string plays a near-periodic wave

This wave repeats every period \(T\). Its frequency is

Its Fourier series is

\(f_1\) is the pitch the tuner names. The sizes \(|c_n| = \sqrt{a_n^2 + b_n^2}\) shape the tone.

• Guitar (richer): strong harmonics at \(f_1, 2f_1, 3f_1, 4f_1, \dots\)
• Flute (purer): mostly the fundamental, with small harmonics.

Different instruments have different harmonic sizes → different tone.

2. Drive rewrites that series

The engine multiplies the string by the drive knob, bends it with a soft absolute-value term, then passes it through tanh twice.

string \(y(t)\) → × drive \(k \in [0, 1]\) → soft abs \(+\,\alpha\,|y(t)|\) (asymmetric bend) → tanh (flattens peaks) → tanh (flattens peaks) → processed wave \(z(t)\)

• tanh flattens the peaks. A flattened wave needs extra odd harmonics in its Fourier series, so the tone gets brighter and harsher as \(k\) goes up.
• The small absolute-value bend is asymmetric, so even harmonics show up too.
• Nothing in this stage looks at a spectrum. The new harmonics are just what that new shape is made of.

As drive \(k\) increases (low → medium → high), the wave goes from a sine toward a square: brighter, harsher, more odd harmonics (and some even harmonics).

3. The tuner reads the string before this bend

It hears the series the string actually played, not the driven, bent version. Tuner input \(= y(t)\) (before drive processing). It names \(f_1\) and sees the harmonic sizes of the string's own motion.

Summary

• A held note is a Fourier series: fundamental + harmonics.
• Drive multiplies, bends, and flattens the wave → adds new harmonics (especially odd, plus even from asymmetry).
• The tuner reads the string before this bend → it hears what was actually played.

Legend: linear / string path (what the tuner sees); nonlinear drive path (rewrites the series). Note: all plots are illustrative. Real string motion includes decay, slight inharmonicity, and noise.

View original infographic

Convolution: cabinet as impulse response

How a guitar note becomes the sound of a cabinet and microphone.

1. Impulse response = the cabinet's "click"

A single click \(\delta[n]\) into the cabinet, recorded by the mic, gives the impulse response \(h[n]\): 2048 samples at 48 kHz ≈ 43 ms.

irs/ contents (from POD Go backup, 8 November 2023): 48 kHz, 32-bit float, 2048 samples, ≈ 43 ms.

2. Playing guitar through the cabinet = convolution

Guitar → Amp (distorted) \(x[n]\) → Convolution (cabinet + mic) → \(y[n]\) (what the mic hears)

Every sample of the distorted string is replaced by a copy of the click (\(h\)), scaled by that sample, and the copies are added where they overlap.

3. The convolution sum (time domain)

• \(x\) = amp (input)
• \(h\) = cabinet impulse response (IR)
• \(y\) = microphone output (what you hear)

Different \(h\) → different sound. Marshall IR \((h_{\text{Marshall}})\) vs. Mesa IR \((h_{\text{Mesa}})\): same \(x[n]\), different \(h\) → different body and top end.

4. Cab mix & post-convolution filters

\(y[n]\) (convolution output) + dry amp \(x[n]\) via Blend (0–100%) → Low Cut (one-pole HPF) → High Cut (one-pole LPF) → Output (to next stage)

Cab mix blends convolution output back with the dry amp. Low cut and high cut are one-pole filters (6 dB/oct), like turning down rumble and hiss on the mic.

5. How the engine actually does it (FFT convolution)

Direct 2048-tap convolution on every block is too expensive for the audio callback. The engine uses the Fourier transform:

Input blocks \((x)\) → FFT → \(X[k]\) → Multiply \((X[k] \cdot H[k])\) → IFFT → Overlap / Add → Output blocks \((y)\)

• \(H[k]\) is the FFT of \(h\), precomputed.
• Overlap-add (or overlap-save) reassembles the blocks into continuous audio.
• Far fewer operations per block → fits in the audio callback.

View original infographic

Guitar effects & processing as DSP building blocks

No FFT. Each output sample is a weighted sum of a few recent input samples and a few recent output samples.

1. Wah, tone stack, cab low & high cuts

Shapes: moving peak (wah), low shelf (lift lows), high shelf (cut highs).

Biquad (wah / tone stack), Direct Form I / Transposed Direct Form II:

One-pole cuts (low / high):

The Fourier transform of the filter's own impulse response is its frequency response. Same family of idea as the cabinet: impulse response so short that the direct sum is cheaper than an FFT.

Cabinet as short impulse response (example)

A weighted sum, no recursion. A typical cab IR is very short (about 5 ms); its frequency response (FFT of the IR) is plotted from 20 Hz to 10 kHz, between about 0 dB and −20 dB.

2. Delay, feedback & comb filter

Input \(x[n]\) → (+) → Cabinet / Filter \(H(z)\) → Output \(y[n]\), with Feedback \(g\) (\(0 \le g < 1\)) through Delay (shift) back into the sum

Delay ring buffer: write \(y[n]\), read \(y[n-D]\). The delay is a shift. The ring buffer holds the cabinet's output and reads it back tens or hundreds of milliseconds later. Feedback adds that echo into later echoes.

A delayed copy of a wave, mixed with the original, is a comb:

Its magnitude response has notches at \(k / D\) Hz \((k = 0, 1, 2, \dots)\).

3. Stereo width (Haas delay)

A much shorter copy of the same trick, the Haas delay, with the louder copy swapped between left and right. Input \(y[n]\) → Delay (\(\tau\) samples, \(\tau \approx\) 5–30 ms) → Gain (L) [illegible: "hiquer left"] → Left Out; Gain (R) [illegible: "hoder right"] → Right Out.

A short delay (\(\tau\)) creates spatial width without a full echo. Same comb idea, but \(\tau\) is small and used for perception, not repetition.

All effects here are rational transfer functions

For the cabinet cuts, many \(a_i = 0\) after the first few terms. Build complex sound with simple recurrence, delay, and feedback. No FFT required.

View original infographic

Back into the room

From rewritten float samples to sound pressure in the earcups.

1. render() returns 2 channels of float samples (example: 48 kHz, 32-bit float; left and right front).
2. PipeWire (pw-cat): 32-bit float, 48 kHz audio stream (2 ch, F32LE, 48 kHz).
3. System default sink (e.g., Logi USB headset): SINK: Logi USB Headset (Playback).
4. Inside the headset: converter → drivers → pressure.
   • DAC (converter): builds a voltage from each sample.
   • Amplifier / driver: moves the voice coil and diaphragm.
   • Acoustic pressure in the earcup: the pressure wave you hear.
5. What the pressure can contain (all encoded in the rewritten samples):
   • Tuner's note: a stable sinusoid at the target frequency (e.g., A4 ≈ 440 Hz).
   • Cabinet's click: a short transient impulse (e.g., mechanical click).
   • Clipped harmonic series: harmonics + hard clipping = bright, buzzy tone (e.g., saw-like + clip).
6. How it got there: rewrite in frequency, invert back to time. Rewrite the spectrum (optional but explicit): $$X[k] = \mathrm{FFT}\{x[n]\} \;\xrightarrow{\text{modify } X[k]}\; X'[k] \;\longrightarrow\; x'[n] = \mathrm{IFFT}\{X'[k]\}$$ Send the [unclear: "newdomain"] samples to PipeWire (back to step 2).

Every sound you hear in the headset started as numbers: rewritten, transformed, inverted, and turned back into pressure.

View original infographic