react-native-tuner-engine 1.0.0

package/cpp/src/PostProcessor.cpp

@@ -0,0 +1,111 @@
+#include "PostProcessor.hpp"
+
+#include <algorithm>
+#include <cmath>
+
+static constexpr float kA4 = 440.0f;
+
+PostProcessor::PostProcessor() : cfg_{} {}
+PostProcessor::PostProcessor(Config cfg) : cfg_(cfg) {
+    cfg_.emaAlpha = std::clamp(cfg_.emaAlpha, 0.01f, 1.0f);
+    cfg_.hysteresisFrames = std::max(cfg_.hysteresisFrames, 1);
+}
+
+void PostProcessor::reset() {
+    std::fill(medianBuf_, medianBuf_ + kMedianLen, 0.0f);
+    medianIdx_      = 0;
+    medianFill_     = 0;
+    smoothedFreq_   = 0.0f;
+    lockedMidi_     = -1;
+    candidateMidi_  = -1;
+    candidateCount_ = 0;
+}
+
+void PostProcessor::setConfig(Config cfg) {
+    cfg.emaAlpha = std::clamp(cfg.emaAlpha, 0.01f, 1.0f);
+    cfg.hysteresisFrames = std::max(cfg.hysteresisFrames, 1);
+    cfg_ = cfg;
+}
+
+float PostProcessor::median5() const {
+    // Optimal median-of-5 via sorting network (6 comparisons, no allocation)
+    float a = medianBuf_[0], b = medianBuf_[1], c = medianBuf_[2],
+          d = medianBuf_[3], e = medianBuf_[4];
+    // Sort pairs
+    if (a > b) std::swap(a, b);
+    if (c > d) std::swap(c, d);
+    // Eliminate the lowest of the two pairs
+    if (a > c) { std::swap(a, c); std::swap(b, d); }
+    // Now a is the global minimum, discard it. Median is among {b, c, d, e}
+    // Find median of {b, c, d, e} by eliminating max and min
+    if (b > e) std::swap(b, e);
+    // Median is middle of {b, c, d}
+    if (b > c) std::swap(b, c);
+    if (c > d) std::swap(c, d);
+    return std::min(c, e);
+}
+
+int PostProcessor::freqToMidi(float hz) {
+    if (hz <= 0.0f) return -1;
+    return static_cast<int>(std::round(69.0f + 12.0f * std::log2(hz / kA4)));
+}
+
+float PostProcessor::freqToCentsFromMidi(float hz, int midi) {
+    if (hz <= 0.0f || midi < 0) return 0.0f;
+    const float targetHz = kA4 * std::pow(2.0f, (midi - 69) / 12.0f);
+    return 1200.0f * std::log2(hz / targetHz);
+}
+
+PostProcessor::Result PostProcessor::process(float frequency, float confidence) {
+    // 1. Feed median buffer (treat 0 as "silent frame")
+    medianBuf_[medianIdx_] = frequency;
+    medianIdx_ = (medianIdx_ + 1) % kMedianLen;
+    if (medianFill_ < kMedianLen) ++medianFill_;
+
+    const float med = (medianFill_ == kMedianLen) ? median5() : frequency;
+
+    if (med <= 0.0f || confidence <= 0.0f) {
+        return Result{ 0.0f, lockedMidi_, 0.0f, false };
+    }
+
+    // 3. Hysteresis — use the raw median for note detection (not the smoothed EMA).
+    // This prevents the slow EMA from drifting through enharmonic neighbours during transitions.
+    const int newMidi = freqToMidi(med);
+
+    if (newMidi == lockedMidi_) {
+        candidateMidi_  = -1;
+        candidateCount_ = 0;
+    } else {
+        if (newMidi == candidateMidi_) {
+            ++candidateCount_;
+        } else {
+            candidateMidi_  = newMidi;
+            candidateCount_ = 1;
+        }
+
+        if (candidateCount_ >= cfg_.hysteresisFrames) {
+            lockedMidi_    = candidateMidi_;
+            smoothedFreq_  = med; // snap EMA to new note to avoid lag artefacts
+            candidateMidi_  = -1;
+            candidateCount_ = 0;
+        }
+    }
+
+    if (lockedMidi_ < 0) {
+        lockedMidi_ = newMidi;
+    }
+
+    // 4. EMA — only for smooth cents/frequency display within the locked note
+    smoothedFreq_ = (smoothedFreq_ <= 0.0f)
+        ? med
+        : cfg_.emaAlpha * med + (1.0f - cfg_.emaAlpha) * smoothedFreq_;
+
+    const float cents = freqToCentsFromMidi(smoothedFreq_, lockedMidi_);
+
+    return Result{
+        smoothedFreq_,
+        lockedMidi_,
+        cents,
+        true
+    };
+}

