Parametric EQ: Peaking and Shelving Biquads

in reviewThis lesson is complete and being validated before release - details may still change.

Parametric EQ

Loading interactive demo…

A parametric equalizer turns parts of the spectrum up or down by a chosen number of decibels. This one is three biquads in series: a low shelf, a peak you can place and widen, and a high shelf, each designed from the same cookbook as the low-pass filter. Take the tour, or press and explore. Legend:

The panel beside the stage is the real ParametricEq class from the published library executing in your browser, with the current line highlighted.

The saw going in, drawn faintly behind the output.
The equalized output so far, and the response curve in the inset.
The sample being computed this step, and the peak band's frequency on the inset (always the brightest).
The part of the response above 0 dB: a boost.

The inset is the whole equalizer's magnitude response on a log frequency axis, computed from the same class: the bands' responses multiply, so their decibels add. at peak is the gain where the peak band sits. Press Wet for a 110 Hz saw through this equalizer, the same class run at 44.1 kHz with every band at the same multiple of the fundamental, and Dry for the saw alone.

The code panel shows bare executable code by default. The bar above it names the file (hover the name for the full published path); options holds the toggles: comments, the tracer instrumentation that produces this visualization, and verbose names for the terse identifiers (display only: the default is the byte-exact published file). The view switch adds plain-English narration: both interleaves it with the code, pseudo shows only the pseudocode. hide code collapses the panel; the rail it leaves behind brings it back.

Keys: Space play/pause · ←/→ step · Home/End jump · R reset · F fullscreen · G guided tour

Every band is the biquad from the low-pass lesson,

y[n] = b_0\,x[n] + b_1\,x[n-1] + b_2\,x[n-2] - a_1\,y[n-1] - a_2\,y[n-2],

with the five weights designed differently. With a gain of $g$ decibels the cookbook first forms

A = 10^{g/40}, \qquad \omega_0 = 2\pi f_0 / f_s, \qquad \alpha = \frac{\sin\omega_0}{2Q},

and the peaking band is

b_0 = 1 + \alpha A, \quad b_1 = -2\cos\omega_0, \quad b_2 = 1 - \alpha A,

a_0 = 1 + \alpha / A, \quad a_1 = -2\cos\omega_0, \quad a_2 = 1 - \alpha / A,

all divided by $a_0$ . At $\omega_0$ the numerator's $\alpha A$ sits over the denominator's $\alpha / A$ , so the gain there is $A^2$ : that is why the decibels are divided by 40 and not 20. Far from $\omega_0$ the $\alpha$ terms vanish against the rest and the band is flat at 0 dB. $Q$ sets how quickly that happens: the bandwidth between the half-gain points is about $f_0 / Q$ .

The low shelf (the high shelf swaps the signs of the $\cos\omega_0$ terms) is

b_0 = A\big[(A+1) - (A-1)\cos\omega_0 + 2\sqrt{A}\,\alpha\big], \quad b_1 = 2A\big[(A-1) - (A+1)\cos\omega_0\big],

a_0 = (A+1) + (A-1)\cos\omega_0 + 2\sqrt{A}\,\alpha, \quad a_1 = -2\big[(A-1) + (A+1)\cos\omega_0\big],

with $b_2$ and $a_2$ as $b_0$ and $a_0$ with the $\alpha$ term subtracted. At DC it is $A^2$ , at the Nyquist limit it is 1, and at $f_0$ itself exactly $A$ : the corner is the shelf's midpoint, half the gain in decibels. $Q = 1/\sqrt2$ is the gentlest shelf, the cookbook's slope of 1.

Series bands multiply. The transfer function of bands in series is the product of theirs, so

20\log_{10}|H| = \sum_k 20\log_{10}|H_k|,

and the inset is literally the three curves added in decibels. The order of the bands does not change the product, only the intermediate values the trace shows.

