react-native-tuner-engine 1.0.0

package/cpp/include/BiquadHpf.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+// 2nd-order high-pass filter, Direct Form II Transposed.
+// Coefficients from Audio EQ Cookbook (Bristow-Johnson).
+// State (w1_, w2_) persists across frames for continuity.
+class BiquadHpf {
+public:
+    // cutoffHz: -3 dB frequency; q: 0.707 = Butterworth (maximally flat)
+    BiquadHpf(float sampleRate, float cutoffHz, float q = 0.7071f);
+
+    // Filter frame in-place.
+    void process(float* frame, int n);
+
+    // Reset inter-frame state (call when stream restarts).
+    void reset();
+
+private:
+    float b0_, b1_, b2_;
+    float a1_, a2_;
+    float w1_ = 0.0f;
+    float w2_ = 0.0f;
+};

package/cpp/include/CepstrumPitchDetector.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "IPitchDetector.hpp"
+#include <complex>
+#include <vector>
+
+// Real-cepstrum pitch detector.
+// HPF-filtered frame → Hann window → FFT → log-power spectrum → IFFT → quefrency peak.
+// Particularly robust for signals with strong harmonics where the fundamental is weak.
+class CepstrumPitchDetector : public IPitchDetector {
+public:
+    CepstrumPitchDetector(float sampleRate, int frameSize);
+
+    DetectorResult detect(const float* frame, int n, float sampleRate) override;
+
+    void reset() override {}
+    void setFrequencyRange(float minHz, float maxHz) override;
+    void setThreshold(float threshold) override;
+
+private:
+    float sampleRate_;
+    int   frameSize_;
+
+    float minHz_     = 60.0f;
+    float maxHz_     = 1200.0f;
+    float threshold_ = 0.10f; // minimum peak prominence to be considered voiced
+
+    std::vector<float>               hann_;
+    std::vector<std::complex<float>> fftBuf_;
+    std::vector<float>               logPow_;
+
+    float peakProminence(int tauMin, int tauMax, int peakTau) const;
+};

package/cpp/include/EnsembleSelector.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "IPitchDetector.hpp"
+#include <memory>
+#include <vector>
+
+// Runs every sub-detector on the same frame and selects the best result.
+// Detectors that agree within one semitone reinforce each other (confidence bonus).
+// A lone detector with no agreement receives a confidence penalty.
+class EnsembleSelector : public IPitchDetector {
+public:
+    explicit EnsembleSelector(std::vector<std::unique_ptr<IPitchDetector>> detectors);
+
+    DetectorResult detect(const float* frame, int n, float sampleRate) override;
+
+    void reset() override;
+    void setFrequencyRange(float minHz, float maxHz) override;
+    void setThreshold(float threshold) override;
+
+private:
+    std::vector<std::unique_ptr<IPitchDetector>> detectors_;
+    std::vector<DetectorResult> resultsBuf_;
+
+    static bool withinSemitones(float f1, float f2, float tolerance = 1.0f);
+};

package/cpp/include/Fft.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <cmath>
+#include <complex>
+#include <vector>
+
+namespace tuner {
+
+// In-place radix-2 Cooley-Tukey DFT. n = x.size() must be a power of 2.
+inline void fft(std::vector<std::complex<float>>& x) {
+    const int n = static_cast<int>(x.size());
+
+    for (int i = 1, j = 0; i < n; ++i) {
+        int bit = n >> 1;
+        for (; j & bit; bit >>= 1) j ^= bit;
+        j ^= bit;
+        if (i < j) std::swap(x[i], x[j]);
+    }
+
+    for (int len = 2; len <= n; len <<= 1) {
+        const float angle = -2.0f * 3.14159265358979323846f / static_cast<float>(len);
+        const std::complex<float> wlen(std::cos(angle), std::sin(angle));
+        for (int i = 0; i < n; i += len) {
+            std::complex<float> w(1.0f, 0.0f);
+            for (int j = 0; j < len / 2; ++j) {
+                const std::complex<float> u = x[i + j];
+                const std::complex<float> v = x[i + j + len / 2] * w;
+                x[i + j]           = u + v;
+                x[i + j + len / 2] = u - v;
+                w *= wlen;
+            }
+        }
+    }
+}
+
+// In-place inverse DFT.
+inline void ifft(std::vector<std::complex<float>>& x) {
+    for (auto& c : x) c = std::conj(c);
+    fft(x);
+    const float inv = 1.0f / static_cast<float>(x.size());
+    for (auto& c : x) c = std::conj(c) * inv;
+}
+
+} // namespace tuner

