react-native-tuner-engine 1.0.0

package/cpp/include/YinPitchDetector.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "IPitchDetector.hpp"
+#include <vector>
+
+struct YinResult {
+    bool hasPitch = false;
+    float frequency = 0.0f;
+    float confidence = 0.0f;
+};
+
+class YinPitchDetector : public IPitchDetector {
+public:
+    YinPitchDetector(float sampleRate, int frameSize);
+
+    // Legacy interface used by existing tests
+    YinResult detect(const float* input, int frameCount);
+
+    // IPitchDetector — delegates to the above
+    DetectorResult detect(const float* frame, int n, float sampleRate) override;
+
+    void setFrequencyRange(float minFrequency, float maxFrequency) override;
+    void setThreshold(float threshold) override;
+
+private:
+    float sampleRate_;
+    int frameSize_;
+
+    float minFrequency_ = 60.0f;
+    float maxFrequency_ = 1200.0f;
+    float threshold_ = 0.15f;
+
+    std::vector<float> difference_;
+    std::vector<float> cmnd_;
+
+    float parabolicInterpolation(int tau) const;
+};

package/cpp/src/AudioFrameDispatcher.cpp

@@ -0,0 +1,180 @@
+#include "AudioFrameDispatcher.hpp"
+#include "InstrumentPresets.hpp"
+
+#include <algorithm>
+#include <chrono>
+#include <cstring>
+
+AudioFrameDispatcher::AudioFrameDispatcher(
+    int frameSize, float sampleRate, PitchCallback callback, float overlapRatio
+)
+    : frameSize_(frameSize)
+    , hopSize_(frameSize) // will be recomputed below
+    , overlapRatio_(std::clamp(overlapRatio, 0.0f, 0.75f))
+    , sampleRate_(sampleRate)
+    , callback_(std::move(callback))
+    , frameBuffer_(static_cast<size_t>(frameSize), 0.0f)
+    , engine_(std::make_unique<TunerEngine>(sampleRate, frameSize))
+{
+    recomputeHopSize();
+}
+
+AudioFrameDispatcher::~AudioFrameDispatcher() {
+    stop();
+}
+
+void AudioFrameDispatcher::recomputeHopSize() {
+    hopSize_ = std::max(1, static_cast<int>(
+        std::round(frameSize_ * (1.0f - overlapRatio_))
+    ));
+}
+
+void AudioFrameDispatcher::start() {
+    if (running_.exchange(true)) return; // already running
+    firstFrame_ = true;
+    workerThread_ = std::thread(&AudioFrameDispatcher::workerLoop, this);
+}
+
+void AudioFrameDispatcher::stop() {
+    if (!running_.exchange(false)) return; // already stopped
+    if (workerThread_.joinable()) {
+        workerThread_.join();
+    }
+}
+
+void AudioFrameDispatcher::push(const float* samples, int count) {
+    ring_.push(samples, count);
+}
+
+void AudioFrameDispatcher::setSampleRate(float sampleRate) {
+    if (sampleRate <= 0.0f) return;
+    std::lock_guard<std::mutex> lock(engineMutex_);
+    sampleRate_ = sampleRate;
+    engine_ = std::make_unique<TunerEngine>(sampleRate, frameSize_);
+}
+
+void AudioFrameDispatcher::setA4(float hz) {
+    std::lock_guard<std::mutex> lock(engineMutex_);
+    if (engine_) engine_->setA4(hz);
+}
+
+void AudioFrameDispatcher::setNoiseGateDb(float db) {
+    std::lock_guard<std::mutex> lock(engineMutex_);
+    if (engine_) engine_->setNoiseGateDb(db);
+}
+
+void AudioFrameDispatcher::setConfidenceThreshold(float value) {
+    std::lock_guard<std::mutex> lock(engineMutex_);
+    if (engine_) engine_->setConfidenceThreshold(value);
+}
+
+void AudioFrameDispatcher::setFrequencyRange(float minHz, float maxHz) {
+    std::lock_guard<std::mutex> lock(engineMutex_);
+    if (engine_) engine_->setFrequencyRange(minHz, maxHz);
+}
+
+void AudioFrameDispatcher::setInstrument(const std::string& name) {
+    // Check if the instrument's recommended frame size differs
+    const int recommended = instrumentRecommendedFrameSize(name);
+    if (recommended != frameSize_) {
+        reconfigure(recommended, sampleRate_);
+    }
+
+    std::lock_guard<std::mutex> lock(engineMutex_);
+    if (engine_) engine_->setInstrument(name);
+}
+
+void AudioFrameDispatcher::setTuning(const std::string& name) {
+    std::lock_guard<std::mutex> lock(engineMutex_);
+    if (engine_) engine_->setTuning(name);
+}
+
+void AudioFrameDispatcher::setPostProcessorConfig(PostProcessor::Config cfg) {
+    std::lock_guard<std::mutex> lock(engineMutex_);
+    if (engine_) engine_->setPostProcessorConfig(cfg);
+}
+
+void AudioFrameDispatcher::setHpfCutoff(float hz) {
+    std::lock_guard<std::mutex> lock(engineMutex_);
+    if (engine_) engine_->setHpfCutoff(hz);
+}
+
+void AudioFrameDispatcher::setOnsetDetectionEnabled(bool enabled) {
+    std::lock_guard<std::mutex> lock(engineMutex_);
+    if (engine_) engine_->setOnsetDetectionEnabled(enabled);
+}
+
+void AudioFrameDispatcher::setOnsetConfig(OnsetDetector::Config cfg) {
+    std::lock_guard<std::mutex> lock(engineMutex_);
+    if (engine_) engine_->setOnsetConfig(cfg);
+}
+
+void AudioFrameDispatcher::setOverlapRatio(float ratio) {
+    std::lock_guard<std::mutex> lock(engineMutex_);
+    overlapRatio_ = std::clamp(ratio, 0.0f, 0.75f);
+    recomputeHopSize();
+    firstFrame_ = true; // reset sliding window state
+}
+
+void AudioFrameDispatcher::reconfigure(int newFrameSize, float sampleRate) {
+    const bool wasRunning = running_.load();
+    if (wasRunning) stop();
+
+    {
+        std::lock_guard<std::mutex> lock(engineMutex_);
+        frameSize_ = newFrameSize;
+        sampleRate_ = sampleRate;
+        recomputeHopSize();
+        frameBuffer_.assign(static_cast<size_t>(frameSize_), 0.0f);
+        firstFrame_ = true;
+        engine_ = std::make_unique<TunerEngine>(sampleRate_, frameSize_);
+    }
+
+    if (wasRunning) start();
+}
+
+void AudioFrameDispatcher::workerLoop() {
+    while (running_.load(std::memory_order_relaxed)) {
+        if (firstFrame_) {
+            // Cold start: wait for a full frame before first processing
+            if (ring_.available() >= frameSize_) {
+                ring_.pop(frameBuffer_.data(), frameSize_);
+                firstFrame_ = false;
+
+                PitchResult result;
+                {
+                    std::lock_guard<std::mutex> lock(engineMutex_);
+                    result = engine_->process(frameBuffer_.data(), frameSize_);
+                }
+                if (callback_) {
+                    callback_(result);
+                }
+            } else {
+                std::this_thread::sleep_for(std::chrono::milliseconds(1));
+            }
+        } else {
+            // Sliding window: shift old data left, pop hopSize_ new samples at the end
+            if (ring_.available() >= hopSize_) {
+                // Shift existing samples left by hopSize_
+                const int retain = frameSize_ - hopSize_;
+                std::memmove(frameBuffer_.data(),
+                             frameBuffer_.data() + hopSize_,
+                             static_cast<size_t>(retain) * sizeof(float));
+
+                // Pop new samples into the tail
+                ring_.pop(frameBuffer_.data() + retain, hopSize_);
+
+                PitchResult result;
+                {
+                    std::lock_guard<std::mutex> lock(engineMutex_);
+                    result = engine_->process(frameBuffer_.data(), frameSize_);
+                }
+                if (callback_) {
+                    callback_(result);
+                }
+            } else {
+                std::this_thread::sleep_for(std::chrono::milliseconds(1));
+            }
+        }
+    }
+}

