Low-latency pitch detection (phases 1-4)

source/dsp/PitchSmoother.h

@@ -41,14 +41,17 @@ class PitchSmoother
             return std::exp2(smoothed);
         }
 
-        smoothed += alpha * (logFreq - smoothed);
+        float delta = std::abs(logFreq - smoothed);
+        float effectiveAlpha = delta > 0.08f ? 1.0f : alpha;
+
+        smoothed += effectiveAlpha * (logFreq - smoothed);
         return std::exp2(smoothed);
     }
 
 private:
     inline void recomputeAlpha()
     {
-        float tau = smoothingAmount * 0.2f;
+        float tau = smoothingAmount * 0.05f;
         if (tau < 1e-6f)
             alpha = 1.0f;
         else

source/dsp/YinPitchDetector.cpp

@@ -4,40 +4,46 @@
 
 void YinPitchDetector::prepare(double sampleRate)
 {
-    decimation = (sampleRate > 50000.0) ? 4 : 2;
-    decimationCounter = 0;
-    decimationAccum = 0.0f;
-    analysisSR = sampleRate / decimation;
+    analysisSR = sampleRate;
 
-    windowSize = 2048;
-    halfWindow = windowSize / 2;
+    halfWindow = static_cast<int>(std::ceil(sampleRate / 70.0));
+    windowSize = 2 * halfWindow;
+    hopSize = static_cast<int>(std::ceil(sampleRate * 0.003));
+
+    fftOrder = static_cast<int>(std::ceil(std::log2(2.0 * windowSize)));
+    fftSize = 1 << fftOrder;
+    fft = std::make_unique<juce::dsp::FFT>(fftOrder);
+    fftInput.resize(static_cast<size_t>(fftSize * 2), 0.0f);
+    fftOutput.resize(static_cast<size_t>(fftSize * 2), 0.0f);
 
     buffer.assign(static_cast<size_t>(windowSize), 0.0f);
+    linearBuffer.resize(static_cast<size_t>(windowSize));
     diff.resize(static_cast<size_t>(halfWindow));
     cmndf.resize(static_cast<size_t>(halfWindow));
 
     writePos = 0;
-    bufferFull = false;
+    hopCounter = 0;
+    windowFilled = false;
     lastResult = {};
 }
 
 void YinPitchDetector::feedSample(float sample)
 {
-    decimationAccum += sample;
-    if (++decimationCounter < decimation)
-        return;
-
-    float decimatedSample = decimationAccum / static_cast<float>(decimation);
-    decimationAccum = 0.0f;
-    decimationCounter = 0;
+    buffer[static_cast<size_t>(writePos)] = sample;
+    writePos = (writePos + 1) % windowSize;
+    ++hopCounter;
 
-    buffer[static_cast<size_t>(writePos)] = decimatedSample;
-    ++writePos;
+    if (!windowFilled)
+    {
+        if (writePos == 0)
+            windowFilled = true;
+        else
+            return;
+    }
 
-    if (writePos >= windowSize)
+    if (hopCounter >= hopSize)
     {
-        writePos = 0;
-        bufferFull = true;
+        hopCounter = 0;
         analyse();
     }
 }
@@ -49,24 +55,47 @@ PitchResult YinPitchDetector::getResult() const
 
 void YinPitchDetector::analyse()
 {
-    if (!bufferFull)
-        return;
-
     auto n = static_cast<size_t>(halfWindow);
 
-    // Step 1: Difference function
-    for (size_t tau = 0; tau < n; ++tau)
+    for (int i = 0; i < windowSize; ++i)
+        linearBuffer[static_cast<size_t>(i)] = buffer[static_cast<size_t>((writePos + i) % windowSize)];
+
+    std::fill(fftInput.begin(), fftInput.end(), 0.0f);
+    for (size_t i = 0; i < n; ++i)
+        fftInput[i] = linearBuffer[i];
+    fft->performRealOnlyForwardTransform(fftInput.data());
+
+    std::fill(fftOutput.begin(), fftOutput.end(), 0.0f);
+    for (int i = 0; i < windowSize; ++i)
+        fftOutput[static_cast<size_t>(i)] = linearBuffer[static_cast<size_t>(i)];
+    fft->performRealOnlyForwardTransform(fftOutput.data());
+
+    for (int k = 0; k < fftSize; ++k)
     {
-        float sum = 0.0f;
-        for (size_t j = 0; j < n; ++j)
-        {
-            float d = buffer[j] - buffer[j + tau];
-            sum += d * d;
-        }
-        diff[tau] = sum;
+        float aRe = fftInput[static_cast<size_t>(2 * k)];
+        float aIm = fftInput[static_cast<size_t>(2 * k + 1)];
+        float bRe = fftOutput[static_cast<size_t>(2 * k)];
+        float bIm = fftOutput[static_cast<size_t>(2 * k + 1)];
+        fftInput[static_cast<size_t>(2 * k)]     = aRe * bRe + aIm * bIm;
+        fftInput[static_cast<size_t>(2 * k + 1)] = aRe * bIm - aIm * bRe;
+    }
+
+    fft->performRealOnlyInverseTransform(fftInput.data());
+
+    float powerTerm0 = 0.0f;
+    for (size_t j = 0; j < n; ++j)
+        powerTerm0 += linearBuffer[j] * linearBuffer[j];
+
+    float powerTermTau = powerTerm0;
+
+    diff[0] = 0.0f;
+    for (size_t tau = 1; tau < n; ++tau)
+    {
+        powerTermTau += linearBuffer[n + tau - 1] * linearBuffer[n + tau - 1]
+                      - linearBuffer[tau - 1] * linearBuffer[tau - 1];
+        diff[tau] = powerTerm0 + powerTermTau - 2.0f * fftInput[tau];
     }
 
-    // Step 2: Cumulative mean normalized difference function
     cmndf[0] = 1.0f;
     float runningSum = 0.0f;
 
@@ -79,7 +108,6 @@ void YinPitchDetector::analyse()
             cmndf[tau] = 1.0f;
     }
 
-    // Step 3: Absolute threshold
     size_t tauEstimate = 0;
     for (size_t tau = 2; tau < n; ++tau)
     {
@@ -98,7 +126,6 @@ void YinPitchDetector::analyse()
         return;
     }
 
-    // Step 4: Parabolic interpolation
     float betterTau = static_cast<float>(tauEstimate);
 
     if (tauEstimate > 0 && tauEstimate < n - 1)

source/dsp/YinPitchDetector.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <juce_dsp/juce_dsp.h>
+#include <memory>
 #include <vector>
 
 struct PitchResult
@@ -19,16 +21,21 @@ class YinPitchDetector
     void analyse();
 
     double analysisSR = 44100.0;
-    int windowSize = 2048;
-    int halfWindow = 1024;
-
-    int decimation = 1;
-    int decimationCounter = 0;
-    float decimationAccum = 0.0f;
+    int windowSize = 0;
+    int halfWindow = 0;
+    int hopSize = 0;
 
     std::vector<float> buffer;
+    std::vector<float> linearBuffer;
     int writePos = 0;
-    bool bufferFull = false;
+    int hopCounter = 0;
+    bool windowFilled = false;
+
+    std::unique_ptr<juce::dsp::FFT> fft;
+    int fftOrder = 0;
+    int fftSize = 0;
+    std::vector<float> fftInput;
+    std::vector<float> fftOutput;
 
     std::vector<float> diff;
     std::vector<float> cmndf;

tests/CMakeLists.txt

@@ -8,15 +8,15 @@ FetchContent_Declare(
 )
 FetchContent_MakeAvailable(Catch2)
 
-add_executable(HdnRingmodTests
+juce_add_console_app(HdnRingmodTests
+    PRODUCT_NAME "HDN Ring Modulator Tests"
+)
+
+target_sources(HdnRingmodTests PRIVATE
     TestOscillator.cpp
     TestYinPitchDetector.cpp
     TestPitchSmoother.cpp
     TestParameters.cpp
-)
-
-# PitchSmoother is header-only so doesn't need a source entry here
-target_sources(HdnRingmodTests PRIVATE
     ${CMAKE_CURRENT_SOURCE_DIR}/../source/dsp/Oscillator.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/../source/dsp/YinPitchDetector.cpp
 )
@@ -25,7 +25,15 @@ target_include_directories(HdnRingmodTests PRIVATE
     ${CMAKE_CURRENT_SOURCE_DIR}/../source
 )
 
-target_link_libraries(HdnRingmodTests PRIVATE Catch2::Catch2WithMain)
+target_compile_definitions(HdnRingmodTests PRIVATE
+    JUCE_WEB_BROWSER=0
+    JUCE_USE_CURL=0
+)
+
+target_link_libraries(HdnRingmodTests PRIVATE
+    juce::juce_dsp
+    Catch2::Catch2WithMain
+)
 
 include(CTest)
 include(Catch)

tests/TestPitchSmoother.cpp

@@ -81,7 +81,7 @@ TEST_CASE("PitchSmoother: zero smoothing passes frequency through immediately")
                  Catch::Matchers::WithinAbs(440.0, 0.1));
 }
 
-TEST_CASE("PitchSmoother: smoothing slows convergence")
+TEST_CASE("PitchSmoother: smoothing slows convergence within a semitone")
 {
     PitchSmoother fast, slow;
     fast.prepare(44100.0);
@@ -92,32 +92,82 @@ TEST_CASE("PitchSmoother: smoothing slows convergence")
     slow.setSmoothingAmount(0.9f);
     slow.setSensitivity(1.0f);
 
-    fast.process(220.0f, 1.0f);
-    slow.process(220.0f, 1.0f);
+    fast.process(440.0f, 1.0f);
+    slow.process(440.0f, 1.0f);
 
     float fastOut = 0.0f, slowOut = 0.0f;
-    for (int i = 0; i < 1000; ++i)
+    for (int i = 0; i < 100; ++i)
     {
-        fastOut = fast.process(440.0f, 1.0f);
-        slowOut = slow.process(440.0f, 1.0f);
+        fastOut = fast.process(443.0f, 1.0f);
+        slowOut = slow.process(443.0f, 1.0f);
     }
 
-    REQUIRE(std::abs(fastOut - 440.0f) < std::abs(slowOut - 440.0f));
+    REQUIRE(std::abs(fastOut - 443.0f) < std::abs(slowOut - 443.0f));
 }
 
-TEST_CASE("PitchSmoother: works in log-frequency domain (octave-uniform)")
+TEST_CASE("PitchSmoother: smoothing operates in log-frequency domain")
 {
     PitchSmoother smoother;
     smoother.prepare(44100.0);
     smoother.setSmoothingAmount(0.5f);
     smoother.setSensitivity(1.0f);
 
-    smoother.process(220.0f, 1.0f);
+    smoother.process(440.0f, 1.0f);
 
     float output = 0.0f;
-    for (int i = 0; i < 4410; ++i)
-        output = smoother.process(440.0f, 1.0f);
+    for (int i = 0; i < 100; ++i)
+        output = smoother.process(445.0f, 1.0f);
+
+    REQUIRE(output > 440.0f);
+    REQUIRE(output < 445.0f);
+}
+
+TEST_CASE("PitchSmoother: instant lock on note change")
+{
+    PitchSmoother smoother;
+    smoother.prepare(44100.0);
+    smoother.setSmoothingAmount(1.0f);
+    smoother.setSensitivity(1.0f);
 
-    REQUIRE(output > 220.0f);
-    REQUIRE(output < 440.0f);
+    smoother.process(440.0f, 1.0f);
+
+    float output = smoother.process(880.0f, 1.0f);
+    REQUIRE_THAT(static_cast<double>(output),
+                 Catch::Matchers::WithinAbs(880.0, 0.1));
+}
+
+TEST_CASE("PitchSmoother: holds during alternating confidence gaps")
+{
+    PitchSmoother smoother;
+    smoother.prepare(44100.0);
+    smoother.setSmoothingAmount(0.0f);
+    smoother.setSensitivity(0.5f);
+
+    smoother.process(440.0f, 1.0f);
+
+    for (int i = 0; i < 10; ++i)
+    {
+        float held = smoother.process(0.0f, 0.0f);
+        REQUIRE_THAT(static_cast<double>(held),
+                     Catch::Matchers::WithinAbs(440.0, 0.1));
+
+        float active = smoother.process(440.0f, 1.0f);
+        REQUIRE_THAT(static_cast<double>(active),
+                     Catch::Matchers::WithinAbs(440.0, 0.1));
+    }
+}
+
+TEST_CASE("PitchSmoother: stable output on sustained note")
+{
+    PitchSmoother smoother;
+    smoother.prepare(44100.0);
+    smoother.setSmoothingAmount(0.5f);
+    smoother.setSensitivity(1.0f);
+
+    for (int i = 0; i < 1000; ++i)
+        smoother.process(440.0f, 1.0f);
+
+    float output = smoother.process(440.0f, 1.0f);
+    REQUIRE_THAT(static_cast<double>(output),
+                 Catch::Matchers::WithinAbs(440.0, 0.01));
 }