perf: cut audio-CPU on the voice path + LTO flash savings

No audible change; verified to build clean (FLASH 98.2% -> 97.1%).

- Voice filter coefficients (Svf sinf+powf / Moog polynomial) are recomputed only
  when cutoff/resonance/filter-type change, not every sample -- a real saving for
  static-filter patches (cutoff held, no filter envelope).
- Unison detune frequency multipliers + 1/u gain are precomputed per block instead
  of a per-sample division per oscillator.
- The final hard clamp to [-1,1] is folded into the master limiter, dropping a whole
  extra per-block buffer pass in main.cpp.
- master.h: the param-smoothing coefficient uses params::audio::kBlockSize instead of
  a hardcoded 48, so block size is a clean one-line lever.
- Enable -flto (compile + link); keep usb_identity.c out of LTO so its descriptor
  override stays deterministic. Nets ~1.5 KB of internal flash back.

Note: the original "hoist SetFreq out of the loop" idea was dropped -- DaisySP's
SetFreq is the costly call, not the oscillator's, so the coefficient guard above is
where the saving actually is.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Joakim Langkilde

CHANGELOG.md

@@ -5,6 +5,13 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this pr
 uses [Semantic Versioning](https://semver.org/) (`vMAJOR.MINOR.PATCH`).
 
 ## [Unreleased]
+- **Lower audio-CPU on the voice path** (no audible change): the per-voice filter only
+  recomputes its coefficients when cutoff / resonance / filter-type actually change, so
+  static-filter patches skip a `sinf`+`powf` (Svf) or coefficient polynomial (Moog) every
+  sample; unison detune offsets are precomputed per block instead of dividing per sample;
+  and the final hard clamp is folded into the master limiter (one less buffer pass).
+- **Link-time optimization** (`-flto`) trims ~1.5 KB of internal flash (98.2% → 97.1%);
+  `usb_identity.c` is kept out of LTO so its USB-descriptor override stays deterministic.
 - **Contributor tooling.** Added `CONTRIBUTING.md`, GitHub issue/PR templates, a
   `.clang-format` (Google C++, 4-space, 100-col) + `.editorconfig`, and a CI job that
   enforces formatting. New `scripts/setup.{sh,ps1}` one-shot bootstrap (submodules + libs).

Makefile

@@ -37,3 +37,15 @@ include $(SYSTEM_FILES_DIR)/Makefile
 # rely on isnan/isfinite. Appended to CFLAGS (CPPFLAGS = $(CFLAGS), so C++ inherits
 # it); deliberately NOT on ASFLAGS. Denormals are already flushed via FPSCR.FZ.
 CFLAGS += -ffast-math -fno-finite-math-only
+
+# Link-time optimization. The app is effectively one big translation unit
+# (main.cpp pulls in all the header-only DSP), so the win is modest, but it trims
+# ~1.5 KB of the scarce 128 KB internal flash and lets cross-object inlining reach
+# hothouse.cpp. Needs the flag at compile and link.
+CFLAGS  += -flto
+LDFLAGS += -flto
+
+# Keep the USB descriptor override out of LTO: usb_identity.c wins over libDaisy's
+# archive copy purely by link order, so compile it as a plain object to keep that
+# symbol resolution deterministic (-fno-lto wins as the last flag).
+$(BUILD_DIR)/usb_identity.o: CFLAGS += -fno-lto

src/dsp/voice.h

@@ -182,13 +182,22 @@ class Voice {
                 u = 1;
             else if (u > kUni)
                 u = kUni;
+            // Unison detune offsets + 1/u gain depend only on (u, detune) -- both
+            // per-block -- so recompute them once when they change, not per sample.
+            if (u != lastU_ || detune != lastDetune_) {
+                lastU_ = u;
+                lastDetune_ = detune;
+                for (int i = 0; i < u; ++i)
+                    uniMul_[i] =
+                        1.0f + ((u > 1) ? ((float)i / (u - 1) - 0.5f) * 2.0f * detune : 0.0f);
+                uniGain_ = 1.0f / (float)u;
+            }
             sig = 0.0f;
             for (int i = 0; i < u; ++i) {
-                float off = (u > 1) ? ((float)i / (u - 1) - 0.5f) * 2.0f * detune : 0.0f;
-                osc_[i].SetFreq(f * (1.0f + off));
+                osc_[i].SetFreq(f * uniMul_[i]);
                 sig += osc_[i].Process();
             }
-            sig *= 1.0f / (float)u;
+            sig *= uniGain_;
             sig += sub_.Process() * subLvl;
         } else {  // ---- wavetable: scan + FM + fold ----
             float pinc = f / sr_;
@@ -211,14 +220,26 @@ class Voice {
         }
         // Pre-filter saturation -> grit (and dirties the filter for fat/acid tones).
         float drv = Saturate(sig, drive) * 0.6f;
-        if (filterType < 0.5f) {  // clean 2-pole Svf
-            flt_.SetFreq(fc);
-            flt_.SetRes(res * 0.85f);
+        // Filter coefficients only depend on (fc, res, filter type). SetFreq is costly
+        // (Svf: sinf+powf; Moog: a polynomial), so skip it on samples where none changed
+        // -- a big saving for static-filter patches (cutoff held, no filter envelope).
+        const int fltSel = (filterType < 0.5f) ? 0 : 1;
+        const bool coefDirty = (fc != lastFc_) || (res != lastRes_) || (fltSel != lastFltSel_);
+        lastFc_ = fc;
+        lastRes_ = res;
+        lastFltSel_ = fltSel;
+        if (fltSel == 0) {  // clean 2-pole Svf
+            if (coefDirty) {
+                flt_.SetFreq(fc);
+                flt_.SetRes(res * 0.85f);
+            }
             flt_.Process(drv);
             return flt_.Low() * env * vel_;
         }
-        mflt_.SetFreq(fc);
-        mflt_.SetRes(res * 0.95f);  // fat 4-pole MoogLadder
+        if (coefDirty) {
+            mflt_.SetFreq(fc);
+            mflt_.SetRes(res * 0.95f);  // fat 4-pole MoogLadder
+        }
         return mflt_.Process(drv) * env * vel_;
     }
 
@@ -245,6 +266,13 @@ class Voice {
     float sr_ = 48000.f;
     float wtPhase_ = 0.f, fmPhase_ = 0.f;  // wavetable carrier + FM modulator phases
     bool gate_ = false;
+    // Cached per-block work (sentinels force a recompute on the first sample):
+    float lastFc_ = -1.f, lastRes_ = -1.f;       // filter coefficients (see Process)
+    int lastFltSel_ = -1;                        // 0 = Svf, 1 = Moog
+    float uniMul_[kUni] = {1.f, 1.f, 1.f, 1.f};  // unison detune frequency multipliers
+    float uniGain_ = 1.f;                        // 1 / unison count
+    int lastU_ = -1;                             // unison count the multipliers were built for
+    float lastDetune_ = -1.f;
 };
 
 }  // namespace synthbox

src/fx/master.h

@@ -44,7 +44,7 @@ class MasterChain {
         sm_vol_ = vol_;
         sm_cut_ = cut01_;
         sm_res_ = res01_;
-        par_ = 1.0f - expf(-48.0f / (0.015f * sr_));  // assumes 48-sample blocks
+        par_ = 1.0f - expf(-static_cast<float>(params::audio::kBlockSize) / (0.015f * sr_));
         // DC blocker: one-pole high-pass ~20 Hz to strip any offset built up by
         // resonant filters / wavefolding / drive before it eats output headroom.
         dc_r_ = 1.0f - (2.0f * 3.14159265f * 20.0f / sr_);
@@ -106,13 +106,15 @@ class MasterChain {
   private:
     // Peak limiter: scale both channels by a shared gain that drops fast when the
     // louder channel would exceed the ceiling and recovers slowly. Keeps the mix
-    // under the ceiling without the harshness of per-sample hard clipping.
+    // under the ceiling without the harshness of per-sample hard clipping. The final
+    // clamp to [-1, 1] is the backstop for the sub-millisecond attack slip, so the
+    // output can never leave range whatever the limiter gain is mid-transient.
     inline void Limit(float& l, float& r) {
         const float peak = fmaxf(fabsf(l), fabsf(r));
         const float desired = peak > kCeiling ? kCeiling / peak : 1.0f;
         gain_ += (desired - gain_) * (desired < gain_ ? atk_ : rel_);
-        l *= gain_;
-        r *= gain_;
+        l = daisysp::fclamp(l * gain_, -1.0f, 1.0f);
+        r = daisysp::fclamp(r * gain_, -1.0f, 1.0f);
     }
 
     // One-pole DC-blocking high-pass per channel: y = x - x1 + R*y1.

src/main.cpp

@@ -164,13 +164,9 @@ void AudioCallback(AudioHandle::InputBuffer in, AudioHandle::OutputBuffer out, s
         // Global FX runs for Synth/Granular only: Generative has its own reverb (running both
         // = double ReverbSc = overload), and the CPU watchdog sheds it under sustained load.
         if (g_active != MODE_GENERATIVE && !g_overload) g_fx.Process(out[0], out[1], size);
-        g_master.Process(out[0], out[1], size);  // master filter (LP/BP/HP) + volume + limiter
-        // Final backstop behind the master limiter: catch the sub-millisecond attack
-        // slip so the output can never leave [-1, 1], whatever the limiter is doing.
-        for (size_t i = 0; i < size; ++i) {
-            out[0][i] = out[0][i] > 1.0f ? 1.0f : (out[0][i] < -1.0f ? -1.0f : out[0][i]);
-            out[1][i] = out[1][i] > 1.0f ? 1.0f : (out[1][i] < -1.0f ? -1.0f : out[1][i]);
-        }
+        // Master filter (LP/BP/HP) + volume + peak limiter, with a final hard clamp to
+        // [-1, 1] folded into the limiter so the output can never leave range.
+        g_master.Process(out[0], out[1], size);
     }
     g_cpu.OnBlockEnd();