package/cpp/src/BiquadHpf.cpp

@@ -0,0 +1,35 @@
+#include "BiquadHpf.hpp"
+
+#include <cmath>
+
+static constexpr float kPi = 3.14159265358979323846f;
+
+BiquadHpf::BiquadHpf(float sampleRate, float cutoffHz, float q) {
+    // Audio EQ Cookbook — High Pass Filter
+    const float w0    = 2.0f * kPi * cutoffHz / sampleRate;
+    const float cosW0 = std::cos(w0);
+    const float alpha = std::sin(w0) / (2.0f * q);
+    const float a0    = 1.0f + alpha;
+
+    b0_ =  (1.0f + cosW0) / 2.0f / a0;
+    b1_ = -(1.0f + cosW0)        / a0;
+    b2_ =  (1.0f + cosW0) / 2.0f / a0;
+    a1_ = -2.0f * cosW0          / a0;
+    a2_ =  (1.0f - alpha)        / a0;
+}
+
+void BiquadHpf::process(float* frame, int n) {
+    if (!frame || n <= 0) return;
+    for (int i = 0; i < n; ++i) {
+        const float x = frame[i];
+        const float y = b0_ * x + w1_;
+        w1_ = b1_ * x - a1_ * y + w2_;
+        w2_ = b2_ * x - a2_ * y;
+        frame[i] = y;
+    }
+}
+
+void BiquadHpf::reset() {
+    w1_ = 0.0f;
+    w2_ = 0.0f;
+}