package/cpp/include/IPitchDetector.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+struct DetectorResult {
+    bool voiced = false;
+    float frequency = 0.0f;
+    float confidence = 0.0f;
+};
+
+class IPitchDetector {
+public:
+    virtual ~IPitchDetector() = default;
+
+    // Detect pitch from a pre-filtered, windowed frame of length n at the given sample rate.
+    virtual DetectorResult detect(const float* frame, int n, float sampleRate) = 0;
+
+    // Reset any inter-frame state (Viterbi, smoothing, etc.).
+    virtual void reset() {}
+
+    virtual void setFrequencyRange(float minHz, float maxHz) = 0;
+    virtual void setThreshold(float threshold) = 0;
+};

package/cpp/include/InstrumentPresets.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <string>
+
+struct FrequencyRange {
+    float minHz;
+    float maxHz;
+};
+
+// Returns the recommended pitch-detection frequency range for a given instrument name.
+// Falls back to chromatic (60–1200 Hz) for unknown names.
+inline FrequencyRange instrumentPreset(const std::string& name) {
+    if (name == "guitar")    return { 75.0f,  1320.0f };
+    if (name == "bass")      return { 38.0f,   330.0f };
+    if (name == "ukulele")   return { 250.0f,  880.0f };
+    if (name == "violin")    return { 190.0f, 3200.0f };
+    if (name == "cello")     return {  60.0f, 1050.0f };
+    if (name == "viola")     return { 125.0f, 1320.0f };
+    if (name == "mandolin")  return { 190.0f, 2100.0f };
+    if (name == "banjo")     return { 190.0f, 1320.0f };
+    return { 60.0f, 1200.0f }; // chromatic default
+}
+
+// Returns the recommended DSP frame size for a given instrument.
+// Low-pitched instruments (bass, cello) need larger frames to resolve
+// their fundamental frequencies via autocorrelation (YIN lag = frameSize/2).
+//   frame=2048 @ 48 kHz → min detectable ≈ 46.9 Hz
+//   frame=4096 @ 48 kHz → min detectable ≈ 23.4 Hz
+inline int instrumentRecommendedFrameSize(const std::string& name) {
+    if (name == "bass")  return 4096;
+    if (name == "cello") return 4096;
+    return 2048; // guitar, violin, viola, ukulele, mandolin, banjo, chromatic
+}

package/cpp/include/NoteMapper.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "PitchResult.hpp"
+
+class NoteMapper {
+public:
+    explicit NoteMapper(float a4 = 440.0f);
+
+    PitchResult map(float frequency, float confidence, float rmsDb) const;
+
+    void setA4(float value);
+
+private:
+    float a4_;
+};

package/cpp/include/OnsetDetector.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+// Lightweight onset detector based on energy rise.
+//
+// Computes the difference between the current frame's RMS and a slow-decay
+// envelope.  When the rise exceeds a threshold, an onset is signalled.
+//
+// Cost: one subtraction + one comparison per frame when enabled.
+// When disabled (`enabled_ == false`), detect() returns false immediately — zero work.
+class OnsetDetector {
+public:
+    struct Config {
+        float thresholdDb   = 6.0f;   // minimum dB rise to trigger an onset
+        float envelopeAlpha = 0.15f;  // envelope decay speed (lower = slower)
+        int   cooldownFrames = 8;     // minimum frames between consecutive onsets
+    };
+
+    OnsetDetector() = default;
+    explicit OnsetDetector(Config cfg);
+
+    // Returns true if an onset is detected for the current frame.
+    // rmsDb: current frame's RMS in dBFS (already computed by Pipeline — free).
+    bool detect(float rmsDb);
+
+    void setEnabled(bool enabled) { enabled_ = enabled; }
+    bool isEnabled() const { return enabled_; }
+
+    void setConfig(Config cfg);
+    void reset();
+
+private:
+    Config cfg_{};
+    bool   enabled_ = false;  // disabled by default — zero cost
+
+    float  envelopeDb_ = -100.0f;
+    int    cooldown_   = 0;
+};

package/cpp/include/Pipeline.hpp

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "BiquadHpf.hpp"
+#include "IPitchDetector.hpp"
+#include "InstrumentPresets.hpp"
+#include "NoteMapper.hpp"
+#include "OnsetDetector.hpp"
+#include "PitchResult.hpp"
+#include "PostProcessor.hpp"
+#include "SnrEstimator.hpp"
+#include "StringMatcher.hpp"
+#include "Window.hpp"
+
+#include <memory>
+#include <vector>
+
+// Ordered DSP chain: HPF → Hann window → IPitchDetector → SNR weighting → PostProcessor → NoteMapper → StringMatcher.
+class Pipeline {
+public:
+    Pipeline(int frameSize, float sampleRate, std::unique_ptr<IPitchDetector> detector);
+
+    PitchResult process(const float* input, int frameCount);
+
+    void setA4(float hz);
+    void setNoiseGateDb(float db);
+    void setConfidenceThreshold(float threshold);
+    void setFrequencyRange(float minHz, float maxHz);
+    void setInstrument(const std::string& name);
+    void setTuning(const std::string& name);   // e.g. "guitar_standard", "" to disable
+    void setPostProcessorConfig(PostProcessor::Config cfg);
+    void setHpfCutoff(float hz);
+    void setOnsetDetectionEnabled(bool enabled);
+    void setOnsetConfig(OnsetDetector::Config cfg);
+
+private:
+    int frameSize_;
+    float sampleRate_;
+
+    float noiseGateDb_           = -55.0f;
+    float confidenceThreshold_   =  0.60f; // lower than raw YIN default; SNR will tighten it
+
+    BiquadHpf hpf_;
+    HannWindow window_;
+    std::unique_ptr<IPitchDetector> detector_;
+    SnrEstimator snr_;
+    OnsetDetector onsetDetector_;
+    PostProcessor postProcessor_;
+    NoteMapper noteMapper_;
+    StringMatcher stringMatcher_;
+
+    std::vector<float> workBuffer_; // HPF + windowing happen here (copy of input)
+
+    float calculateRmsDb(const float* input, int n) const;
+    float calculateRmsLinear(const float* input, int n) const;
+};

package/cpp/include/PitchResult.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <string>
+
+struct PitchResult
+{
+    bool hasPitch = false;
+
+    float frequency = 0.0f;
+    float confidence = 0.0f;
+    float rmsDb = -120.0f;
+
+    int midiNote = 0;
+    std::string noteName;
+    int octave = 0;
+
+    float targetFrequency = 0.0f;
+    float cents = 0.0f;
+
+    // Set when a TuningProfile is active (via Pipeline::setTuning).
+    // Empty string means no tuning is configured.
+    std::string nearestString;       // e.g. "E2", "A2"
+    float       stringDeviation = 0.0f; // cents from that string's target, signed
+};

package/cpp/include/PostProcessor.hpp

@@ -0,0 +1,51 @@
+#pragma once
+
+// Stabilises pitch output via:
+//   1. Median-5 filter on frequency (kills transient spikes)
+//   2. EMA smoothing on the median frequency
+//   3. Note-change hysteresis (debounce rapid note switches)
+class PostProcessor {
+public:
+    struct Config {
+        float emaAlpha         = 0.35f; // smoothing speed (higher = faster response)
+        int   hysteresisFrames = 3;     // consecutive frames needed to confirm a new note
+    };
+
+    PostProcessor();
+    explicit PostProcessor(Config cfg);
+
+    struct Result {
+        float frequency  = 0.0f;
+        int   midiNote   = -1;   // -1 = no stable note yet
+        float cents      = 0.0f; // cents deviation from locked note
+        bool  isStable   = false;
+    };
+
+    // Call once per detected frame. frequency = 0 means "no pitch".
+    Result process(float frequency, float confidence);
+
+    void reset();
+    void setConfig(Config cfg);
+
+private:
+    Config cfg_;
+
+    // Median-5 circular buffer
+    static constexpr int kMedianLen = 5;
+    float medianBuf_[kMedianLen] = {};
+    int   medianIdx_ = 0;
+    int   medianFill_ = 0;
+
+    float median5() const;
+
+    // EMA state
+    float smoothedFreq_ = 0.0f;
+
+    // Hysteresis state
+    int  lockedMidi_     = -1;
+    int  candidateMidi_  = -1;
+    int  candidateCount_ = 0;
+
+    static int freqToMidi(float hz);
+    static float freqToCentsFromMidi(float hz, int midi);
+};

package/cpp/include/PyinPitchDetector.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "IPitchDetector.hpp"
+#include <vector>
+
+// Probabilistic YIN (PYIN) — unlike plain YIN, it collects every CMND local minimum
+// below threshold and picks the most probable one rather than the first.
+// This eliminates the octave errors that occur when the first minimum corresponds
+// to a harmonic period rather than the fundamental.
+class PyinPitchDetector : public IPitchDetector {
+public:
+    PyinPitchDetector(float sampleRate, int frameSize);
+
+    DetectorResult detect(const float* frame, int n, float sampleRate) override;
+
+    void reset() override {}
+    void setFrequencyRange(float minHz, float maxHz) override;
+    void setThreshold(float threshold) override;
+
+private:
+    float sampleRate_;
+    int   frameSize_;
+
+    float minHz_     = 60.0f;
+    float maxHz_     = 1200.0f;
+    float threshold_ = 0.25f; // wider than YIN — captures all plausible candidates
+
+    std::vector<float> diff_;
+    std::vector<float> cmnd_;
+
+    struct Candidate { int tau; float prob; };
+    std::vector<Candidate> candidates_; // pre-allocated, reused each frame
+
+    float parabolicInterpolation(int tau) const;
+};

package/cpp/include/RingBuffer.hpp

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <atomic>
+#include <algorithm>
+
+// Lock-free single-producer single-consumer ring buffer for float samples.
+// Capacity must be a power of 2. push() is safe from the producer/audio thread;
+// pop() and available() are safe from the consumer/worker thread.
+// Uses monotonically-growing unsigned indices for correct wrap-around arithmetic.
+template<unsigned Capacity>
+class FloatRingBuffer {
+    static_assert((Capacity & (Capacity - 1)) == 0, "Capacity must be power of 2");
+    static constexpr unsigned kMask = Capacity - 1;
+
+public:
+    FloatRingBuffer() : writeIdx_(0u), readIdx_(0u) {}
+
+    // Push up to n samples from src. Returns actual count written (may be < n if full).
+    // Safe to call from the audio/producer thread.
+    int push(const float* src, int n) {
+        const unsigned w = writeIdx_.load(std::memory_order_relaxed);
+        const unsigned r = readIdx_.load(std::memory_order_acquire);
+        const unsigned space = Capacity - (w - r);
+        const unsigned count = static_cast<unsigned>(std::min<int>(n, static_cast<int>(space)));
+        if (count == 0) return 0;
+
+        const unsigned startSlot = w & kMask;
+        const unsigned first = std::min(count, Capacity - startSlot);
+        const unsigned second = count - first;
+
+        std::copy(src, src + first, data_ + startSlot);
+        if (second > 0) {
+            std::copy(src + first, src + first + second, data_);
+        }
+
+        writeIdx_.store(w + count, std::memory_order_release);
+        return static_cast<int>(count);
+    }
+
+    // Pop exactly n samples into dst. Returns n on success, 0 if not enough data.
+    // Safe to call from the consumer/worker thread.
+    int pop(float* dst, int n) {
+        const unsigned r = readIdx_.load(std::memory_order_relaxed);
+        const unsigned w = writeIdx_.load(std::memory_order_acquire);
+        const unsigned avail = w - r;
+        if (avail < static_cast<unsigned>(n)) return 0;
+
+        const unsigned startSlot = r & kMask;
+        const unsigned first = std::min<unsigned>(static_cast<unsigned>(n), Capacity - startSlot);
+        const unsigned second = static_cast<unsigned>(n) - first;
+
+        std::copy(data_ + startSlot, data_ + startSlot + first, dst);
+        if (second > 0) {
+            std::copy(data_, data_ + second, dst + first);
+        }
+
+        readIdx_.store(r + static_cast<unsigned>(n), std::memory_order_release);
+        return n;
+    }
+
+    // Samples currently available to read. Safe from any thread.
+    int available() const {
+        const unsigned w = writeIdx_.load(std::memory_order_acquire);
+        const unsigned r = readIdx_.load(std::memory_order_relaxed);
+        return static_cast<int>(w - r);
+    }
+
+private:
+    float data_[Capacity];
+    std::atomic<unsigned> writeIdx_;
+    std::atomic<unsigned> readIdx_;
+};

