Merge branch 'pdpwopr' into audioupdates

Author: davepl

include/effects/strip/faneffects.h

@@ -412,9 +412,7 @@ class FanBeatEffect : public LEDStripEffect
 
     CRGB c = CHSV(random(0, 255), 255, 255);
     for (int i = NUM_FANS * FAN_SIZE; i < NUM_LEDS; i++)
-    {
       g()->setPixel(i, c);
-    }
   }
 
   void DrawEffect()

include/globals.h

@@ -150,6 +150,7 @@
     #define USE_M5 1
 #endif
 
+
 #if USE_M5
 #include "M5Unified.h"
 #endif

include/soundanalyzer.h

@@ -304,7 +304,7 @@ class SoundAnalyzer : public ISoundAnalyzer
     // I'm old enough I can only hear up to about 12000Hz, but feel free to adjust.  Remember from
     // school that you need to sample at double the frequency you want to process, so 24000 samples is 12000Hz
 
-    static constexpr size_t SAMPLING_FREQUENCY = 20000;
+    static constexpr size_t SAMPLING_FREQUENCY = 24000;
     static constexpr size_t LOWEST_FREQ = 100;
     static constexpr size_t HIGHEST_FREQ = SAMPLING_FREQUENCY / 2;
 
@@ -324,6 +324,7 @@ class SoundAnalyzer : public ISoundAnalyzer
     float   _oldPeakVU;                 // Old peak VU value for damping
     float   _oldMinVU;                  // Old min VU value for damping
     float * _vPeaks;                    // Normalized band energies 0..1
+    float * _livePeaks;                 // Attack-limited display peaks per band
     int     _bandBinStart[NUM_BANDS];
     int     _bandBinEnd[NUM_BANDS];
     float   _energyMaxEnv = 1.0f;         // adaptive envelope for autoscaling
@@ -346,6 +347,7 @@ class SoundAnalyzer : public ISoundAnalyzer
     //
 
   private:
+    static constexpr int kBandOffset = 1; // number of lowest source bands to skip in layout
     float *_vReal = nullptr;
     float *_vImaginary = nullptr;
     std::unique_ptr<int16_t[]> ptrSampleBuffer; // sample buffer storage
@@ -455,7 +457,9 @@ class SoundAnalyzer : public ISoundAnalyzer
 #endif
         for (int b = 0; b < NUM_BANDS; b++)
         {
-            float fracHi = (float)(b + 1) / (float)NUM_BANDS;
+            // Shift the effective band index by kBandOffset so logical band 0 starts higher
+            const int logicalIdx = b + kBandOffset;
+            const float fracHi = (float)(logicalIdx + 1) / (float)(NUM_BANDS + kBandOffset);
 #if SPECTRUM_BAND_SCALE_MEL
             float edgeMel = melMin + (melMax - melMin) * fracHi;
             float edgeHiFreq = melToHz(edgeMel);
@@ -474,10 +478,31 @@ class SoundAnalyzer : public ISoundAnalyzer
 
     PeakData ProcessPeaksEnergy()
     {
-        float frameMax = 0.0f;
-        float frameRawMax = 0.0f;    // max pre-subtraction band power (with compensation)
-        float noiseSum = 0.0f;       // accumulate noise floor for mean
-        float noiseMaxAll = 0.0f;    // track max noise floor across bands
+        // Band offset handled in ComputeBandLayout so index 0 is the lowest VISIBLE band
+         float frameMax = 0.0f;
+         float frameSumRaw = 0.0f;
+         float noiseSum = 0.0f;
+         float noiseMaxAll = 0.0f; // Tracks max noise floor across bands
+         // Display gain and band floor constants
+         constexpr float kDisplayGain = 1.5f;
+         constexpr float kBandFloorMin = 0.01f;
+         constexpr float kBandFloorScale = 0.05f;
+
+        // Remember that a slower attack will yield a smoother display but a lower one, as it's always 
+        // below the actual for some amount of time
+
+        constexpr float kLiveAttackPerSec = 5.0f;
+
+        // Envelope gating factor and max relative EMA
+        float _gateEnv = 1.0f;
+        float _vMaxRelEMA = 1.0f;
+        // Delta time for attack limiting (replace with actual frame time if available)
+        float dt = 0.016f;
+        // Allocate _livePeaks if not already done
+        if (!_livePeaks) {
+            _livePeaks = (float *)PreferPSRAMAlloc(NUM_BANDS * sizeof(_livePeaks[0]));
+            for (int i = 0; i < NUM_BANDS; ++i) _livePeaks[i] = 0.0f;
+        }
         _framesProcessed++;
         const float binWidth = (float)SAMPLING_FREQUENCY / (MAX_SAMPLES / 2.0f);
         for (int b = 0; b < NUM_BANDS; b++)
@@ -504,8 +529,8 @@ class SoundAnalyzer : public ISoundAnalyzer
             avgPower *= compensation;
 
             // Track pre-subtraction max for SNR gating
-            if (avgPower > frameRawMax)
-                frameRawMax = avgPower;
+            if (avgPower > frameSumRaw)
+                frameSumRaw = avgPower;
 
             if (avgPower > _noiseFloor[b])
                 _noiseFloor[b] = _noiseFloor[b] * (1.0f - _params.energyNoiseAdapt) + (float)avgPower * _params.energyNoiseAdapt;
@@ -520,11 +545,20 @@ class SoundAnalyzer : public ISoundAnalyzer
             float signal = (float)avgPower - _noiseFloor[b];
             if (signal < 0.0f)
                 signal = 0.0f;
-            float smoothed = _rawPrev[b] * (1.0f - _params.energySmoothAlpha) + signal * _params.energySmoothAlpha;
+#if ENABLE_AUDIO_SMOOTHING
+            // Weighted average: 0.25 * (2 * current + left + right)
+            float left = (b > 0) ? _rawPrev[b - 1] : signal;
+            float right = (b < NUM_BANDS - 1) ? _rawPrev[b + 1] : signal;
+            float smoothed = 0.125f * (6.0f * signal + left + right);
             _rawPrev[b] = smoothed;
             _vPeaks[b] = smoothed;
             if (smoothed > frameMax)
                 frameMax = smoothed;
+#else
+            _vPeaks[b] = signal;
+            if (signal > frameMax)
+                frameMax = signal;
+#endif
         }
         if (frameMax > _energyMaxEnv)
             _energyMaxEnv = frameMax;
@@ -535,7 +569,7 @@ class SoundAnalyzer : public ISoundAnalyzer
 
         // Raw SNR-based frame gate (pre-normalization) to suppress steady HVAC and similar backgrounfd noises
 
-        float snrRaw = frameRawMax / (noiseMaxAll + 1e-9f);
+        float snrRaw = frameSumRaw / (noiseMaxAll + 1e-9f);
         if (snrRaw < _params.frameSNRGate)
         {
             _frameGateHits++;
@@ -599,22 +633,8 @@ class SoundAnalyzer : public ISoundAnalyzer
         }
 #endif
 
+        const float invEnv = 1.0f / normDen;
         float sumNorm = 0.0f;
-        for (int b = 0; b < NUM_BANDS; b++)
-        {
-            float v = _vPeaks[b] * invEnv;
-
-            // Per-band normalized noise gate
-            if (v < _params.normNoiseGate)
-            {
-                v = 0.0f;
-                _bandGateHits++;
-            }
-            else
-            {
-                // Cube root compression for smooth flattening without spikes
-                v = sqrt(cbrtf(std::max(0.0f, v)));
-            }
 
             // Apply post-scale to improve visible band intensity and clamp to [0,1]
             v *= _params.postScale;
@@ -628,15 +648,25 @@ class SoundAnalyzer : public ISoundAnalyzer
 #if ENABLE_AUDIO_SMOOTHING
         // Spatially smooth live spectrum peaks by blending with neighbors.
         // This affects displayed bars (and VU after we recompute below).
+        // Now that layout skips the lowest bins, emit all NUM_BANDS directly with no reindexing
+        for (int b = 0; b < NUM_BANDS; b++)
         {
-            float tmp[NUM_BANDS];
-            for (int b = 0; b < NUM_BANDS; ++b)
+            float vTarget = _vPeaks[b] * invEnv;
+            vTarget = cbrtf(std::max(0.0f, vTarget));
+            if (vTarget > 1.0f) vTarget = 1.0f;
+            vTarget *= _gateEnv;
+            vTarget *= kDisplayGain;
+            if (vTarget > 1.0f) vTarget = 1.0f;
+            const float bandFloor = std::max(kBandFloorMin, kBandFloorScale * _vMaxRelEMA);
+            if (vTarget < bandFloor) { vTarget = 0.0f; _bandGateHits++; }
+            float vCurr = _livePeaks[b];
+            float vNew = vTarget;
+            if (vTarget > vCurr)
             {
-                float v = _Peaks._Level[b];
-                float l = (b > 0) ? _Peaks._Level[b - 1] : v;
-                float r = (b < NUM_BANDS - 1) ? _Peaks._Level[b + 1] : v;
-                tmp[b] = (v * 2.0f + l + r) * 0.25f; // (2*center + left + right) / 4
+                const float maxRise = kLiveAttackPerSec * dt;
+                vNew = vCurr + std::min(vTarget - vCurr, maxRise);
             }
+
             for (int b = 0; b < NUM_BANDS; ++b)
             {
                 float v = tmp[b];
@@ -646,9 +676,14 @@ class SoundAnalyzer : public ISoundAnalyzer
             }
             // Recompute VU from smoothed values
             sumNorm = std::accumulate(&_Peaks._Level[0], &_Peaks._Level[0] + NUM_BANDS, 0.0f);
+            if (vNew > 1.0f) vNew = 1.0f;
+            if (vNew < 0.0f) vNew = 0.0f;
+            _livePeaks[b] = vNew;
+            _vPeaks[b] = vNew;
+            _Peaks._Level[b] = vNew;
+            sumNorm += vNew;
         }
-#endif
-        UpdateVU((float)(sumNorm / NUM_BANDS));
+        UpdateVU(sumNorm / (float)NUM_BANDS);
         return _Peaks;
     }
 
@@ -794,8 +829,10 @@ class SoundAnalyzer : public ISoundAnalyzer
         _vReal = (float *)PreferPSRAMAlloc(MAX_SAMPLES * sizeof(_vReal[0]));
         _vImaginary = (float *)PreferPSRAMAlloc(MAX_SAMPLES * sizeof(_vImaginary[0]));
         _vPeaks = (float *)PreferPSRAMAlloc(NUM_BANDS * sizeof(_vPeaks[0]));
-        if (!_vReal || !_vImaginary || !_vPeaks)
+        _livePeaks = (float *)PreferPSRAMAlloc(NUM_BANDS * sizeof(_livePeaks[0]));
+        if (!_vReal || !_vImaginary || !_vPeaks || !_livePeaks)
             throw std::runtime_error("Failed to allocate FFT buffers");
+        for (int i = 0; i < NUM_BANDS; ++i) _livePeaks[i] = 0.0f;
         _oldVU = _oldPeakVU = _oldMinVU = 0.0f;
         _MicMode = PeakData::MESMERIZERMIC;
         _params = ParamsFor(_MicMode);
@@ -812,6 +849,7 @@ class SoundAnalyzer : public ISoundAnalyzer
         free(_vReal);
         free(_vImaginary);
         free(_vPeaks);
+        free(_livePeaks);
     }
 
     // These functions allow access to the last-acquired sample buffer and its size so that

site/vite.config.mjs

@@ -27,7 +27,7 @@ export default defineConfig({
         }),
         viteCompression({
             deleteOriginFile: true,
-            filter: '/\.(js|mjs|json|css|html|ico)$/i'
+            filter: /\.(js|mjs|json|css|html|ico)$/i
         })
     ],
     server: {

src/effects.cpp

@@ -179,9 +179,20 @@ void LoadEffectFactories()
     // Include custom effects header if available - it overrides whatever the effect set flags
     // would otherwise include.
     //
-    // ONLY one of these may be defined at a time
+    // REVIEW (davepl) This allows the user to define custom effects
+    // in a separate file, which is included here. This way, the user can add custom effects
+    // without having to modify the main effect factories code, which is useful for projects that
+    // are shared across multiple boards and/or projects.  But it replaces ALL effects.  If we
+    // want to allow custom effects to be added to the existing set, we need to change this
+    // not to have an else case after but rather an endif.
+
+    // REVIEW (davepl) If someone were to define multiple effects sets, it would overwrite the
+    // value of EFFECT_SET_VERSION differently for each set, which is not what we want.
+    //
+
 
     #if __has_include ("custom_effects.h")
+
       #include "custom_effects.h"
 
     // Fill effect factories using new effect set flags