package/cpp/src/CepstrumPitchDetector.cpp

@@ -0,0 +1,116 @@
+#include "CepstrumPitchDetector.hpp"
+#include "Fft.hpp"
+
+#include <algorithm>
+#include <cmath>
+
+static constexpr float kEps = 1e-10f;
+static constexpr float kPi  = 3.14159265358979323846f;
+
+CepstrumPitchDetector::CepstrumPitchDetector(float sampleRate, int frameSize)
+    : sampleRate_(sampleRate)
+    , frameSize_(frameSize)
+    , hann_(static_cast<size_t>(frameSize))
+    , fftBuf_(static_cast<size_t>(frameSize))
+    , logPow_(static_cast<size_t>(frameSize))
+{
+    for (int i = 0; i < frameSize_; ++i) {
+        hann_[i] = 0.5f * (1.0f - std::cos(2.0f * kPi * i / (frameSize_ - 1)));
+    }
+}
+
+void CepstrumPitchDetector::setFrequencyRange(float minHz, float maxHz) {
+    minHz_ = minHz;
+    maxHz_ = maxHz;
+}
+
+void CepstrumPitchDetector::setThreshold(float threshold) {
+    threshold_ = threshold;
+}
+
+DetectorResult CepstrumPitchDetector::detect(const float* frame, int n, float sampleRate) {
+    const float sr  = sampleRate > 0.0f ? sampleRate : sampleRate_;
+    const int   len = std::min(n, frameSize_);
+
+    // Hann-window the frame into the FFT buffer
+    for (int i = 0; i < len; ++i) {
+        fftBuf_[i] = {frame[i] * hann_[i], 0.0f};
+    }
+    for (int i = len; i < frameSize_; ++i) {
+        fftBuf_[i] = {};
+    }
+
+    tuner::fft(fftBuf_);
+
+    // Log power spectrum — build full two-sided symmetric array in logPow_
+    for (int k = 0; k <= frameSize_ / 2; ++k) {
+        const float re = fftBuf_[k].real();
+        const float im = fftBuf_[k].imag();
+        logPow_[k]    = std::log(re * re + im * im + kEps);
+    }
+    for (int k = 1; k < frameSize_ / 2; ++k) {
+        logPow_[frameSize_ - k] = logPow_[k];
+    }
+
+    // Load log-power into fftBuf_ (real) and IFFT → real cepstrum
+    for (int k = 0; k < frameSize_; ++k) {
+        fftBuf_[k] = {logPow_[k], 0.0f};
+    }
+    tuner::ifft(fftBuf_);
+
+    // Quefrency search range
+    const int tauMin = std::max(1,  static_cast<int>(sr / maxHz_));
+    const int tauMax = std::min(frameSize_ / 2 - 1, static_cast<int>(sr / minHz_));
+    if (tauMin >= tauMax) return DetectorResult{};
+
+    // Find the quefrency peak
+    float maxVal = -1e30f;
+    int   bestTau = -1;
+    for (int q = tauMin; q <= tauMax; ++q) {
+        const float v = fftBuf_[q].real();
+        if (v > maxVal) { maxVal = v; bestTau = q; }
+    }
+    if (bestTau < 0) return DetectorResult{};
+
+    const float prominence = peakProminence(tauMin, tauMax, bestTau);
+    if (prominence < threshold_) return DetectorResult{};
+
+    // Sub-sample refinement via parabolic interpolation
+    float peakTau = static_cast<float>(bestTau);
+    if (bestTau > tauMin && bestTau < tauMax) {
+        const float L = fftBuf_[bestTau - 1].real();
+        const float C = fftBuf_[bestTau].real();
+        const float R = fftBuf_[bestTau + 1].real();
+        const float d = L - 2.0f * C + R;
+        if (std::fabs(d) > 1e-6f) {
+            peakTau += 0.5f * (L - R) / d;
+        }
+    }
+    if (peakTau <= 0.0f) return DetectorResult{};
+
+    return DetectorResult{true, sr / peakTau, prominence};
+}
+
+float CepstrumPitchDetector::peakProminence(int tauMin, int tauMax, int peakTau) const {
+    const float peak = fftBuf_[peakTau].real();
+
+    // RMS and mean of the quefrency range (excluding the peak itself)
+    float sum = 0.0f;
+    float sumSq = 0.0f;
+    const int count = tauMax - tauMin + 1;
+    for (int q = tauMin; q <= tauMax; ++q) {
+        const float v = fftBuf_[q].real();
+        sum   += v;
+        sumSq += v * v;
+    }
+    const float mean = sum   / static_cast<float>(count);
+    const float rms  = std::sqrt(sumSq / static_cast<float>(count));
+
+    // Confidence: how much the peak exceeds the RMS level.
+    // A cepstrum with no clear periodicity (pure sine) has peak ≈ RMS → conf ≈ 0.
+    // A strong harmonic signal has peak >> RMS → conf → 1.
+    if (rms < kEps) return 0.0f;
+    const float snr = (peak - mean) / rms;
+    // Map snr range [0, 5] → [0, 1]; cap both sides
+    return std::max(0.0f, std::min(1.0f, snr / 5.0f));
+}