package/cpp/include/SnrEstimator.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+// Estimates signal-to-noise ratio by tracking a slow noise-floor EMA.
+// The floor decays toward the current RMS level; it only rises when the
+// signal drops below it (i.e. it tracks the quiet passages).
+class SnrEstimator {
+public:
+    explicit SnrEstimator(float floorInitDb = -70.0f);
+
+    // Update with current linear RMS and return SNR in dB.
+    float update(float rmsLinear);
+
+    // Map SNR to a confidence weight in [0, 1].
+    static float snrToWeight(float snrDb);
+
+    void reset();
+
+private:
+    float noiseFloorLinear_;
+    static constexpr float kAttackAlpha  = 0.0100f; // how fast floor follows signal downward
+};

package/cpp/include/StringMatcher.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "TuningPresets.hpp"
+
+#include <optional>
+
+struct StringMatch {
+    const char* name;           // "E2", "A2", "D3" ...
+    int         stringNumber;   // 1-based (thickest = 1)
+    float       targetHz;       // exact equal-temperament frequency
+    float       deviationCents; // signed: negative = flat, positive = sharp
+};
+
+// Maps a detected frequency to the nearest string in the active TuningProfile.
+class StringMatcher {
+public:
+    void setTuning(const TuningProfile* profile);
+    bool hasTuning() const;
+
+    // Returns the nearest string within maxDeviationCents (default 100 ¢ = 1 semitone).
+    // Returns std::nullopt if no tuning is set or no string is close enough.
+    std::optional<StringMatch> match(float frequency,
+                                     float maxDeviationCents = 100.0f) const;
+
+private:
+    const TuningProfile* profile_ = nullptr;
+};

package/cpp/include/TunerEngine.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "Pipeline.hpp"
+#include "OnsetDetector.hpp"
+#include "PostProcessor.hpp"
+#include "PitchResult.hpp"
+
+#include <memory>
+#include <string>
+
+// Facade that owns a Pipeline. The external API is identical to the pre-M2 TunerEngine
+// so AudioFrameDispatcher and all existing tests require no changes.
+class TunerEngine {
+public:
+    TunerEngine(float sampleRate, int frameSize);
+
+    PitchResult process(const float* input, int frameCount);
+
+    void setA4(float a4);
+    void setNoiseGateDb(float db);
+    void setConfidenceThreshold(float value);
+    void setFrequencyRange(float minFrequency, float maxFrequency);
+    void setInstrument(const std::string& name);
+    void setTuning(const std::string& name);
+    void setPostProcessorConfig(PostProcessor::Config cfg);
+    void setHpfCutoff(float hz);
+    void setOnsetDetectionEnabled(bool enabled);
+    void setOnsetConfig(OnsetDetector::Config cfg);
+
+private:
+    std::unique_ptr<Pipeline> pipeline_;
+};

package/cpp/include/TuningPresets.hpp