package/cpp/src/PyinPitchDetector.cpp

@@ -0,0 +1,134 @@
+#include "PyinPitchDetector.hpp"
+
+#include <algorithm>
+#include <cmath>
+
+PyinPitchDetector::PyinPitchDetector(float sampleRate, int frameSize)
+    : sampleRate_(sampleRate)
+    , frameSize_(frameSize)
+{
+    diff_.resize(static_cast<size_t>(frameSize_ / 2));
+    cmnd_.resize(static_cast<size_t>(frameSize_ / 2));
+    candidates_.reserve(32); // typical number of CMND minima
+}
+
+void PyinPitchDetector::setFrequencyRange(float minHz, float maxHz) {
+    minHz_ = minHz;
+    maxHz_ = maxHz;
+}
+
+void PyinPitchDetector::setThreshold(float threshold) {
+    threshold_ = threshold;
+}
+
+DetectorResult PyinPitchDetector::detect(const float* frame, int n, float sampleRate) {
+    const float sr = sampleRate > 0.0f ? sampleRate : sampleRate_;
+
+    if (!frame || n < frameSize_) return DetectorResult{};
+
+    const int tauMin = std::max(2, static_cast<int>(sr / maxHz_));
+    const int tauMax = std::min(
+        frameSize_ / 2 - 1,
+        static_cast<int>(sr / minHz_)
+    );
+
+    if (tauMin >= tauMax) return DetectorResult{};
+
+    // Squared difference function (YIN step 2)
+    std::fill(diff_.begin(), diff_.end(), 0.0f);
+    for (int tau = 1; tau <= tauMax; ++tau) {
+        float sum = 0.0f;
+        for (int i = 0; i < frameSize_ - tau; ++i) {
+            const float d = frame[i] - frame[i + tau];
+            sum += d * d;
+        }
+        diff_[tau] = sum;
+    }
+
+    // Cumulative mean normalised difference (CMND, YIN step 3)
+    cmnd_[0] = 1.0f;
+    float runningSum = 0.0f;
+    for (int tau = 1; tau <= tauMax; ++tau) {
+        runningSum += diff_[tau];
+        cmnd_[tau] = (runningSum <= 0.0f)
+                     ? 1.0f
+                     : diff_[tau] * static_cast<float>(tau) / runningSum;
+    }
+
+    // Collect all local minima of CMND below threshold — this is the PYIN divergence point.
+    // YIN stops at the first; PYIN considers all.
+    candidates_.clear();
+
+    auto tryAdd = [&](int tau) {
+        if (tau < tauMin || tau > tauMax) return;
+        if (cmnd_[tau] < threshold_) {
+            candidates_.push_back({tau, 1.0f - cmnd_[tau] / threshold_});
+        }
+    };
+
+    // Interior local minima
+    for (int tau = tauMin + 1; tau < tauMax; ++tau) {
+        if (cmnd_[tau] < cmnd_[tau - 1] && cmnd_[tau] < cmnd_[tau + 1]) {
+            tryAdd(tau);
+        }
+    }
+    // Boundary checks
+    if (cmnd_[tauMin] < cmnd_[tauMin + 1]) tryAdd(tauMin);
+    if (cmnd_[tauMax] < cmnd_[tauMax - 1]) tryAdd(tauMax);
+
+    if (candidates_.empty()) return DetectorResult{};
+
+    // The CMND formula makes later (longer-period) minima numerically smaller than
+    // earlier ones at sub-multiples of the same fundamental period. Without pruning,
+    // a pure sine would always produce candidates at tau0, 2*tau0, 3*tau0 … with the
+    // highest probability at the LONGEST alias — the wrong (sub-octave) answer.
+    //
+    // Prune: for any candidate whose tau is within 2% of an integer multiple (≥2×) of
+    // a shorter-period candidate, zero its probability. Candidates are already in
+    // ascending tau order, so a single forward pass suffices.
+    for (int i = 0; i < static_cast<int>(candidates_.size()); ++i) {
+        if (candidates_[i].prob == 0.0f) continue;
+        for (int j = i + 1; j < static_cast<int>(candidates_.size()); ++j) {
+            const float ratio   = static_cast<float>(candidates_[j].tau)
+                                  / static_cast<float>(candidates_[i].tau);
+            const float nearest = std::round(ratio);
+            if (nearest >= 2.0f && std::fabs(ratio - nearest) / nearest < 0.02f) {
+                candidates_[j].prob = 0.0f;
+            }
+        }
+    }
+
+    // Sum surviving probabilities for voiced confidence
+    float totalProb = 0.0f;
+    for (const auto& c : candidates_) totalProb += c.prob;
+
+    // Pick the candidate with the highest (surviving) probability.
+    // Strict '>' keeps the first (lowest-tau, highest-frequency) on exact ties.
+    const Candidate* winner = nullptr;
+    for (const auto& c : candidates_) {
+        if (!winner || c.prob > winner->prob) winner = &c;
+    }
+    if (!winner || winner->prob == 0.0f) return DetectorResult{};
+
+    const float betterTau = parabolicInterpolation(winner->tau);
+    if (betterTau <= 0.0f) return DetectorResult{};
+
+    // Confidence: voiced probability × how much the winner dominates
+    const float voicedProb  = std::min(1.0f, totalProb);
+    const float winnerShare = (totalProb > 0.0f) ? winner->prob / totalProb : 0.0f;
+    const float confidence  = voicedProb * (0.5f + 0.5f * winnerShare);
+
+    return DetectorResult{true, sr / betterTau, confidence};
+}
+
+float PyinPitchDetector::parabolicInterpolation(int tau) const {
+    if (tau <= 0 || tau >= static_cast<int>(cmnd_.size()) - 1) {
+        return static_cast<float>(tau);
+    }
+    const float L = cmnd_[tau - 1];
+    const float C = cmnd_[tau];
+    const float R = cmnd_[tau + 1];
+    const float d = L - 2.0f * C + R;
+    if (std::fabs(d) < 1e-6f) return static_cast<float>(tau);
+    return tau + 0.5f * (L - R) / d;
+}

