equalizer.h

Go to the documentation of this file.

#pragma once
 
#include "fl/audio/audio_detector.h"
#include "fl/audio/spectral_equalizer.h"
#include "fl/math/filter/filter.h"
#include "fl/stl/function.h"
#include "fl/stl/span.h"
#include "fl/stl/vector.h"
#include "fl/stl/noexcept.h"
 
namespace fl {
namespace audio {
namespace detector {

enum class FFTScalingMode : u8 {
    None,         
    SquareRoot,   
    Logarithmic,  
    Linear        
};

struct EqualizerConfig {
    float minFreq = 90.0f;           
    float maxFreq = 5120.0f;         
    float smoothing = 0.05f;         
    float normAttack = 0.001f;       
    float normDecay = 4.0f;          
    float silenceThreshold = 10.0f;  

    float outputAttack = 0.0f;       
    float outputDecay = 0.0f;        

    FFTScalingMode scalingMode = FFTScalingMode::None;

    EqualizationCurve curve = EqualizationCurve::Flat;
};

struct Equalizer {
    static constexpr int kNumBins = 16;
    float bass = 0;                          
    float mid = 0;                           
    float treble = 0;                        
    float volume = 0;                        
    float zcf = 0;                           
    float volumeNormFactor = 1.0f;            
    bool isSilence = false;                  
    span<const float, kNumBins> bins;        
 
    // P2 features: peak detection and dB mapping
    float dominantFreqHz = 0.0f;             
    float dominantMagnitude = 0.0f;          
    float volumeDb = -100.0f;               
};

class EqualizerDetector : public Detector {
public:
    static constexpr int kNumBins = 16;
 
    EqualizerDetector() FL_NO_EXCEPT;
    ~EqualizerDetector() FL_NO_EXCEPT override;

    void configure(const EqualizerConfig& config) FL_NO_EXCEPT;
 
    // Detector interface
    void update(shared_ptr<Context> context) FL_NO_EXCEPT override;
    void fireCallbacks() FL_NO_EXCEPT override;
    bool needsFFT() const FL_NO_EXCEPT override { return true; }
    const char* getName() const FL_NO_EXCEPT override { return "EqualizerDetector"; }
    void reset() FL_NO_EXCEPT override;
    void setSampleRate(int rate) FL_NO_EXCEPT override { mSampleRate = rate; }
 
    // WLED-compatible getters (all return 0.0-1.0)
    float getBass() const FL_NO_EXCEPT { return mBass; }
    float getMid() const FL_NO_EXCEPT { return mMid; }
    float getTreble() const FL_NO_EXCEPT { return mTreble; }
    float getVolume() const FL_NO_EXCEPT { return mVolume; }
    float getZcf() const FL_NO_EXCEPT { return mZcf; }
    float getVolumeNormFactor() const FL_NO_EXCEPT { return mVolumeNormFactor; }
    float getAutoGain() const FL_NO_EXCEPT { return mVolumeNormFactor; }
    bool getIsSilence() const FL_NO_EXCEPT { return mIsSilence; }
    float getBin(int index) const FL_NO_EXCEPT;
    const float* getBins() const FL_NO_EXCEPT { return mBins; }

    void setMicProfile(MicProfile profile) FL_NO_EXCEPT;
 
    // Callback — single struct with everything
    function_list<void(const Equalizer&)> onEqualizer;
 
    // P2 getters
    float getDominantFreqHz() const FL_NO_EXCEPT { return mDominantFreqHz; }
    float getDominantMagnitude() const FL_NO_EXCEPT { return mDominantMagnitude; }
    float getVolumeDb() const FL_NO_EXCEPT { return mVolumeDb; }
 
private:
    EqualizerConfig mConfig;
    int mSampleRate = 44100;
    float mBins[kNumBins] = {};
    float mBass = 0, mMid = 0, mTreble = 0, mVolume = 0, mZcf = 0;
    float mVolumeNormFactor = 1.0f;
    bool mIsSilence = false;
    float mGain = 1.0f;
    float mDominantFreqHz = 0.0f;
    float mDominantMagnitude = 0.0f;
    float mVolumeDb = -100.0f;
 
    // Per-bin adaptive normalization (running max with slow decay)
    vector<AttackDecayFilter<float>> mBinMaxFilters;
    AttackDecayFilter<float> mVolumeMax{0.001f, 4.0f, 0.0f};
 
    // Smoothing for output stability — may be ExponentialSmoother or AttackDecayFilter
    // depending on whether outputAttack/outputDecay are set
    vector<ExponentialSmoother<float>> mBinSmoothers;
    vector<AttackDecayFilter<float>> mBinOutputFilters;
    bool mUseAttackDecaySmoothing = false;
 
    // Spectral equalization (optional, applied to raw bins before normalization)
    SpectralEqualizer mSpectralEq;
    float mEqBuffer[kNumBins] = {};
 
    // Microphone correction gains (applied before spectral EQ)
    float mMicGains[kNumBins] = {};
    bool mHasMicCorrection = false;
    MicProfile mCurrentMicProfile = MicProfile::None;
 
    // Pink noise spectral tilt compensation (always active)
    float mPinkNoiseGains[kNumBins] = {};
    void recomputePinkNoiseGains() FL_NO_EXCEPT;
 
    // Compute log-spaced bin center frequencies from current config
    void computeBinCenters(float* out) const FL_NO_EXCEPT;
 
    // Cached FFT from Context (shared across detector)
    shared_ptr<const fft::Bins> mRetainedFFT;
 
    // FFT windowing correction factor (WLED-MM FFT_DOWNSCALE = 0.40)
    static constexpr float kFFTDownscale = 0.40f;
};
 
} // namespace detector
} // namespace audio
} // namespace fl