@@ -0,0 +1,103 @@
+#pragma once
+
+#include <string>
+
+struct StringTarget {
+    const char* name;   // e.g. "E2", "A2", "D3"
+    int   stringNumber; // 1-based, thickest/lowest string = 1
+    float frequency;    // Hz, equal temperament A4=440
+};
+
+struct TuningProfile {
+    const char*  name;
+    StringTarget strings[8]; // max 8 strings
+    int          stringCount;
+};
+
+// Standard tunings — frequencies in Hz (equal temperament, A4=440)
+namespace tuning_presets {
+
+inline constexpr TuningProfile guitar_standard = {
+    "guitar_standard",
+    {{"E2",1,82.41f},{"A2",2,110.00f},{"D3",3,146.83f},
+     {"G3",4,196.00f},{"B3",5,246.94f},{"E4",6,329.63f}},
+    6
+};
+
+inline constexpr TuningProfile guitar_drop_d = {
+    "guitar_drop_d",
+    {{"D2",1,73.42f},{"A2",2,110.00f},{"D3",3,146.83f},
+     {"G3",4,196.00f},{"B3",5,246.94f},{"E4",6,329.63f}},
+    6
+};
+
+inline constexpr TuningProfile guitar_open_g = {
+    "guitar_open_g",
+    {{"D2",1,73.42f},{"G2",2,98.00f},{"D3",3,146.83f},
+     {"G3",4,196.00f},{"B3",5,246.94f},{"D4",6,293.66f}},
+    6
+};
+
+inline constexpr TuningProfile bass_standard = {
+    "bass_standard",
+    {{"E1",1,41.20f},{"A1",2,55.00f},{"D2",3,73.42f},{"G2",4,98.00f}},
+    4
+};
+
+inline constexpr TuningProfile bass_drop_d = {
+    "bass_drop_d",
+    {{"D1",1,36.71f},{"A1",2,55.00f},{"D2",3,73.42f},{"G2",4,98.00f}},
+    4
+};
+
+inline constexpr TuningProfile violin_standard = {
+    "violin_standard",
+    {{"G3",1,196.00f},{"D4",2,293.66f},{"A4",3,440.00f},{"E5",4,659.26f}},
+    4
+};
+
+inline constexpr TuningProfile viola_standard = {
+    "viola_standard",
+    {{"C3",1,130.81f},{"G3",2,196.00f},{"D4",3,293.66f},{"A4",4,440.00f}},
+    4
+};
+
+inline constexpr TuningProfile cello_standard = {
+    "cello_standard",
+    {{"C2",1,65.41f},{"G2",2,98.00f},{"D3",3,146.83f},{"A3",4,220.00f}},
+    4
+};
+
+inline constexpr TuningProfile ukulele_standard = {
+    "ukulele_standard",
+    {{"G4",1,392.00f},{"C4",2,261.63f},{"E4",3,329.63f},{"A4",4,440.00f}},
+    4
+};
+
+} // namespace tuning_presets
+
+// Returns a pointer to a built-in TuningProfile by name, or nullptr for unknown names.
+inline const TuningProfile* tuningPreset(const std::string& name) {
+    if (name == "guitar_standard") return &tuning_presets::guitar_standard;
+    if (name == "guitar_drop_d")   return &tuning_presets::guitar_drop_d;
+    if (name == "guitar_open_g")   return &tuning_presets::guitar_open_g;
+    if (name == "bass_standard")   return &tuning_presets::bass_standard;
+    if (name == "bass_drop_d")     return &tuning_presets::bass_drop_d;
+    if (name == "violin_standard") return &tuning_presets::violin_standard;
+    if (name == "viola_standard")  return &tuning_presets::viola_standard;
+    if (name == "cello_standard")  return &tuning_presets::cello_standard;
+    if (name == "ukulele_standard")return &tuning_presets::ukulele_standard;
+    return nullptr;
+}
+
+// Returns the default tuning name for a given instrument name (mirrors InstrumentPresets).
+// Returns "" if the instrument has no default tuning (chromatic, mandolin, banjo).
+inline std::string defaultTuningForInstrument(const std::string& instrument) {
+    if (instrument == "guitar")  return "guitar_standard";
+    if (instrument == "bass")    return "bass_standard";
+    if (instrument == "violin")  return "violin_standard";
+    if (instrument == "viola")   return "viola_standard";
+    if (instrument == "cello")   return "cello_standard";
+    if (instrument == "ukulele") return "ukulele_standard";
+    return "";
+}

package/cpp/include/Window.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <vector>
+
+// Precomputed Hann window. apply() multiplies a frame in-place.
+class HannWindow {
+public:
+    explicit HannWindow(int size);
+    void apply(float* frame, int n) const;
+
+private:
+    std::vector<float> coeffs_;
+};