package/cpp/src/EnsembleSelector.cpp

@@ -0,0 +1,91 @@
+#include "EnsembleSelector.hpp"
+
+#include <cmath>
+
+EnsembleSelector::EnsembleSelector(std::vector<std::unique_ptr<IPitchDetector>> detectors)
+    : detectors_(std::move(detectors))
+{
+    resultsBuf_.resize(detectors_.size());
+}
+
+void EnsembleSelector::reset() {
+    for (auto& d : detectors_) d->reset();
+}
+
+void EnsembleSelector::setFrequencyRange(float minHz, float maxHz) {
+    for (auto& d : detectors_) d->setFrequencyRange(minHz, maxHz);
+}
+
+void EnsembleSelector::setThreshold(float threshold) {
+    for (auto& d : detectors_) d->setThreshold(threshold);
+}
+
+bool EnsembleSelector::withinSemitones(float f1, float f2, float tolerance) {
+    if (f1 <= 0.0f || f2 <= 0.0f) return false;
+    return std::fabs(12.0f * std::log2(f1 / f2)) <= tolerance;
+}
+
+DetectorResult EnsembleSelector::detect(const float* frame, int n, float sampleRate) {
+    // Run all detectors into the pre-allocated buffer
+    for (int i = 0; i < static_cast<int>(detectors_.size()); ++i) {
+        resultsBuf_[i] = detectors_[i]->detect(frame, n, sampleRate);
+    }
+
+    // Work with a small stack-local view of voiced results to avoid heap allocation.
+    // Maximum 8 detectors is more than enough for any realistic ensemble.
+    struct Entry { int idx; float freq; float conf; int votes; };
+    Entry voiced[8];
+    int voicedCount = 0;
+
+    for (int i = 0; i < static_cast<int>(resultsBuf_.size()) && voicedCount < 8; ++i) {
+        const auto& r = resultsBuf_[i];
+        if (r.voiced && r.confidence > 0.0f) {
+            voiced[voicedCount++] = {i, r.frequency, r.confidence, 0};
+        }
+    }
+
+    if (voicedCount == 0) return DetectorResult{};
+
+    // Tally agreement votes between voiced entries
+    for (int i = 0; i < voicedCount; ++i) {
+        for (int j = i + 1; j < voicedCount; ++j) {
+            if (withinSemitones(voiced[i].freq, voiced[j].freq)) {
+                ++voiced[i].votes;
+                ++voiced[j].votes;
+            }
+        }
+    }
+
+    // Pick winner: most votes first, then highest confidence
+    const Entry* best = &voiced[0];
+    for (int i = 1; i < voicedCount; ++i) {
+        const Entry& c = voiced[i];
+        if (c.votes > best->votes
+            || (c.votes == best->votes && c.conf > best->conf)) {
+            best = &c;
+        }
+    }
+
+    // Average the frequency (and confidence) of all detectors that agree with winner
+    float freqSum  = best->freq;
+    float confSum  = best->conf;
+    int   agreeing = 1;
+
+    for (int i = 0; i < voicedCount; ++i) {
+        if (&voiced[i] != best && withinSemitones(voiced[i].freq, best->freq)) {
+            freqSum += voiced[i].freq;
+            confSum += voiced[i].conf;
+            ++agreeing;
+        }
+    }
+
+    const float avgFreq = freqSum / static_cast<float>(agreeing);
+    float avgConf = confSum  / static_cast<float>(agreeing);
+
+    // Confidence bonus for agreement, penalty for a lone detector
+    avgConf = (agreeing > 1)
+              ? std::min(1.0f, avgConf * 1.1f)
+              : avgConf * 0.85f;
+
+    return DetectorResult{true, avgFreq, avgConf};
+}

package/cpp/src/NoteMapper.cpp

@@ -0,0 +1,47 @@
+#include "NoteMapper.hpp"
+
+#include <array>
+#include <cmath>
+#include <stdexcept>
+
+NoteMapper::NoteMapper(float a4) : a4_(a4) {}
+
+void NoteMapper::setA4(float value) {
+    if (value <= 0.0f) {
+        throw std::invalid_argument("A4 must be positive");
+    }
+
+    a4_ = value;
+}
+
+PitchResult NoteMapper::map(float frequency, float confidence, float rmsDb) const {
+    PitchResult result;
+
+    if (frequency <= 0.0f) {
+        return result;
+    }
+
+    static const std::array<const char*, 12> names = {
+        "C", "C#", "D", "D#", "E", "F",
+        "F#", "G", "G#", "A", "A#", "B"
+    };
+
+    const int midi = static_cast<int>(
+        std::round(69.0f + 12.0f * std::log2(frequency / a4_))
+    );
+
+    const float target = a4_ * std::pow(2.0f, (midi - 69) / 12.0f);
+    const float cents = 1200.0f * std::log2(frequency / target);
+
+    result.hasPitch = true;
+    result.frequency = frequency;
+    result.confidence = confidence;
+    result.rmsDb = rmsDb;
+    result.midiNote = midi;
+    result.noteName = names[midi % 12];
+    result.octave = midi / 12 - 1;
+    result.targetFrequency = target;
+    result.cents = cents;
+
+    return result;
+}

package/cpp/src/OnsetDetector.cpp

@@ -0,0 +1,39 @@
+#include "OnsetDetector.hpp"
+
+#include <algorithm>
+
+OnsetDetector::OnsetDetector(Config cfg) : cfg_(cfg) {}
+
+bool OnsetDetector::detect(float rmsDb) {
+    // Fast path: disabled → no work at all.
+    if (!enabled_) return false;
+
+    // Decrement cooldown counter
+    if (cooldown_ > 0) {
+        --cooldown_;
+        // Still update envelope during cooldown so we don't miss the next onset
+        envelopeDb_ += cfg_.envelopeAlpha * (rmsDb - envelopeDb_);
+        return false;
+    }
+
+    const float rise = rmsDb - envelopeDb_;
+
+    // Update envelope (exponential follower — tracks slow changes)
+    envelopeDb_ += cfg_.envelopeAlpha * (rmsDb - envelopeDb_);
+
+    if (rise > cfg_.thresholdDb) {
+        cooldown_ = cfg_.cooldownFrames;
+        return true;
+    }
+
+    return false;
+}
+
+void OnsetDetector::setConfig(Config cfg) {
+    cfg_ = cfg;
+}
+
+void OnsetDetector::reset() {
+    envelopeDb_ = -100.0f;
+    cooldown_ = 0;
+}

package/cpp/src/Pipeline.cpp

@@ -0,0 +1,133 @@
+#include "Pipeline.hpp"
+
+#include <algorithm>
+#include <cmath>
+
+static constexpr float kMinLinear = 1e-7f;
+
+Pipeline::Pipeline(int frameSize, float sampleRate, std::unique_ptr<IPitchDetector> detector)
+    : frameSize_(frameSize)
+    , sampleRate_(sampleRate)
+    , hpf_(sampleRate, 70.0f)       // 70 Hz HPF — removes DC and sub-bass rumble
+    , window_(frameSize)
+    , detector_(std::move(detector))
+    , workBuffer_(static_cast<size_t>(frameSize))
+{}
+
+PitchResult Pipeline::process(const float* input, int frameCount) {
+    if (!input || frameCount < frameSize_) return PitchResult{};
+
+    // --- RMS gate ---
+    const float rmsLinear = calculateRmsLinear(input, frameSize_);
+    const float rmsDb     = 20.0f * std::log10(std::max(rmsLinear, kMinLinear));
+
+    if (rmsDb < noiseGateDb_) {
+        PitchResult silent;
+        silent.rmsDb = rmsDb;
+        return silent;
+    }
+
+    // --- Onset detection (no-op when disabled — single branch) ---
+    if (onsetDetector_.detect(rmsDb)) {
+        postProcessor_.reset();
+    }
+
+    // --- Working copy: HPF only.
+    // Hann windowing is reserved for FFT-based detectors (M3 cepstrum/PYIN).
+    // YIN works in the time domain — windowing distorts its difference function.
+    std::copy(input, input + frameSize_, workBuffer_.begin());
+    hpf_.process(workBuffer_.data(), frameSize_);
+
+    // --- Pitch detection ---
+    DetectorResult det = detector_->detect(workBuffer_.data(), frameSize_, sampleRate_);
+
+    // --- SNR-weighted confidence ---
+    const float snrDb     = snr_.update(rmsLinear);
+    const float snrWeight = SnrEstimator::snrToWeight(snrDb);
+    const float weightedConf = det.confidence * snrWeight;
+
+    if (!det.voiced || weightedConf < confidenceThreshold_) {
+        PitchResult nopit;
+        nopit.rmsDb = rmsDb;
+        return nopit;
+    }
+
+    // --- Post-process: median + EMA + hysteresis ---
+    PostProcessor::Result pp = postProcessor_.process(det.frequency, weightedConf);
+
+    if (!pp.isStable || pp.frequency <= 0.0f) {
+        PitchResult nopit;
+        nopit.rmsDb = rmsDb;
+        return nopit;
+    }
+
+    // --- Note mapping ---
+    PitchResult result = noteMapper_.map(pp.frequency, weightedConf, rmsDb);
+    // Override cents with the hysteresis-stabilised value from PostProcessor
+    result.cents = pp.cents;
+
+    // --- String matching (optional, only when a TuningProfile is active) ---
+    if (stringMatcher_.hasTuning()) {
+        auto m = stringMatcher_.match(pp.frequency);
+        if (m) {
+            result.nearestString    = m->name;
+            result.stringDeviation  = m->deviationCents;
+        }
+    }
+
+    return result;
+}
+
+void Pipeline::setA4(float hz) {
+    noteMapper_.setA4(hz);
+}
+
+void Pipeline::setNoiseGateDb(float db) {
+    noiseGateDb_ = db;
+}
+
+void Pipeline::setConfidenceThreshold(float threshold) {
+    confidenceThreshold_ = threshold;
+}
+
+void Pipeline::setFrequencyRange(float minHz, float maxHz) {
+    detector_->setFrequencyRange(minHz, maxHz);
+}
+
+void Pipeline::setInstrument(const std::string& name) {
+    FrequencyRange r = instrumentPreset(name);
+    detector_->setFrequencyRange(r.minHz, r.maxHz);
+}
+
+void Pipeline::setTuning(const std::string& name) {
+    stringMatcher_.setTuning(name.empty() ? nullptr : tuningPreset(name));
+}
+
+void Pipeline::setPostProcessorConfig(PostProcessor::Config cfg) {
+    postProcessor_.setConfig(cfg);
+}
+
+void Pipeline::setHpfCutoff(float hz) {
+    hpf_ = BiquadHpf(sampleRate_, hz);
+}
+
+void Pipeline::setOnsetDetectionEnabled(bool enabled) {
+    onsetDetector_.setEnabled(enabled);
+    if (!enabled) onsetDetector_.reset();
+}
+
+void Pipeline::setOnsetConfig(OnsetDetector::Config cfg) {
+    onsetDetector_.setConfig(cfg);
+}
+
+float Pipeline::calculateRmsDb(const float* input, int n) const {
+    return 20.0f * std::log10(std::max(calculateRmsLinear(input, n), kMinLinear));
+}
+
+float Pipeline::calculateRmsLinear(const float* input, int n) const {
+    float sum = 0.0f;
+    for (int i = 0; i < n; ++i) {
+        sum += input[i] * input[i];
+    }
+    return std::sqrt(sum / static_cast<float>(n));
+}