initOctaveWise()

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

inlineprivate

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

                                             {
 
 
        // Use floor so the top octave covers the remaining frequency range
        // rather than creating a tiny sliver octave with 1 bin.
        int numOctaves = static_cast<int>(floorf(log2f(fmax / fmin)));
        if (numOctaves < 1)
            numOctaves = 1;
 
        // Log-spaced center frequencies for all bins
        float logRatio = logf(fmax / fmin);
        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));
        }
 
        // Assign each bin to an octave: oct j spans [fmin*2^j, fmin*2^(j+1))
        FASTLED_STACK_ARRAY(int, binOctave, bands);
        for (int i = 0; i < bands; i++) {
            int oct =
                static_cast<int>(floorf(log2f(centerFreqs[i] / fmin)));
            if (oct < 0)
                oct = 0;
            if (oct >= numOctaves)
                oct = numOctaves - 1;
            binOctave[i] = oct;
        }
 
        // Build per-octave CQ kernel sets
        mOctaves.resize(numOctaves);
        mMaxBinsPerOctave = 0;
        for (int oct = 0; oct < numOctaves; oct++) {
            int first = -1, last = -1;
            for (int i = 0; i < bands; i++) {
                if (binOctave[i] == oct) {
                    if (first < 0)
                        first = i;
                    last = i;
                }
            }
 
            OctaveInfo &oi = mOctaves[oct];
            fl::memset(&oi.cfg, 0, sizeof(oi.cfg));
            oi.kernels = nullptr;
            if (first < 0) {
                oi.firstBin = 0;
                oi.numBins = 0;
                continue;
            }
 
            oi.firstBin = first;
            oi.numBins = last - first + 1;
            if (oi.numBins > mMaxBinsPerOctave) {
                mMaxBinsPerOctave = oi.numBins;
            }
 
            // Decimation: top octave (numOctaves-1) uses original sample rate.
            // Each lower octave halves the effective sample rate.
            int decimExp = numOctaves - 1 - oct;
            float effectiveFs =
                static_cast<float>(sr) /
                static_cast<float>(1 << decimExp);
 
            oi.cfg.samples = samples;
            oi.cfg.bands = oi.numBins;
            oi.cfg.fmin = centerFreqs[first];
            oi.cfg.fmax = (oi.numBins > 1) ? centerFreqs[last]
                                            : centerFreqs[first] * 2.0f;
            oi.cfg.fs = effectiveFs;
            oi.cfg.min_val = FL_FFT_MIN_VAL;
 
            oi.kernels = generate_kernels(oi.cfg);
        }
 
        // Pre-allocate reusable buffers
        mWorkBuf.resize(samples);
        mFftOut.resize(samples);
 
        buildLinearBinLut(mLinearBinLut, samples);
        initLogRebin();
        computeWindow(mWindowBuf, samples, Window::BLACKMAN_HARRIS);
        const float mainLobeHz = 4.0f * static_cast<float>(sr) /
                                 static_cast<float>(samples);
        // Band indices are stored as u16. `centerFreqs` above is a stack
        // array of `bands` floats, so any band count that fits a real task
        // stack is far below 65536.
        FL_ASSERT(bands <= 0xFFFF, "CQ_OCTAVE band count exceeds u16 index range");
        mCoverageFirst.resize(bands);
        mCoverageLast.resize(bands);
        int firstNearby = 0;
        int lastNearby = 0;
        for (int i = 0; i < bands; ++i) {
            while (centerFreqs[i] - centerFreqs[firstNearby] > mainLobeHz) {
                ++firstNearby;
            }
            if (lastNearby < i) lastNearby = i;
            while (lastNearby + 1 < bands &&
                   centerFreqs[lastNearby + 1] - centerFreqs[i] <= mainLobeHz) {
                ++lastNearby;
            }
            mCoverageFirst[i] = static_cast<u16>(firstNearby);
            mCoverageLast[i] = static_cast<u16>(lastNearby);
        }
        // Note: CQ kernels already apply Hamming windowing in frequency domain.
        // Adding time-domain Hanning would double-window and over-attenuate.
    }

References cq_kernel_cfg::bands, fl::audio::fft::BLACKMAN_HARRIS, buildLinearBinLut(), fl::audio::fft::Context::OctaveInfo::cfg, computeWindow(), fl::expf(), FASTLED_STACK_ARRAY, fl::audio::fft::Context::OctaveInfo::firstBin, FL_ASSERT, FL_FFT_MIN_VAL, fl::FL_NO_EXCEPT, fl::floorf(), cq_kernel_cfg::fmax, cq_kernel_cfg::fmin, cq_kernel_cfg::fs, generate_kernels(), initLogRebin(), fl::audio::fft::Context::OctaveInfo::kernels, fl::log2f(), fl::logf(), mCoverageFirst, mCoverageLast, fl::memset(), mFftOut, cq_kernel_cfg::min_val, mLinearBinLut, mMaxBinsPerOctave, mOctaves, mWindowBuf, mWorkBuf, fl::audio::fft::Context::OctaveInfo::numBins, fl::oct, and cq_kernel_cfg::samples.

Referenced by Context().

Here is the call graph for this function:

Here is the caller graph for this function: