runOctaveWise()

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

inlineprivate

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

                                                          {
        const int N = mInputSamples;
        const int numOctaves = static_cast<int>(mOctaves.size());
        const int numRawBins = N / 2 + 1;
 
        out->setParams(mFmin, mFmax, mSampleRate);
 
        // Copy input to working buffer
        int workLen = N;
        for (int i = 0; i < N; i++) {
            mWorkBuf[i] =
                (i < static_cast<int>(buffer.size())) ? buffer[i] : 0;
        }
 
        // FFT at full sample rate (for linear bins + top octave CQ)
        fl_fft_real_forward(mFftrCfg, mInputSamples, mWorkBuf.data(), mFftOut.data());
 
        // Deinterleave AoS → SoA and batch-compute magnitudes
        FftScratch &s = scratch();
        s.re.resize(numRawBins);
        s.im.resize(numRawBins);
        s.mag.resize(numRawBins);
        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);
 
        // Prepare CQ output bins
        fl::vector<float> &rawBins = out->raw_mut();
        rawBins.resize(mTotalBands);
        for (int i = 0; i < mTotalBands; i++) {
            rawBins[i] = 0.0f;
        }
 
        // Pre-allocate CQ accumulator once (avoids alloca in loop)
        FASTLED_STACK_ARRAY(kiss_fft_cpx, cq, mMaxBinsPerOctave);
 
        // Process octaves from top (highest freq) to bottom (lowest freq).
        // Top octave uses the FFT already computed above.
        // Each lower octave: decimate signal by 2x, then FFT + CQ.
        for (int oct = numOctaves - 1; oct >= 0; oct--) {
            const OctaveInfo &oi = mOctaves[oct];
            if (oi.numBins <= 0 || !oi.kernels)
                continue;
 
            if (oct != numOctaves - 1) {
                decimateBy2(mWorkBuf.data(), workLen);
                workLen = workLen / 2;
                // Zero-pad remainder so FFT sees clean input
                for (int i = workLen; i < N; i++)
                    mWorkBuf[i] = 0;
                fl_fft_real_forward(mFftrCfg, mInputSamples, mWorkBuf.data(), mFftOut.data());
            }
 
            // Zero the CQ accumulator and apply kernels
            fl::memset(cq, 0, sizeof(kiss_fft_cpx) * oi.numBins);
            apply_kernels(mFftOut.data(), cq, oi.kernels, oi.cfg);
 
            for (int i = 0; i < oi.numBins; i++) {
                int binIdx = oi.firstBin + i;
                i32 real = cq[i].r;
                i32 imag = cq[i].i;
#ifdef FIXED_POINT
                rawBins[binIdx] = static_cast<float>(fastMag(real, imag));
#else
                float r2 = float(real * real);
                float i2 = float(imag * imag);
                rawBins[binIdx] = sqrt(r2 + i2);
#endif
            }
        }
    }

References apply_kernels(), batchMag(), fl::audio::fft::Context::OctaveInfo::cfg, computeLinearBins(), fl::vector< T >::data(), decimateBy2(), deinterleave(), FASTLED_STACK_ARRAY, fastMag(), fl::audio::fft::Context::OctaveInfo::firstBin, fl::audio::fft::fl_fft_real_forward(), fl::audio::fft::Context::FftScratch::im, fl::audio::fft::Context::OctaveInfo::kernels, fl::audio::fft::Context::FftScratch::mag, fl::memset(), mFftOut, mFftrCfg, mFmax, mFmin, mInputSamples, mMaxBinsPerOctave, mOctaves, mSampleRate, mTotalBands, mWorkBuf, fl::audio::fft::Context::OctaveInfo::numBins, fl::oct, fl::audio::fft::Bins::raw_mut(), fl::audio::fft::Context::FftScratch::re, fl::vector< T >::resize(), scratch(), fl::audio::fft::Bins::setParams(), fl::span< T, Extent >::size(), and fl::sqrt().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function: