processSample()

void fl::audio::Reactive::processSample

(

const Sample &

sample

)

Definition at line 164 of file audio_reactive.cpp.hpp.

                                                              {
    if (!sample.isValid()) {
        return; // Invalid sample, ignore
    }
 
    // Extract timestamp from the Sample
    fl::u32 currentTimeMs = sample.timestamp();
 
    // Phase 1: Signal conditioning pipeline
    Sample processedSample = sample;
 
    // Step 1: Signal conditioning (DC removal, spike filtering, noise gate)
    if (mConfig.enableSignalConditioning) {
        processedSample = mSignalConditioner.processSample(processedSample);
        if (!processedSample.isValid()) {
            return; // Signal was completely filtered out
        }
    }
 
    // Step 2: Noise floor tracking (update tracker, but don't modify signal)
    if (mConfig.enableNoiseFloorTracking) {
        float rms = processedSample.rms();
        mNoiseFloorTracker.update(rms);
    }
 
    // Set conditioned sample on shared Context (clears per-frame FFT cache)
    mContext->setSample(processedSample);
 
    // Populate silence flag after setSample() resets it — detectors run via
    // updateFromContext() below and will read context->isSilent().
    //
    // Uses an absolute RMS threshold (not the adaptive noise floor). The
    // adaptive floor's first-sample init matches the current level, which
    // causes isAboveFloor() to be stuck at false for any steady signal —
    // wrongly flagging loud constant tones as silent. Absolute RMS is the
    // right primitive for "no signal present": a steady loud tone has
    // large RMS and is not silent regardless of noise-floor adaptation.
    if (mConfig.enableNoiseFloorTracking) {
        constexpr float kSilenceRmsThreshold = 10.0f;
        mContext->setSilent(processedSample.rms() < kSilenceRmsThreshold);
    }
 
    // Process the conditioned Sample - timing is gated by sample availability
    processFFT(processedSample);
 
    // Update internal Processor BEFORE populating Data fields,
    // so updateVolumeAndPeak() can source normalized volume.
    ensureAudioProcessor();
    mAudioProcessor->updateFromContext(mContext);
 
    updateVolumeAndPeak(processedSample);
 
    // Enhanced processing pipeline
    applySpectralEqualization();
    calculateBandEnergies();
 
    // Apply pink noise compensation AFTER band energy calculation
    // so that bassEnergy/midEnergy/trebleEnergy reflect actual spectral content
    if (mPinkNoiseComputed) {
        for (int i = 0; i < 16; ++i) {
            mCurrentData.frequencyBins[i] *= mPinkNoiseGains[i];
        }
    }
 
    // Apply A-weighting BEFORE spectral flux and beat detection so that
    // high-frequency attenuation is visible to onset/beat algorithms.
    // Previously this ran after beat detection, causing bin 15 to appear
    // disproportionately active (boosted by pink noise but not yet attenuated).
    applyAWeighting();
 
    updateSpectralFlux();
 
    // Silence gate for spectral metrics (FastLED#2253).
    // During audio the envelopes are pass-through; during silence they
    // exponentially decay (tau=0.2s) the raw argmax / flux outputs toward
    // zero so the FFT noise floor cannot lock onto arbitrary bins.
    // dt is the exact audio duration of this PCM buffer (frame-rate
    // independent). When enableNoiseFloorTracking is false, isSilent()
    // is always false, making this a strict pass-through (no behavior
    // change for users who haven't opted in).
    {
        const bool silent = mContext->isSilent();
        const float dt = computeAudioDt(processedSample.pcm().size(),
                                        mConfig.sampleRate);
        mCurrentData.dominantFrequency = mDominantFrequencyEnvelope.update(
            silent, mCurrentData.dominantFrequency, dt);
        mCurrentData.magnitude = mMagnitudeEnvelope.update(
            silent, mCurrentData.magnitude, dt);
        mCurrentData.spectralFlux = mSpectralFluxEnvelope.update(
            silent, mCurrentData.spectralFlux, dt);
    }
 
    // Enhanced beat detection (includes original)
    detectBeat(currentTimeMs);
    detectEnhancedBeats(currentTimeMs);
 
    // Loudness compensation stays after beat detection — it is a global
    // level adjustment that should not affect relative frequency balance.
    applyLoudnessCompensation();
 
    applyGain();
    applyScaling();
    smoothResults();
 
    mCurrentData.timestamp = currentTimeMs;
 
    // Processor was already updated earlier in this method (before updateVolumeAndPeak).
}

References applyAWeighting(), applyGain(), applyLoudnessCompensation(), applyScaling(), applySpectralEqualization(), calculateBandEnergies(), fl::audio::computeAudioDt(), detectBeat(), detectEnhancedBeats(), ensureAudioProcessor(), fl::FL_NO_EXCEPT, fl::audio::Sample::isValid(), mAudioProcessor, mConfig, mContext, mCurrentData, mDominantFrequencyEnvelope, mMagnitudeEnvelope, mNoiseFloorTracker, mPinkNoiseComputed, mPinkNoiseGains, mSignalConditioner, mSpectralFluxEnvelope, fl::audio::Sample::pcm(), processFFT(), fl::audio::Sample::rms(), rms(), fl::sample(), fl::vector_basic::size(), smoothResults(), updateSpectralFlux(), and updateVolumeAndPeak().

Here is the call graph for this function: