Sprint 4: Add AudioAnalyser — LUFS, FFT bands, stereo width, centroid, true peak

Runs in processBlock (audio thread), stores results in atomics.
MCP get_analysis reads atomics from HTTP thread — zero contention.

Output format: "-14.2 LUFS | TP:-1.1 | sub:ok bass:+3 low:ok mid:ok hi:-2 brill:ok | W:0.72 | bright"
Max ~60 tokens per call."

Source/Plugin/AudioAnalyser.h

@@ -0,0 +1,259 @@
+#pragma once
+
+#include <juce_audio_basics/juce_audio_basics.h>
+#include <juce_dsp/juce_dsp.h>
+#include <atomic>
+#include <array>
+#include <cmath>
+#include <string>
+
+// Real-time audio analyser — runs in processBlock, results read from MCP thread.
+// All inter-thread communication via std::atomic — no locks in audio path.
+
+class AudioAnalyser
+{
+public:
+    AudioAnalyser() = default;
+
+    void prepareToPlay(double sampleRate, int blockSize)
+    {
+        currentSampleRate = sampleRate;
+        currentBlockSize = blockSize;
+
+        // FFT setup (1024-point)
+        fftBuffer.fill(0.0f);
+        fftWritePos = 0;
+
+        // LUFS — simplified momentary loudness (400ms window)
+        lufsWindowSamples = (int)(sampleRate * 0.4);
+        lufsAccumulator = 0.0;
+        lufsSampleCount = 0;
+
+        // Reset all outputs
+        momentaryLUFS.store(-100.0f);
+        truePeak.store(-100.0f);
+        stereoWidth.store(0.0f);
+        spectralCentroid.store(0.0f);
+        isSilent.store(true);
+
+        for (auto& b : bands)
+            b.store(0.0f);
+    }
+
+    // Called from audio thread — MUST be lock-free
+    void processBlock(const juce::AudioBuffer<float>& buffer)
+    {
+        const int numSamples = buffer.getNumSamples();
+        const int numChannels = buffer.getNumChannels();
+        if (numSamples == 0 || numChannels == 0) return;
+
+        const float* left = buffer.getReadPointer(0);
+        const float* right = numChannels > 1 ? buffer.getReadPointer(1) : left;
+
+        // --- True Peak ---
+        float peak = 0.0f;
+        for (int i = 0; i < numSamples; ++i)
+        {
+            float absL = std::fabs(left[i]);
+            float absR = std::fabs(right[i]);
+            peak = std::max(peak, std::max(absL, absR));
+        }
+        float peakDb = peak > 0.0f ? 20.0f * std::log10(peak) : -100.0f;
+        truePeak.store(peakDb);
+
+        // --- Silence Gate ---
+        if (peakDb < -60.0f)
+        {
+            isSilent.store(true);
+            return;
+        }
+        isSilent.store(false);
+
+        // --- LUFS (simplified momentary — sum of squares over 400ms) ---
+        for (int i = 0; i < numSamples; ++i)
+        {
+            float mono = (left[i] + right[i]) * 0.5f;
+            lufsAccumulator += (double)(mono * mono);
+            lufsSampleCount++;
+
+            if (lufsSampleCount >= lufsWindowSamples)
+            {
+                double meanSquare = lufsAccumulator / (double)lufsSampleCount;
+                float lufs = (meanSquare > 0.0) ? (float)(-0.691 + 10.0 * std::log10(meanSquare)) : -100.0f;
+                momentaryLUFS.store(lufs);
+                lufsAccumulator = 0.0;
+                lufsSampleCount = 0;
+            }
+        }
+
+        // --- Stereo Width (correlation-based) ---
+        float sumMid = 0.0f, sumSide = 0.0f;
+        for (int i = 0; i < numSamples; ++i)
+        {
+            float mid = (left[i] + right[i]) * 0.5f;
+            float side = (left[i] - right[i]) * 0.5f;
+            sumMid += mid * mid;
+            sumSide += side * side;
+        }
+        float totalEnergy = sumMid + sumSide;
+        float width = (totalEnergy > 1e-10f) ? sumSide / totalEnergy : 0.0f;
+        // Smooth
+        float prevWidth = stereoWidth.load();
+        stereoWidth.store(prevWidth * 0.9f + width * 0.1f);
+
+        // --- FFT accumulator (ring buffer → run FFT when full) ---
+        for (int i = 0; i < numSamples; ++i)
+        {
+            float mono = (left[i] + right[i]) * 0.5f;
+            fftBuffer[fftWritePos] = mono;
+            fftWritePos++;
+
+            if (fftWritePos >= kFFTSize)
+            {
+                runFFT();
+                fftWritePos = 0;
+            }
+        }
+    }
+
+    // Called from HTTP/MCP thread — thread-safe read of atomic values
+    std::string getCompactAnalysis() const
+    {
+        if (isSilent.load())
+            return "silent";
+
+        char buf[256];
+        float lufs = momentaryLUFS.load();
+        float tp = truePeak.load();
+        float width = stereoWidth.load();
+        float centroid = spectralCentroid.load();
+
+        // Band deviations from flat (0 = flat reference)
+        // Only report bands that deviate > ±2dB
+        std::string bandStr;
+        static const char* bandNames[] = {"sub", "bass", "low", "mid", "hi", "pres", "brill"};
+        for (int i = 0; i < 7; ++i)
+        {
+            float db = bands[i].load();
+            if (db > 2.0f)
+                bandStr += std::string(bandNames[i]) + ":+" + std::to_string((int)db) + " ";
+            else if (db < -2.0f)
+                bandStr += std::string(bandNames[i]) + ":" + std::to_string((int)db) + " ";
+        }
+        if (bandStr.empty())
+            bandStr = "flat ";
+
+        // Brightness descriptor from centroid
+        const char* brightnessDesc = "balanced";
+        if (centroid > 4000.0f) brightnessDesc = "bright";
+        else if (centroid < 1500.0f) brightnessDesc = "dark";
+
+        snprintf(buf, sizeof(buf), "%.1f LUFS | TP:%.1f | %s| W:%.2f | %s",
+                 lufs, tp, bandStr.c_str(), width, brightnessDesc);
+
+        return std::string(buf);
+    }
+
+private:
+    static constexpr int kFFTOrder = 10;
+    static constexpr int kFFTSize = 1 << kFFTOrder; // 1024
+
+    void runFFT()
+    {
+        // Apply window
+        std::array<float, kFFTSize> windowed;
+        for (int i = 0; i < kFFTSize; ++i)
+            windowed[i] = fftBuffer[i] * hanningWindow(i, kFFTSize);
+
+        // JUCE FFT requires 2x buffer (real + imaginary interleaved)
+        std::array<float, kFFTSize * 2> fftData{};
+        for (int i = 0; i < kFFTSize; ++i)
+            fftData[i] = windowed[i];
+
+        juce::dsp::FFT fft(kFFTOrder);
+        fft.performFrequencyOnlyForwardTransform(fftData.data());
+
+        // Now fftData[0..kFFTSize/2] contains magnitudes
+        int halfSize = kFFTSize / 2;
+        float binWidth = (float)currentSampleRate / (float)kFFTSize;
+
+        // --- 7 Band Energy ---
+        // sub: 20-60, bass: 60-250, low: 250-500, mid: 500-2k, hi: 2k-6k, pres: 6k-12k, brill: 12k-20k
+        static const float bandEdges[] = {20, 60, 250, 500, 2000, 6000, 12000, 20000};
+
+        float bandEnergy[7] = {};
+        int bandCount[7] = {};
+
+        for (int bin = 1; bin < halfSize; ++bin)
+        {
+            float freq = bin * binWidth;
+            float mag = fftData[bin];
+
+            for (int b = 0; b < 7; ++b)
+            {
+                if (freq >= bandEdges[b] && freq < bandEdges[b + 1])
+                {
+                    bandEnergy[b] += mag * mag;
+                    bandCount[b]++;
+                    break;
+                }
+            }
+        }
+
+        // Convert to dB relative to average
+        float totalEnergy = 0.0f;
+        for (int b = 0; b < 7; ++b)
+            totalEnergy += bandEnergy[b];
+
+        float avgEnergy = totalEnergy / 7.0f;
+
+        for (int b = 0; b < 7; ++b)
+        {
+            float bandDb = 0.0f;
+            if (avgEnergy > 1e-10f && bandEnergy[b] > 1e-10f)
+                bandDb = 10.0f * std::log10(bandEnergy[b] / avgEnergy);
+            bands[b].store(bandDb);
+        }
+
+        // --- Spectral Centroid ---
+        float weightedSum = 0.0f;
+        float magnitudeSum = 0.0f;
+        for (int bin = 1; bin < halfSize; ++bin)
+        {
+            float freq = bin * binWidth;
+            float mag = fftData[bin];
+            weightedSum += freq * mag;
+            magnitudeSum += mag;
+        }
+        float centroid = (magnitudeSum > 1e-10f) ? weightedSum / magnitudeSum : 0.0f;
+        // Smooth
+        float prevCentroid = spectralCentroid.load();
+        spectralCentroid.store(prevCentroid * 0.8f + centroid * 0.2f);
+    }
+
+    static float hanningWindow(int i, int size)
+    {
+        return 0.5f * (1.0f - std::cos(2.0f * 3.14159265358979f * i / (float)(size - 1)));
+    }
+
+    // State
+    double currentSampleRate = 44100.0;
+    int currentBlockSize = 512;
+
+    // FFT ring buffer
+    std::array<float, kFFTSize> fftBuffer{};
+    int fftWritePos = 0;
+
+    // LUFS accumulator
+    int lufsWindowSamples = 17640; // 400ms at 44.1kHz
+    double lufsAccumulator = 0.0;
+    int lufsSampleCount = 0;
+
+    // Thread-safe outputs (written in audio thread, read from HTTP thread)
+    std::atomic<float> momentaryLUFS{-100.0f};
+    std::atomic<float> truePeak{-100.0f};
+    std::atomic<float> stereoWidth{0.0f};
+    std::atomic<float> spectralCentroid{0.0f};
+    std::atomic<bool> isSilent{true};
+    std::array<std::atomic<float>, 7> bands{}; // sub, bass, low, mid, hi, pres, brill
+};