package/cpp/src/SnrEstimator.cpp

@@ -0,0 +1,33 @@
+#include "SnrEstimator.hpp"
+
+#include <algorithm>
+#include <cmath>
+
+static constexpr float kMinLinear = 1e-7f; // -140 dBFS floor
+
+SnrEstimator::SnrEstimator(float floorInitDb)
+    : noiseFloorLinear_(std::pow(10.0f, floorInitDb / 20.0f)) {}
+
+float SnrEstimator::update(float rmsLinear) {
+    rmsLinear = std::max(rmsLinear, kMinLinear);
+
+    if (rmsLinear < noiseFloorLinear_) {
+        // Signal dropped below floor — pull floor down quickly to track silence
+        noiseFloorLinear_ = kAttackAlpha * rmsLinear + (1.0f - kAttackAlpha) * noiseFloorLinear_;
+    }
+    // Floor never rises during active signal — prevents SNR from collapsing on sustained notes
+
+    noiseFloorLinear_ = std::max(noiseFloorLinear_, kMinLinear);
+    return 20.0f * std::log10(rmsLinear / noiseFloorLinear_);
+}
+
+float SnrEstimator::snrToWeight(float snrDb) {
+    // Sigmoid-like mapping: 0 dB SNR → ~0.0 weight, 20 dB → ~1.0 weight
+    if (snrDb <= 0.0f)  return 0.0f;
+    if (snrDb >= 30.0f) return 1.0f;
+    return snrDb / 30.0f;
+}
+
+void SnrEstimator::reset() {
+    noiseFloorLinear_ = std::pow(10.0f, -70.0f / 20.0f);
+}

package/cpp/src/StringMatcher.cpp

@@ -0,0 +1,37 @@
+#include "StringMatcher.hpp"
+
+#include <cmath>
+
+void StringMatcher::setTuning(const TuningProfile* profile) {
+    profile_ = profile;
+}
+
+bool StringMatcher::hasTuning() const {
+    return profile_ != nullptr && profile_->stringCount > 0;
+}
+
+std::optional<StringMatch> StringMatcher::match(float frequency,
+                                                  float maxDeviationCents) const {
+    if (!hasTuning() || frequency <= 0.0f) return std::nullopt;
+
+    const StringMatch* best = nullptr;
+    float bestAbsCents = maxDeviationCents + 1.0f; // sentinel > threshold
+    StringMatch bestMatch{};
+
+    for (int i = 0; i < profile_->stringCount; ++i) {
+        const StringTarget& s = profile_->strings[i];
+        if (s.frequency <= 0.0f) continue;
+
+        const float cents = 1200.0f * std::log2(frequency / s.frequency);
+        const float absCents = std::fabs(cents);
+
+        if (absCents < bestAbsCents) {
+            bestAbsCents  = absCents;
+            bestMatch     = {s.name, s.stringNumber, s.frequency, cents};
+            best          = &bestMatch;
+        }
+    }
+
+    if (!best || bestAbsCents > maxDeviationCents) return std::nullopt;
+    return bestMatch;
+}

package/cpp/src/TunerEngine.cpp

@@ -0,0 +1,67 @@
+#include "TunerEngine.hpp"
+#include "CepstrumPitchDetector.hpp"
+#include "EnsembleSelector.hpp"
+#include "PyinPitchDetector.hpp"
+#include "TuningPresets.hpp"
+#include "YinPitchDetector.hpp"
+
+#include <memory>
+#include <vector>
+
+TunerEngine::TunerEngine(float sampleRate, int frameSize) {
+    std::vector<std::unique_ptr<IPitchDetector>> detectors;
+    detectors.push_back(std::make_unique<YinPitchDetector>(sampleRate, frameSize));
+    detectors.push_back(std::make_unique<PyinPitchDetector>(sampleRate, frameSize));
+    detectors.push_back(std::make_unique<CepstrumPitchDetector>(sampleRate, frameSize));
+
+    auto ensemble = std::make_unique<EnsembleSelector>(std::move(detectors));
+    pipeline_ = std::make_unique<Pipeline>(frameSize, sampleRate, std::move(ensemble));
+}
+
+PitchResult TunerEngine::process(const float* input, int frameCount) {
+    return pipeline_->process(input, frameCount);
+}
+
+void TunerEngine::setA4(float a4) {
+    pipeline_->setA4(a4);
+}
+
+void TunerEngine::setNoiseGateDb(float db) {
+    pipeline_->setNoiseGateDb(db);
+}
+
+void TunerEngine::setConfidenceThreshold(float value) {
+    pipeline_->setConfidenceThreshold(value);
+}
+
+void TunerEngine::setFrequencyRange(float minFrequency, float maxFrequency) {
+    pipeline_->setFrequencyRange(minFrequency, maxFrequency);
+}
+
+void TunerEngine::setInstrument(const std::string& name) {
+    pipeline_->setInstrument(name);
+    // Auto-apply the default tuning for this instrument (e.g. "guitar" → "guitar_standard").
+    // Can be overridden afterwards with an explicit setTuning() call.
+    const std::string defaultTuning = defaultTuningForInstrument(name);
+    pipeline_->setTuning(defaultTuning);
+}
+
+void TunerEngine::setTuning(const std::string& name) {
+    pipeline_->setTuning(name);
+}
+
+void TunerEngine::setPostProcessorConfig(PostProcessor::Config cfg) {
+    pipeline_->setPostProcessorConfig(cfg);
+}
+
+void TunerEngine::setHpfCutoff(float hz) {
+    pipeline_->setHpfCutoff(hz);
+}
+
+void TunerEngine::setOnsetDetectionEnabled(bool enabled) {
+    pipeline_->setOnsetDetectionEnabled(enabled);
+}
+
+void TunerEngine::setOnsetConfig(OnsetDetector::Config cfg) {
+    pipeline_->setOnsetConfig(cfg);
+}

package/cpp/src/Window.cpp

@@ -0,0 +1,21 @@
+#include "Window.hpp"
+
+#include <algorithm>
+#include <cmath>
+
+static constexpr float kPi = 3.14159265358979323846f;
+
+HannWindow::HannWindow(int size) : coeffs_(static_cast<size_t>(size)) {
+    for (int i = 0; i < size; ++i) {
+        coeffs_[static_cast<size_t>(i)] =
+            0.5f * (1.0f - std::cos(2.0f * kPi * i / (size - 1)));
+    }
+}
+
+void HannWindow::apply(float* frame, int n) const {
+    if (!frame || n <= 0) return;
+    const int len = std::min(n, static_cast<int>(coeffs_.size()));
+    for (int i = 0; i < len; ++i) {
+        frame[i] *= coeffs_[static_cast<size_t>(i)];
+    }
+}

package/cpp/src/YinPitchDetector.cpp

