initHybrid()

void fl::audio::fft::Context::initHybrid ( int samples, int bands, float fmin, float fmax, int sr )

inlineprivate

Definition at line 742 of file fft_impl.cpp.hpp.

                                                                            {
        float logRatio = logf(fmax / fmin);
 
        // Log-spaced center frequencies for all bins
        FASTLED_STACK_ARRAY(float, centerFreqs, bands);
        for (int i = 0; i < bands; i++) {
            centerFreqs[i] =
                fmin * expf(logRatio * static_cast<float>(i) /
                            static_cast<float>(bands - 1));
        }
 
        // 3-tier split at octave boundaries:
        //   bass/mid  at fmin*4 (~698 Hz, 2 octaves above fmin)
        //   mid/upper at fmin*8 (~1397 Hz, 3 octaves above fmin)
        float bassMidFreq = fmin * 4.0f;
        float midUpperFreq = fmin * 8.0f;
 
        // Clamp splits to valid range
        if (midUpperFreq >= fmax) midUpperFreq = fmax * 0.5f;
        if (bassMidFreq >= midUpperFreq) bassMidFreq = midUpperFreq * 0.5f;
 
        // Find split bin indices
        mHybridSplitBin = 0;
        for (int i = 0; i < bands; i++) {
            if (centerFreqs[i] < bassMidFreq)
                mHybridSplitBin = i + 1;
        }
        mHybridMidSplitBin = mHybridSplitBin;
        for (int i = mHybridSplitBin; i < bands; i++) {
            if (centerFreqs[i] < midUpperFreq)
                mHybridMidSplitBin = i + 1;
        }
 
        // Ensure each tier has at least 1 bin
        if (mHybridSplitBin < 1) mHybridSplitBin = 1;
        if (mHybridMidSplitBin <= mHybridSplitBin)
            mHybridMidSplitBin = mHybridSplitBin + 1;
        if (mHybridMidSplitBin >= bands)
            mHybridMidSplitBin = bands - 1;
 
        // LOG_REBIN bin edges (shared by all three tiers)
        mLogBinEdges.resize(bands + 1);
        if (bands <= 1) {
            mLogBinEdges[0] = fmin;
            mLogBinEdges[1] = fmax;
        } else {
            float denom = 2.0f * static_cast<float>(bands - 1);
            mLogBinEdges[0] = fmin * expf(-logRatio / denom);
            for (int i = 1; i < bands; i++) {
                mLogBinEdges[i] =
                    fmin * expf(logRatio *
                                (2.0f * static_cast<float>(i) - 1.0f) / denom);
            }
            mLogBinEdges[bands] = fmax * expf(logRatio / denom);
        }
 
        // Clamp top bin edge to Nyquist
        float nyquist = static_cast<float>(sr) / 2.0f;
        if (mLogBinEdges[bands] > nyquist) {
            mLogBinEdges[bands] = nyquist;
        }
 
        computeBinEdgesQ16();
 
        // Window for the full-rate 512pt FFT (upper tier)
        initWindow();
 
        // Mid-tier: 2 decimation steps → samples/4 at sr/4
        // Zero-pad 2x: 128 real samples → 256pt FFT → 43 Hz bins
        mHybridMidN = samples / 4;
        mHybridMidFs = static_cast<float>(sr) / 4.0f;
        mHybridMidFft = kiss_fftr_alloc(mHybridMidN * 2, 0, nullptr, nullptr);
        mHybridMidFftOut.resize(mHybridMidN * 2);
        computeWindow(mHybridMidWindow, mHybridMidN, mWindow);
 
        // Bass-tier: 3 decimation steps → samples/8 at sr/8
        mHybridSmallN = samples / 8;
        mHybridSmallFs = static_cast<float>(sr) / 8.0f;
        mHybridSmallFft =
            kiss_fftr_alloc(mHybridSmallN, 0, nullptr, nullptr);
        mHybridSmallFftOut.resize(mHybridSmallN);
        computeWindow(mHybridBassWindow, mHybridSmallN, mWindow);
 
        // Work buffer for decimation (reused across phases)
        mWorkBuf.resize(samples);
        mFftOut.resize(samples);
 
        // Pre-computed bin mapping LUTs for each tier
        buildLogBinLut(mLogBinLut, samples,
                       static_cast<float>(sr),
                       mHybridMidSplitBin, bands);
        buildLogBinLut(mLogBinLutMid, mHybridMidN * 2,
                       mHybridMidFs,
                       mHybridSplitBin, mHybridMidSplitBin);
        buildLogBinLut(mLogBinLutBass, mHybridSmallN,
                       mHybridSmallFs,
                       0, mHybridSplitBin);
        buildLinearBinLut(mLinearBinLut, samples);
 
        // Pre-compute normalization factors for each hybrid tier
        computeLogRebinNormFactors(mHybridNormUpper, mLogBinLut,
                                   samples, static_cast<float>(sr),
                                   mHybridMidSplitBin, bands);
        computeLogRebinNormFactors(mHybridNormMid, mLogBinLutMid,
                                   mHybridMidN * 2, mHybridMidFs,
                                   mHybridSplitBin, mHybridMidSplitBin);
        computeLogRebinNormFactors(mHybridNormBass, mLogBinLutBass,
                                   mHybridSmallN, mHybridSmallFs,
                                   0, mHybridSplitBin);
 
        // Pre-compute merged norm factors (avoids per-frame allocation)
        mHybridMergedNorm.resize(bands);
        for (int i = 0; i < bands; ++i) {
            if (i >= mHybridMidSplitBin && i < static_cast<int>(mHybridNormUpper.size())) {
                mHybridMergedNorm[i] = mHybridNormUpper[i];
            } else if (i >= mHybridSplitBin && i < static_cast<int>(mHybridNormMid.size())) {
                mHybridMergedNorm[i] = mHybridNormMid[i];
            } else if (i < static_cast<int>(mHybridNormBass.size())) {
                mHybridMergedNorm[i] = mHybridNormBass[i];
            } else {
                mHybridMergedNorm[i] = 1.0f;
            }
        }
    }

References buildLinearBinLut(), buildLogBinLut(), computeBinEdgesQ16(), computeLogRebinNormFactors(), computeWindow(), fl::expf(), FASTLED_STACK_ARRAY, initWindow(), kiss_fftr_alloc(), fl::logf(), mFftOut, mHybridBassWindow, mHybridMergedNorm, mHybridMidFft, mHybridMidFftOut, mHybridMidFs, mHybridMidN, mHybridMidSplitBin, mHybridMidWindow, mHybridNormBass, mHybridNormMid, mHybridNormUpper, mHybridSmallFft, mHybridSmallFftOut, mHybridSmallFs, mHybridSmallN, mHybridSplitBin, mLinearBinLut, mLogBinEdges, mLogBinLut, mLogBinLutBass, mLogBinLutMid, mWindow, and mWorkBuf.

Referenced by Context().

Here is the call graph for this function:

Here is the caller graph for this function: