initOctaveWise()

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

inlineprivate

Definition at line 573 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);
        // 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, buildLinearBinLut(), fl::audio::fft::Context::OctaveInfo::cfg, fl::expf(), FASTLED_STACK_ARRAY, fl::audio::fft::Context::OctaveInfo::firstBin, FL_FFT_MIN_VAL, fl::floorf(), cq_kernel_cfg::fmax, cq_kernel_cfg::fmin, cq_kernel_cfg::fs, generate_kernels(), fl::audio::fft::Context::OctaveInfo::kernels, fl::log2f(), fl::logf(), fl::memset(), mFftOut, cq_kernel_cfg::min_val, mLinearBinLut, mMaxBinsPerOctave, mOctaves, 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: