runHybrid()

void fl::audio::fft::Context::runHybrid ( span< const i16 > buffer, Bins * out )

inlineprivate

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

                                                      {
        const int N = mInputSamples;
        const int numRawBins = N / 2 + 1;
 
        out->setParams(mFmin, mFmax, mSampleRate);
 
        // Use thread-local scratch buffers
        FftScratch &s = scratch();
        s.re.resize(numRawBins);
        s.im.resize(numRawBins);
        s.mag.resize(numRawBins);
        s.windowed.resize(N);
        s.rawBinsI.resize(mTotalBands);
 
        // Phase 1: Windowed 512pt FFT → LOG_REBIN for upper bins
        applyWindow(buffer.data(), mWindowBuf.data(), s.windowed.data(), N);
 
        fl_fft_real_forward(mFftrCfg, mInputSamples, s.windowed.data(), mFftOut.data());
 
        deinterleave(mFftOut.data(), s.re.data(), s.im.data(), numRawBins);
        batchMag(s.re.data(), s.im.data(), s.mag.data(), numRawBins);
 
        computeLinearBins(s.mag.data(), N, out);
 
        // Integer accumulation for log-rebin
        fl::memset(s.rawBinsI.data(), 0, sizeof(u32) * mTotalBands);
 
        // Upper tier: LOG_REBIN for bins [mHybridMidSplitBin, mTotalBands)
        logRebinRange(s.mag.data(), N,
                      static_cast<float>(mSampleRate),
                      mHybridMidSplitBin, mTotalBands, s.rawBinsI.data(),
                      mLogBinLut);
 
        // Decimate signal: 512 → 256 → 128 (2 steps for mid tier)
        int workLen = N;
        for (int i = 0; i < N; i++) {
            mWorkBuf[i] =
                (i < static_cast<int>(buffer.size())) ? buffer[i] : 0;
        }
        decimateBy2(mWorkBuf.data(), workLen);
        workLen /= 2;
        decimateBy2(mWorkBuf.data(), workLen);
        workLen /= 2;
 
        // Phase 2: Zero-padded 256pt FFT (128 windowed + 128 zeros) → LOG_REBIN for mid bins
        if (mHybridMidSplitBin > mHybridSplitBin && mHybridMidFft) {
            int midFftN = mHybridMidN * 2;
            int midRawBins = midFftN / 2 + 1;
            s.windowed.resize(midFftN);
            applyWindow(mWorkBuf.data(), mHybridMidWindow.data(),
                           s.windowed.data(), mHybridMidN);
            for (int i = mHybridMidN; i < midFftN; ++i) {
                s.windowed[i] = 0;
            }
            fl_fft_real_forward(mHybridMidFft, mHybridMidN * 2,
                                s.windowed.data(),
                                mHybridMidFftOut.data());
            deinterleave(mHybridMidFftOut.data(), s.re.data(), s.im.data(), midRawBins);
            batchMag(s.re.data(), s.im.data(), s.mag.data(), midRawBins);
 
            logRebinRange(s.mag.data(), midFftN,
                          mHybridMidFs,
                          mHybridSplitBin, mHybridMidSplitBin, s.rawBinsI.data(),
                          mLogBinLutMid);
        }
 
        // Decimate 1 more step: 128 → 64 (reuse unwindowed workBuf)
        decimateBy2(mWorkBuf.data(), workLen);
        workLen /= 2;
 
        // Phase 3: Windowed 64pt FFT → LOG_REBIN for bass bins
        if (mHybridSplitBin > 0 && mHybridSmallFft) {
            int bassRawBins = mHybridSmallN / 2 + 1;
            s.windowed.resize(mHybridSmallN);
            applyWindow(mWorkBuf.data(), mHybridBassWindow.data(),
                           s.windowed.data(), mHybridSmallN);
            fl_fft_real_forward(mHybridSmallFft, mHybridSmallN,
                                s.windowed.data(),
                                mHybridSmallFftOut.data());
            deinterleave(mHybridSmallFftOut.data(), s.re.data(), s.im.data(), bassRawBins);
            batchMag(s.re.data(), s.im.data(), s.mag.data(), bassRawBins);
            logRebinRange(s.mag.data(), mHybridSmallN,
                          mHybridSmallFs,
                          0, mHybridSplitBin, s.rawBinsI.data(),
                          mLogBinLutBass);
        }
 
        // Store raw magnitudes (dB computed lazily by Bins::db())
        fl::vector<float> &rawBins = out->raw_mut();
        rawBins.resize(mTotalBands);
        for (int i = 0; i < mTotalBands; ++i) {
            rawBins[i] = static_cast<float>(s.rawBinsI[i]);
        }
 
        // Use pre-computed merged norm factors (no per-frame allocation)
        out->setNormFactors(mHybridMergedNorm);
    }

References applyWindow(), batchMag(), computeLinearBins(), fl::span< T, Extent >::data(), fl::vector< T >::data(), decimateBy2(), deinterleave(), fl::audio::fft::fl_fft_real_forward(), fl::audio::fft::Context::FftScratch::im, logRebinRange(), fl::audio::fft::Context::FftScratch::mag, fl::memset(), mFftOut, mFftrCfg, mFmax, mFmin, mHybridBassWindow, mHybridMergedNorm, mHybridMidFft, mHybridMidFftOut, mHybridMidFs, mHybridMidN, mHybridMidSplitBin, mHybridMidWindow, mHybridSmallFft, mHybridSmallFftOut, mHybridSmallFs, mHybridSmallN, mHybridSplitBin, mInputSamples, mLogBinLut, mLogBinLutBass, mLogBinLutMid, mSampleRate, mTotalBands, mWindowBuf, mWorkBuf, fl::audio::fft::Bins::raw_mut(), fl::audio::fft::Context::FftScratch::rawBinsI, fl::audio::fft::Context::FftScratch::re, fl::vector< T >::resize(), scratch(), fl::audio::fft::Bins::setNormFactors(), fl::audio::fft::Bins::setParams(), fl::span< T, Extent >::size(), and fl::audio::fft::Context::FftScratch::windowed.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function: