Super responsive FFT with overlap processing

Author: kunitoki

examples/graphics/source/examples/SpectrumAnalyzer.h

@@ -441,6 +441,16 @@ class SpectrumAnalyzerDemo
             analyzerComponent.setReleaseTimeSeconds (value);
         };
         addAndMakeVisible (*releaseSlider);
+        
+        // Overlap control for responsiveness
+        overlapSlider = std::make_unique<yup::Slider> (yup::Slider::LinearBarHorizontal, "Overlap");
+        overlapSlider->setRange ({ 0.0, 0.95 });
+        overlapSlider->setValue (0.75);
+        overlapSlider->onValueChanged = [this] (float value)
+        {
+            analyzerComponent.setOverlapFactor (value);
+        };
+        addAndMakeVisible (*overlapSlider);
 
         // Status labels with appropriate font size
         auto statusFont = font.withHeight (11.0f);
@@ -469,12 +479,13 @@ class SpectrumAnalyzerDemo
         analyzerComponent.setDecibelRange (-100.0f, 10.0f);
         analyzerComponent.setUpdateRate (30);
         analyzerComponent.setSampleRate (44100.0);
+        analyzerComponent.setOverlapFactor (0.75f); // 75% overlap for better responsiveness
         addAndMakeVisible (analyzerComponent);
 
         // Create parameter labels with proper font sizing
         auto labelFont = font.withHeight (12.0f);
 
-        for (const auto& labelText : { "Signal Type:", "Frequency:", "Amplitude:", "Sweep Duration:", "FFT Size:", "Window:", "Display:", "Release:" })
+        for (const auto& labelText : { "Signal Type:", "Frequency:", "Amplitude:", "Sweep Duration:", "FFT Size:", "Window:", "Display:", "Release:", "Overlap:" })
         {
             auto label = parameterLabels.add (std::make_unique<yup::Label> (labelText));
             label->setText (labelText);
@@ -526,7 +537,7 @@ class SpectrumAnalyzerDemo
         auto fftSizeSection = row2.removeFromLeft (colWidth);
         auto windowSection = row2.removeFromLeft (colWidth);
         auto displaySection = row2.removeFromLeft (colWidth);
-        row2.removeFromLeft (colWidth); // Skip unused column
+        auto overlapSection = row2.removeFromLeft (colWidth);
 
         parameterLabels[4]->setBounds (fftSizeSection.removeFromTop (labelHeight));
         fftSizeCombo->setBounds (fftSizeSection.removeFromTop (controlHeight));
@@ -536,6 +547,9 @@ class SpectrumAnalyzerDemo
 
         parameterLabels[6]->setBounds (displaySection.removeFromTop (labelHeight));
         displayTypeCombo->setBounds (displaySection.removeFromTop (controlHeight));
+        
+        parameterLabels[8]->setBounds (overlapSection.removeFromTop (labelHeight));
+        overlapSlider->setBounds (overlapSection.removeFromTop (controlHeight));
 
         // Third row: Status labels
         auto row3 = bounds.removeFromTop (30);
@@ -671,6 +685,7 @@ class SpectrumAnalyzerDemo
     std::unique_ptr<yup::ComboBox> windowTypeCombo;
     std::unique_ptr<yup::ComboBox> displayTypeCombo;
     std::unique_ptr<yup::Slider> releaseSlider;
+    std::unique_ptr<yup::Slider> overlapSlider;
 
     // Status labels
     std::unique_ptr<yup::Label> frequencyLabel;

modules/yup_audio_gui/displays/yup_SpectrumAnalyzerComponent.cpp

@@ -57,12 +57,15 @@ void SpectrumAnalyzerComponent::initializeFFTBuffers()
 void SpectrumAnalyzerComponent::timerCallback()
 {
     bool hasNewData = false;
+    int fftCount = 0;
+    const int maxFFTsPerFrame = 8; // Limit to prevent blocking UI thread
 
-    // Process FFT frames with proper overlap
-    while (analyzerState.getNumAvailableSamples() >= fftSize && analyzerState.isFFTDataReady())
+    // Process multiple FFT frames with overlap for better responsiveness
+    while (analyzerState.isFFTDataReady() && fftCount < maxFFTsPerFrame)
     {
         processFFT();
         hasNewData = true;
+        ++fftCount;
     }
 
     // Always update display to maintain smooth animation
@@ -558,6 +561,16 @@ void SpectrumAnalyzerComponent::setReleaseTimeSeconds (float timeSeconds)
     releaseTimeSeconds = jmax (0.1f, timeSeconds);
 }
 
+void SpectrumAnalyzerComponent::setOverlapFactor (float overlapFactor)
+{
+    analyzerState.setOverlapFactor (overlapFactor);
+}
+
+float SpectrumAnalyzerComponent::getOverlapFactor() const noexcept
+{
+    return analyzerState.getOverlapFactor();
+}
+
 void SpectrumAnalyzerComponent::setFFTSize (int size)
 {
     jassert (isPowerOfTwo (size) && size >= 64 && size <= 16384);

modules/yup_audio_gui/displays/yup_SpectrumAnalyzerComponent.h

@@ -168,6 +168,16 @@ class YUP_API SpectrumAnalyzerComponent
 
     /** Returns the current release time in seconds. */
     float getReleaseTimeSeconds() const noexcept { return releaseTimeSeconds; }
+    
+    //==============================================================================
+    /** Sets the overlap factor for more responsive spectrum analysis.
+    
+        @param overlapFactor    overlap factor (0.0 = no overlap, 0.75 = 75% overlap)
+    */
+    void setOverlapFactor (float overlapFactor);
+    
+    /** Returns the current overlap factor. */
+    float getOverlapFactor() const noexcept;
 
     //==============================================================================
     /** Returns the frequency for a given bin index.

modules/yup_dsp/frequency/yup_SpectrumAnalyzerState.cpp

@@ -38,6 +38,7 @@ void SpectrumAnalyzerState::initializeFifo()
 {
     fftDataReady = false;
     fifoSize = fftSize * 4;
+    hopSize = static_cast<int> (fftSize * (1.0f - overlapFactor));
 
     audioFifo = std::make_unique<AbstractFifo> (fifoSize);
 
@@ -57,7 +58,7 @@ void SpectrumAnalyzerState::pushSample (float sample) noexcept
     if (writeScope.blockSize1 > 0)
         sampleBuffer[static_cast<size_t> (writeScope.startIndex1)] = sample;
 
-    // Check if we have enough samples for FFT processing
+    // Check if we have enough samples for FFT processing with overlap
     if (audioFifo->getNumReady() >= fftSize)
         fftDataReady = true;
 }
@@ -85,7 +86,7 @@ void SpectrumAnalyzerState::pushSamples (const float* samples, int numSamples) n
         std::copy_n (samples + writeScope.blockSize1, writeScope.blockSize2, &sampleBuffer[static_cast<size_t> (writeScope.startIndex2)]);
     }
 
-    // Check if we have enough samples for FFT processing
+    // Check if we have enough samples for FFT processing with overlap
     if (audioFifo->getNumReady() >= fftSize)
         fftDataReady = true;
 }
@@ -103,29 +104,42 @@ bool SpectrumAnalyzerState::getFFTData (float* destBuffer) noexcept
     if (destBuffer == nullptr || ! isFFTDataReady())
         return false;
 
-    // Lock-free read from FIFO - safe for UI thread
-    const auto readScope = audioFifo->read (fftSize);
+    // Use prepareToRead to get read positions without consuming data
+    int startIndex1, blockSize1, startIndex2, blockSize2;
+    audioFifo->prepareToRead (fftSize, startIndex1, blockSize1, startIndex2, blockSize2);
 
     // Copy first block
-    if (readScope.blockSize1 > 0)
+    if (blockSize1 > 0)
     {
-        std::copy_n (&sampleBuffer[static_cast<size_t> (readScope.startIndex1)],
-                     readScope.blockSize1,
+        std::copy_n (&sampleBuffer[static_cast<size_t> (startIndex1)],
+                     blockSize1,
                      destBuffer);
     }
 
     // Copy second block (wrap-around case)
-    if (readScope.blockSize2 > 0)
+    if (blockSize2 > 0)
     {
-        std::copy_n (&sampleBuffer[static_cast<size_t> (readScope.startIndex2)],
-                     readScope.blockSize2,
-                     destBuffer + readScope.blockSize1);
+        std::copy_n (&sampleBuffer[static_cast<size_t> (startIndex2)],
+                     blockSize2,
+                     destBuffer + blockSize1);
     }
 
-    // Reset the ready flag since we've consumed the data
-    fftDataReady = false;
+    // Check if we read the full FFT size
+    const int actualReadSize = blockSize1 + blockSize2;
+    if (actualReadSize == fftSize)
+    {
+        // Advance read position by hopSize (not full FFT size) for overlap processing
+        audioFifo->finishedRead (hopSize);
+        
+        // Check if we still have enough samples for next FFT
+        fftDataReady = (audioFifo->getNumReady() >= fftSize);
+        
+        return true;
+    }
 
-    return (readScope.blockSize1 + readScope.blockSize2) == fftSize;
+    // If we couldn't read the full FFT size, reset flag and return false
+    fftDataReady = false;
+    return false;
 }
 
 //==============================================================================
@@ -161,4 +175,21 @@ int SpectrumAnalyzerState::getFreeSpace() const noexcept
     return audioFifo->getFreeSpace();
 }
 
+void SpectrumAnalyzerState::setOverlapFactor (float newOverlapFactor)
+{
+    jassert (newOverlapFactor >= 0.0f && newOverlapFactor < 1.0f);
+    
+    if (overlapFactor != newOverlapFactor)
+    {
+        overlapFactor = jlimit (0.0f, 0.95f, newOverlapFactor);
+        hopSize = static_cast<int> (fftSize * (1.0f - overlapFactor));
+        hopSize = jmax (1, hopSize); // Ensure minimum hop size of 1
+    }
+}
+
+int SpectrumAnalyzerState::getHopSize() const noexcept
+{
+    return hopSize;
+}
+
 } // namespace yup

modules/yup_dsp/frequency/yup_SpectrumAnalyzerState.h

@@ -115,13 +115,28 @@ class YUP_API SpectrumAnalyzerState
 
     /** Returns the amount of free space in the FIFO. */
     int getFreeSpace() const noexcept;
+    
+    //==============================================================================
+    /** Sets the overlap factor for more responsive spectrum analysis.
+    
+        @param overlapFactor    overlap factor (0.0 = no overlap, 0.75 = 75% overlap)
+    */
+    void setOverlapFactor (float overlapFactor);
+    
+    /** Returns the current overlap factor. */
+    float getOverlapFactor() const noexcept { return overlapFactor; }
+    
+    /** Returns the hop size (samples between FFT frames). */
+    int getHopSize() const noexcept;
 
 private:
     //==============================================================================
     void initializeFifo();
 
     int fftSize = 2048;
     int fifoSize = 8192; // Will be updated in initializeFifo()
+    float overlapFactor = 0.75f; // 75% overlap by default
+    int hopSize = 512; // Will be computed from overlap factor
 
     std::unique_ptr<AbstractFifo> audioFifo;
     std::vector<float> sampleBuffer;