@@ -0,0 +1,118 @@
+#include "YinPitchDetector.hpp"
+
+#include <algorithm>
+#include <cmath>
+
+YinPitchDetector::YinPitchDetector(float sampleRate, int frameSize)
+    : sampleRate_(sampleRate), frameSize_(frameSize) {
+    difference_.resize(frameSize_ / 2);
+    cmnd_.resize(frameSize_ / 2);
+}
+
+void YinPitchDetector::setFrequencyRange(float minFrequency, float maxFrequency) {
+    minFrequency_ = minFrequency;
+    maxFrequency_ = maxFrequency;
+}
+
+void YinPitchDetector::setThreshold(float threshold) {
+    threshold_ = threshold;
+}
+
+YinResult YinPitchDetector::detect(const float* input, int frameCount) {
+    YinResult result;
+
+    if (input == nullptr || frameCount < frameSize_) {
+        return result;
+    }
+
+    const int tauMin = std::max(2, static_cast<int>(sampleRate_ / maxFrequency_));
+    const int tauMax = std::min(
+        frameSize_ / 2 - 1,
+        static_cast<int>(sampleRate_ / minFrequency_)
+    );
+
+    std::fill(difference_.begin(), difference_.end(), 0.0f);
+
+    for (int tau = 1; tau <= tauMax; ++tau) {
+        float sum = 0.0f;
+
+        for (int i = 0; i < frameSize_ - tau; ++i) {
+            const float delta = input[i] - input[i + tau];
+            sum += delta * delta;
+        }
+
+        difference_[tau] = sum;
+    }
+
+    cmnd_[0] = 1.0f;
+
+    float runningSum = 0.0f;
+
+    for (int tau = 1; tau <= tauMax; ++tau) {
+        runningSum += difference_[tau];
+
+        if (runningSum <= 0.0f) {
+            cmnd_[tau] = 1.0f;
+        } else {
+            cmnd_[tau] = difference_[tau] * tau / runningSum;
+        }
+    }
+
+    int tauEstimate = -1;
+
+    for (int tau = tauMin; tau <= tauMax; ++tau) {
+        if (cmnd_[tau] < threshold_) {
+            while (tau + 1 <= tauMax && cmnd_[tau + 1] < cmnd_[tau]) {
+                tau++;
+            }
+
+            tauEstimate = tau;
+            break;
+        }
+    }
+
+    if (tauEstimate == -1) {
+        return result;
+    }
+
+    const float betterTau = parabolicInterpolation(tauEstimate);
+
+    if (betterTau <= 0.0f) {
+        return result;
+    }
+
+    result.hasPitch = true;
+    result.frequency = sampleRate_ / betterTau;
+    result.confidence = 1.0f - cmnd_[tauEstimate];
+
+    return result;
+}
+
+DetectorResult YinPitchDetector::detect(const float* frame, int n, float sampleRate) {
+    // Store the passed sampleRate temporarily if it differs (Pipeline may have resampled)
+    const float savedSr = sampleRate_;
+    if (sampleRate > 0.0f && sampleRate != sampleRate_) {
+        sampleRate_ = sampleRate;
+    }
+    YinResult r = detect(frame, n);
+    sampleRate_ = savedSr;
+    return DetectorResult{ r.hasPitch, r.frequency, r.confidence };
+}
+
+float YinPitchDetector::parabolicInterpolation(int tau) const {
+    if (tau <= 0 || tau >= static_cast<int>(cmnd_.size()) - 1) {
+        return static_cast<float>(tau);
+    }
+
+    const float left = cmnd_[tau - 1];
+    const float center = cmnd_[tau];
+    const float right = cmnd_[tau + 1];
+
+    const float denominator = left - 2.0f * center + right;
+
+    if (std::fabs(denominator) < 1e-6f) {
+        return static_cast<float>(tau);
+    }
+
+    return tau + 0.5f * (left - right) / denominator;
+}

package/cpp/tests/CMakeLists.txt

@@ -0,0 +1,23 @@
+cmake_minimum_required(VERSION 3.20)
+
+project(TunerEngineTests LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_subdirectory(.. ${CMAKE_BINARY_DIR}/tuner_engine_core)
+
+add_executable(tuner_engine_tests
+    main.cpp
+)
+
+target_link_libraries(tuner_engine_tests PRIVATE tuner_engine_core)
+
+add_executable(tuner_engine_bench
+    bench.cpp
+)
+
+target_link_libraries(tuner_engine_bench PRIVATE tuner_engine_core)
+
+enable_testing()
+add_test(NAME tuner_engine_tests COMMAND tuner_engine_tests)