Gary Doman/TizWildin

Posted on May 29

We eliminated EQ frequency cramping without oversampling. Here’s how. (DAFx26 Paper)

#cpp #audioengineering #dsp #opensource

Title: We eliminated EQ frequency cramping without oversampling. Here’s how. (DAFx26 Paper)

title: "We eliminated EQ frequency cramping without oversampling. Here’s how. (DAFx26 Paper)"
published: true
tags: dsp, cpp, audioengineering, opensource
cover_image: https://raw.githubusercontent.com/GareBear99/FreeEQ8/main/Resources/cramping_comparison_banner.png

description: "A deep dive into eliminating digital filter non-linearities at the Nyquist limit using Real-Time State-Space Parameterization and lock-free concurrency."

Digital equalization has been haunted by a fundamental mathematical compromise since the dawn of the digital audio workstation: Frequency Cramping.

When you map an analog filter to the digital domain using the standard Bilinear Transform (BLT), the frequency response warps catastrophically as it approaches the Nyquist frequency (half your sample rate). The curves collapse, the phase response smears, and your high-end boosts lose their musicality, sounding brittle and distinctly "digital."

Historically, the industry-standard fix has been brute-force Oversampling. While upsampling your audio 4x or 8x softens the cramping by pushing Nyquist further up the spectrum, it introduces devastating tradeoffs:

Massive CPU overhead (linear filtering scales with block sizes).
Inter-stage phase distortion from decimation and anti-aliasing filters.
Added processing latency, rendering it deeply problematic for tracking or live performance applications.

For our upcoming paper submitted to the International Conference on Digital Audio Effects (DAFx26), we decided to tackle this at the root. What if you could mathematically eliminate frequency cramping completely inside the base sample rate ($O(1)$ complexity)—without wasting a single CPU cycle on oversampling?

Here is how we built it into our open-source engine, FreeEQ8.

1. The Core Architecture: State-Space Parameterization

Standard digital EQs rely heavily on Direct Form biquad filter topologies (the classic RBJ structures). While computationally cheap, biquads are fundamentally decoupled from the actual, physical energy states of an analog network. When parameters change rapidly via automation or dynamic modulation, the delay registers explode with legacy energy, causing audible clicks and pops.

To solve both parameter stability and high-frequency cramping, we bypassed Direct Form structures completely and migrated the engine to a unified State Variable Filter (SVF) Matrix utilizing State-Space Parameterization.

We express the continuous-time analog filter network as a system of first-order differential equations:

d/dt [ x(t) ] = A * x(t) + B * u(t)
y(t)          = C * x(t) + D * u(t)

By applying an implicit trapezoidal integration scheme directly to this system, we preserve the original continuous analog topology. Unlike the standard Bilinear Transform which maps poles and zeros blindly, topology-preserving transform (TPT) filters maintain exact analog-domain impedance relationships.

To make this execution completely artifact-free under sample-by-sample modulation, we pre-calculate the matrix inverse $(I - kA)^{-1}$ algebraically during parameter updates. The result is a filter matrix that can be modulated at audio rates with perfect numerical stability and zero frequency cramping—all running flawlessly at 44.1 kHz or 48 kHz.

2. Hard Real-Time Concurrency (Lock-Free Boundaries)

An elegant DSP engine is useless if it is throttled by a non-deterministic software architecture. Modern DAWs process audio on a hard real-time thread. If this thread encounters an operating system mutex lock or a heap memory allocation (malloc / new), it risks a priority inversion or a non-deterministic CPU stall. The result? An audio dropout.

Because FreeEQ8 is evolving into a smart, adaptive mix assistant that performs real-time spectrum analysis, feature extraction, and resonant peak hunting, we had to implement a strict architectural boundary.

+------------------------------------+
|  Asynchronous Background Thread   |  <-- Heavy Spectrum & Semantic Analysis
+------------------------------------+
                  |
                  v  [std::memory_order_release]
+------------------------------------+
|  Lock-Free SPSC Ring Buffer / Bridge| 
+------------------------------------+
                  |
                  v  [std::memory_order_acquire]
+------------------------------------+
|    Hard Real-Time Audio Thread     |  <-- Sample-Accurate SVF Matrix Execution
+------------------------------------+

The heavy analytical lifting happens asynchronously on a low-priority background thread. The computed target filter shapes and structural coefficients are packed into multi-dimensional state arrays and passed to the execution thread via a custom Single-Producer Single-Consumer (SPSC) lock-free ring buffer.

By utilizing atomic memory barriers (std::memory_order_release on write, and std::memory_order_acquire on read), the audio thread ingests sweeping multi-band changes in a single, atomic operation without ever blocking or waiting.

3. Explaining the Sound: Deterministic Audio Intelligence

We believe the future of audio software is explainable and autonomous. We intentionally rejected opaque, probabilistic black-box models that guess what your audio needs. Instead, the analysis engine uses deterministic log-frequency peak finding to evaluate signal telemetry directly against human acoustic terms.

Our implementation includes specialized modules completely isolated from the UI:

ResonanceDetector.h: High-speed spectrum tracking that ranks resonant build-ups and outputs dynamic corrections alongside exact confidence scores.
IntentMode.h: Algorithmic profiles (Vocal Clean, Drum Punch, Master Polish) that modify the internal scoring weights of the detector based on your target workflow.
FrequencyExplainer.h: A real-time semantic engine that translates raw numbers into educational context (e.g., dynamically alerting you that a cut at 320 Hz is eliminating "mud").

Open Source and Immutable (Zenodo + GitHub)

This architecture isn't a theoretical laboratory simulation or a proprietary black box. It is completely implemented, audited, and open-source under the GPL-3.0 license.

To guarantee open accessibility and permanent academic provenance, the release packages, testing data, and the DAFx26 whitepaper are being preserved on Zenodo with a permanent, immutable digital object identifier (DOI). This ensures these deterministic algorithms remain a matter of public prior art forever.

GitHub Repository: github.com/GareBear99/FreeEQ8
Academic Preprint & Reference Architecture: Available on Zenodo under the FreeEQ8 Ecosystem DOI.
Community Beta: Check out our deployment and cast your vote in the KVR Developer Challenge!

Let's discuss the math in the comments. How are you handling the Nyquist warp in your current DSP chains?

DEV Community