Choices worth reading closely in the implementation (the code panel's comments and tracer checkboxes reveal the full published file):

One band class, three designs. EqBand.design is a switch on the band's kind over the same five-number shape; the memories and process are shared. A graphic equalizer would be the same class with a row of fixed peaks.
The gain goes through 10^(g/40). The comment on the class says why: $A$ is used twice, so the ratio the learner asked for is $A^2$ . The library test pins a +6 dB peak to 6 dB at its frequency.
Normalised once, in design. Dividing by $a_0$ at design time keeps the per-sample loop at five multiplies per band, and the design event shows the numbers the loop uses.
process reports the value after each band. The step event carries low, peak, and y, so the watch row shows the signal being handed from one band to the next. The order of the bands changes those intermediates but not the output.
magnitudeAt multiplies the bands' real transfer functions, so the response inset is the equalizer, not a drawing of one; the test checks it equals the sum of the bands' decibels.
Frequencies are clamped just under the Nyquist limit, as in the low-pass, where the design formulas degenerate; reset clears every band for a new note while the memories otherwise survive block boundaries.

Tone controls began as a bass knob and a treble knob: Peter Baxandall's 1952 circuit let each be turned up or down without touching the other, and the Pultec program equalizer of 1956 put a boost and a cut on the same band in a studio box. What was missing was a band you could place: George Massenburg's 1972 paper named the equalizer whose frequency, width, and gain were all continuous knobs "parametric". In software every band is a biquad, the same five numbers as a low-pass with different design formulas, and bands in series simply add their decibels.

1952Peter Baxandall - 'Negative-feedback tone control' in Wireless World describes the bass and treble circuit that, in one account, swept all others before it: the ancestor of the two shelves.source
1956Pulse Techniques - The Pultec EQP-1 program equalizer is introduced, with a low shelf that could be boosted and cut at the same time; it stayed in production for 25 years.source
1971Daniel Flickinger - The first parametric equalizer, with its frequency, bandwidth, and gain as continuous controls, is introduced and patented (US 3752928).source
1972George Massenburg - 'Parametric Equalization', presented at the 42nd convention of the Audio Engineering Society in May, gives the design its name.source

Used today

Mixing - A cut where two instruments collide and a shelf to brighten a vocal are the everyday moves of a mix; every channel strip carries three or four of these bands.
Room correction - Measured peaks in a room's response are cancelled with matching cuts, band by band.
Playback tone controls - The bass and treble on a car stereo or a phone are a low shelf and a high shelf; a graphic equalizer is a row of fixed peaks.
Speaker crossovers and hearing aids - Shelves and peaks compensate for a driver's or an ear's own response before the sound is made.

low0 dB

peak at3x

peak+6 dB

Q1.0

high0 dB

peak Hz: 3 Hz
at peak: 6.0 dB
at DC: 0.0 dB
out/in: 1.21

parametric-eq.ts

import type { Tracer } from "../trace";import { SampleRate } from "./sample-rate";/** The three band shapes a parametric equalizer is built from. */export type EqBandKind = "low-shelf" | "peak" | "high-shelf";export const EQ_BAND_KINDS: readonly EqBandKind[] = ["low-shelf", "peak", "high-shelf"];/** One band's settings: its shape, where it sits, how much it adds or takes, and how wide it is. */export interface EqBandSpec {  readonly kind: EqBandKind;  readonly frequencyHz: number;  readonly gainDb: number;  /** Bandwidth for a peak; slope for a shelf (1 / sqrt 2 is the cookbook's gentlest shelf, S = 1). */  readonly q: number;}/** The five numbers that are a biquad, already divided by a0. */export interface EqCoefficients {  readonly b0: number;  readonly b1: number;  readonly b2: number;  readonly a1: number;  readonly a2: number;}/** A band's frequency is kept this far below the Nyquist limit, where the design degenerates. */const MAX_FREQUENCY_FRACTION = 0.49;const PASS_THROUGH: EqCoefficients = { b0: 1, b1: 0, b2: 0, a1: 0, a2: 0 };/** * One band of the equalizer: a biquad in direct form I whose five * weights come from Robert Bristow-Johnson's Audio EQ Cookbook, the * peaking formulas or one of the two shelf formulas. The shelves use * the cookbook's Q form (alpha = sin w0 / 2Q), so a Q of 1 / sqrt 2 is * the slope-1 shelf. The gain in decibels is divided by 40, not 20, to * get A: the formulas use A twice (once in the numerator, once in the * denominator), so A squared is the amplitude ratio asked for. */export class EqBand {  private coefficients: EqCoefficients = PASS_THROUGH;  private x1 = 0;  private previousInput = 0;  private x2 = 0;  private olderInput = 0;  private y1 = 0;  private previousOutput = 0;  private y2 = 0;  private olderOutput = 0;  constructor(readonly spec: EqBandSpec) {    if (!(spec.q > 0)) throw new RangeError(`q must be positive, got ${spec.q}`);    if (!EQ_BAND_KINDS.includes(spec.kind)) throw new RangeError(`unknown band kind ${String(spec.kind)}`);  }  /** Designs the band for a sample rate and returns its five weights. */  design(sampleRate: number): EqCoefficients {    const frequency = Math.min(Math.max(this.spec.frequencyHz, 0), MAX_FREQUENCY_FRACTION * sampleRate);    const amplitude = Math.pow(10, this.spec.gainDb / 40);    const w0 = (2 * Math.PI * frequency) / sampleRate;    const cornerAngle = (2 * Math.PI * frequency) / sampleRate;    const cosine = Math.cos(w0);    const cosine = Math.cos(cornerAngle);    const alpha = Math.sin(w0) / (2 * this.spec.q);    const alpha = Math.sin(cornerAngle) / (2 * this.spec.q);    const root = 2 * Math.sqrt(amplitude) * alpha;    let b0: number;    let b1: number;    let b2: number;    let a0: number;    let a1: number;    let a2: number;    switch (this.spec.kind) {      case "peak":        b0 = 1 + alpha * amplitude;        b1 = -2 * cosine;        b2 = 1 - alpha * amplitude;        a0 = 1 + alpha / amplitude;        a1 = -2 * cosine;        a2 = 1 - alpha / amplitude;        break;      case "low-shelf":        b0 = amplitude * (amplitude + 1 - (amplitude - 1) * cosine + root);        b1 = 2 * amplitude * (amplitude - 1 - (amplitude + 1) * cosine);        b2 = amplitude * (amplitude + 1 - (amplitude - 1) * cosine - root);        a0 = amplitude + 1 + (amplitude - 1) * cosine + root;        a1 = -2 * (amplitude - 1 + (amplitude + 1) * cosine);        a2 = amplitude + 1 + (amplitude - 1) * cosine - root;        break;      case "high-shelf":        b0 = amplitude * (amplitude + 1 + (amplitude - 1) * cosine + root);        b1 = -2 * amplitude * (amplitude - 1 + (amplitude + 1) * cosine);        b2 = amplitude * (amplitude + 1 + (amplitude - 1) * cosine - root);        a0 = amplitude + 1 - (amplitude - 1) * cosine + root;        a1 = 2 * (amplitude - 1 - (amplitude + 1) * cosine);        a2 = amplitude + 1 - (amplitude - 1) * cosine - root;        break;    }    // Dividing by a0 here means the per-sample loop never has to.    this.coefficients = { b0: b0 / a0, b1: b1 / a0, b2: b2 / a0, a1: a1 / a0, a2: a2 / a0 };    return this.coefficients;  }  /** One sample through the band, carrying the four memories forward. */  process(x: number): number {    const { b0, b1, b2, a1, a2 } = this.coefficients;    const y = b0 * x + b1 * this.x1 + b2 * this.x2 - a1 * this.y1 - a2 * this.y2;    const y = b0 * x + b1 * this.previousInput + b2 * this.olderInput - a1 * this.previousOutput - a2 * this.olderOutput;    this.x2 = this.x1;    this.olderInput = this.previousInput;    this.x1 = x;    this.previousInput = x;    this.y2 = this.y1;    this.olderOutput = this.previousOutput;    this.y1 = y;    this.previousOutput = y;    return y;  }  /** How much this band scales a steady tone at a frequency: the magnitude of its transfer function. */  magnitudeAt(frequencyHz: number, sampleRate: number): number {    const { b0, b1, b2, a1, a2 } = this.coefficients;    const w = (2 * Math.PI * frequencyHz) / sampleRate;    const cos1 = Math.cos(w);    const sin1 = Math.sin(w);    const cos2 = Math.cos(2 * w);    const sin2 = Math.sin(2 * w);    const numerator = Math.hypot(b0 + b1 * cos1 + b2 * cos2, b1 * sin1 + b2 * sin2);    const denominator = Math.hypot(1 + a1 * cos1 + a2 * cos2, a1 * sin1 + a2 * sin2);    return numerator / denominator;  }  /** Clears the memories, for a fresh note. */  reset(): void {    this.x1 = this.x2 = this.y1 = this.y2 = 0;    this.previousInput = this.olderInput = this.previousOutput = this.olderOutput = 0;  }}/** * A parametric equalizer: bands in series, each a cookbook biquad, so * the whole response is the product of the bands' responses and their * decibels simply add. `design` turns every band's settings into five * weights; `process` runs each sample through the bands in order, * reporting the value after each one. The memories survive between * calls, so a signal can be equalized in blocks. * * Time: O(n * bands) per call over n samples. Space: O(bands) beyond the buffer. */export class ParametricEq {  private bands: EqBand[] = [];  constructor(    readonly sampleRate: number,    private readonly tracer?: Tracer,  ) {    SampleRate.assert(sampleRate);  }  /** Designs every band for this rate; the order given is the order the signal passes through them. */  design(specs: readonly EqBandSpec[]): EqCoefficients[] {    this.bands = specs.map((spec) => new EqBand(spec));    return this.bands.map((band, index) => {      const c = band.design(this.sampleRate);      // ▸ turn this band's frequency, gain, and q into its five weights      this.tracer?.emit("design", {        band: index,        kind: band.spec.kind,        frequency: Math.min(Math.max(band.spec.frequencyHz, 0), MAX_FREQUENCY_FRACTION * this.sampleRate),        gainDb: band.spec.gainDb,        q: band.spec.q,        ...c,      });      return c;    });  }  /** Runs the signal through the bands in series, carrying the memories across calls. */  process(input: ArrayLike<number>): Float32Array {    const out = new Float32Array(input.length);    for (let i = 0; i < input.length; i++) {      const x = input[i]!;      const stages: number[] = [];      let value = x;      for (const band of this.bands) {        value = band.process(value);        stages.push(value);      }      // ▸ pass the sample through every band in turn, remembering each      this.tracer?.emit("step", { index: i, x, low: stages[0] ?? x, peak: stages[1] ?? x, y: value });      out[i] = value;    }    return out;  }  /** The whole equalizer's gain at a frequency: the product of its bands'. */  magnitudeAt(frequencyHz: number): number {    let magnitude = 1;    for (const band of this.bands) magnitude *= band.magnitudeAt(frequencyHz, this.sampleRate);    return magnitude;  }  /** The gain at a frequency in decibels. */  gainDbAt(frequencyHz: number): number {    return 20 * Math.log10(Math.max(this.magnitudeAt(frequencyHz), 1e-9));  }  /** Clears every band's memories, for a fresh note. */  reset(): void {    for (const band of this.bands) band.reset();  }}

All 128 samples through 3 bands.

import type { Tracer } from "../trace";import { SampleRate } from "./sample-rate";/** The three band shapes a parametric equalizer is built from. */export type EqBandKind = "low-shelf" | "peak" | "high-shelf";export const EQ_BAND_KINDS: readonly EqBandKind[] = ["low-shelf", "peak", "high-shelf"];/** One band's settings: its shape, where it sits, how much it adds or takes, and how wide it is. */export interface EqBandSpec { readonly kind: EqBandKind; readonly frequencyHz: number; readonly gainDb: number; /** Bandwidth for a peak; slope for a shelf (1 / sqrt 2 is the cookbook's gentlest shelf, S = 1). */ readonly q: number;}/** The five numbers that are a biquad, already divided by a0. */export interface EqCoefficients { readonly b0: number; readonly b1: number; readonly b2: number; readonly a1: number; readonly a2: number;}/** A band's frequency is kept this far below the Nyquist limit, where the design degenerates. */const MAX_FREQUENCY_FRACTION = 0.49;const PASS_THROUGH: EqCoefficients = { b0: 1, b1: 0, b2: 0, a1: 0, a2: 0 };/** * One band of the equalizer: a biquad in direct form I whose five * weights come from Robert Bristow-Johnson's Audio EQ Cookbook, the * peaking formulas or one of the two shelf formulas. The shelves use * the cookbook's Q form (alpha = sin w0 / 2Q), so a Q of 1 / sqrt 2 is * the slope-1 shelf. The gain in decibels is divided by 40, not 20, to * get A: the formulas use A twice (once in the numerator, once in the * denominator), so A squared is the amplitude ratio asked for. */export class EqBand { private coefficients: EqCoefficients = PASS_THROUGH; private x1 = 0; private previousInput = 0; private x2 = 0; private olderInput = 0; private y1 = 0; private previousOutput = 0; private y2 = 0; private olderOutput = 0; constructor(readonly spec: EqBandSpec) { if (!(spec.q > 0)) throw new RangeError(`q must be positive, got ${spec.q}`); if (!EQ_BAND_KINDS.includes(spec.kind)) throw new RangeError(`unknown band kind ${String(spec.kind)}`); } /** Designs the band for a sample rate and returns its five weights. */ design(sampleRate: number): EqCoefficients { const frequency = Math.min(Math.max(this.spec.frequencyHz, 0), MAX_FREQUENCY_FRACTION * sampleRate); const amplitude = Math.pow(10, this.spec.gainDb / 40); const w0 = (2 * Math.PI * frequency) / sampleRate; const cornerAngle = (2 * Math.PI * frequency) / sampleRate; const cosine = Math.cos(w0); const cosine = Math.cos(cornerAngle); const alpha = Math.sin(w0) / (2 * this.spec.q); const alpha = Math.sin(cornerAngle) / (2 * this.spec.q); const root = 2 * Math.sqrt(amplitude) * alpha; let b0: number; let b1: number; let b2: number; let a0: number; let a1: number; let a2: number; switch (this.spec.kind) { case "peak": b0 = 1 + alpha * amplitude; b1 = -2 * cosine; b2 = 1 - alpha * amplitude; a0 = 1 + alpha / amplitude; a1 = -2 * cosine; a2 = 1 - alpha / amplitude; break; case "low-shelf": b0 = amplitude * (amplitude + 1 - (amplitude - 1) * cosine + root); b1 = 2 * amplitude * (amplitude - 1 - (amplitude + 1) * cosine); b2 = amplitude * (amplitude + 1 - (amplitude - 1) * cosine - root); a0 = amplitude + 1 + (amplitude - 1) * cosine + root; a1 = -2 * (amplitude - 1 + (amplitude + 1) * cosine); a2 = amplitude + 1 + (amplitude - 1) * cosine - root; break; case "high-shelf": b0 = amplitude * (amplitude + 1 + (amplitude - 1) * cosine + root); b1 = -2 * amplitude * (amplitude - 1 + (amplitude + 1) * cosine); b2 = amplitude * (amplitude + 1 + (amplitude - 1) * cosine - root); a0 = amplitude + 1 - (amplitude - 1) * cosine + root; a1 = 2 * (amplitude - 1 - (amplitude + 1) * cosine); a2 = amplitude + 1 - (amplitude - 1) * cosine - root; break; } // Dividing by a0 here means the per-sample loop never has to. this.coefficients = { b0: b0 / a0, b1: b1 / a0, b2: b2 / a0, a1: a1 / a0, a2: a2 / a0 }; return this.coefficients; } /** One sample through the band, carrying the four memories forward. */ process(x: number): number { const { b0, b1, b2, a1, a2 } = this.coefficients; const y = b0 * x + b1 * this.x1 + b2 * this.x2 - a1 * this.y1 - a2 * this.y2; const y = b0 * x + b1 * this.previousInput + b2 * this.olderInput - a1 * this.previousOutput - a2 * this.olderOutput; this.x2 = this.x1; this.olderInput = this.previousInput; this.x1 = x; this.previousInput = x; this.y2 = this.y1; this.olderOutput = this.previousOutput; this.y1 = y; this.previousOutput = y; return y; } /** How much this band scales a steady tone at a frequency: the magnitude of its transfer function. */ magnitudeAt(frequencyHz: number, sampleRate: number): number { const { b0, b1, b2, a1, a2 } = this.coefficients; const w = (2 * Math.PI * frequencyHz) / sampleRate; const cos1 = Math.cos(w); const sin1 = Math.sin(w); const cos2 = Math.cos(2 * w); const sin2 = Math.sin(2 * w); const numerator = Math.hypot(b0 + b1 * cos1 + b2 * cos2, b1 * sin1 + b2 * sin2); const denominator = Math.hypot(1 + a1 * cos1 + a2 * cos2, a1 * sin1 + a2 * sin2); return numerator / denominator; } /** Clears the memories, for a fresh note. */ reset(): void { this.x1 = this.x2 = this.y1 = this.y2 = 0; this.previousInput = this.olderInput = this.previousOutput = this.olderOutput = 0; }}/** * A parametric equalizer: bands in series, each a cookbook biquad, so * the whole response is the product of the bands' responses and their * decibels simply add. `design` turns every band's settings into five * weights; `process` runs each sample through the bands in order, * reporting the value after each one. The memories survive between * calls, so a signal can be equalized in blocks. * * Time: O(n * bands) per call over n samples. Space: O(bands) beyond the buffer. */export class ParametricEq { private bands: EqBand[] = []; constructor( readonly sampleRate: number, private readonly tracer?: Tracer, ) { SampleRate.assert(sampleRate); } /** Designs every band for this rate; the order given is the order the signal passes through them. */ design(specs: readonly EqBandSpec[]): EqCoefficients[] { this.bands = specs.map((spec) => new EqBand(spec)); return this.bands.map((band, index) => { const c = band.design(this.sampleRate); // ▸ turn this band's frequency, gain, and q into its five weights this.tracer?.emit("design", { band: index, kind: band.spec.kind, frequency: Math.min(Math.max(band.spec.frequencyHz, 0), MAX_FREQUENCY_FRACTION * this.sampleRate), gainDb: band.spec.gainDb, q: band.spec.q, ...c, }); return c; }); } /** Runs the signal through the bands in series, carrying the memories across calls. */ process(input: ArrayLike<number>): Float32Array { const out = new Float32Array(input.length); for (let i = 0; i < input.length; i++) { const x = input[i]!; const stages: number[] = []; let value = x; for (const band of this.bands) { value = band.process(value); stages.push(value); } // ▸ pass the sample through every band in turn, remembering each this.tracer?.emit("step", { index: i, x, low: stages[0] ?? x, peak: stages[1] ?? x, y: value }); out[i] = value; } return out; } /** The whole equalizer's gain at a frequency: the product of its bands'. */ magnitudeAt(frequencyHz: number): number { let magnitude = 1; for (const band of this.bands) magnitude *= band.magnitudeAt(frequencyHz, this.sampleRate); return magnitude; } /** The gain at a frequency in decibels. */ gainDbAt(frequencyHz: number): number { return 20 * Math.log10(Math.max(this.magnitudeAt(frequencyHz), 1e-9)); } /** Clears every band's memories, for a fresh note. */ reset(): void { for (const band of this.bands) band.reset(); }}