◆ runOctaveWise()

void fl::audio::fft::Context::runOctaveWise	(	span< const i16 >	buffer,
		Bins *	out )
inlineprivate
Definition at line 694 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
            }
        }
 
        // A full-rate Blackman-Harris FFT supplies a low-gain floor wherever
        // the narrow CQ kernels leave a gap. Its low-frequency resolution is
        // coarse, so do not let it override a CQ detection within its main
        // lobe (about four FFT-bin widths).
        s.windowed.resize(N);
        s.fftOut.resize(N);
        s.rawBinsI.resize(mTotalBands);
        applyWindow(buffer.data(), mWindowBuf.data(), s.windowed.data(), N);
        fl_fft_real_forward(mFftrCfg, N, s.windowed.data(), s.fftOut.data());
        deinterleave(s.fftOut.data(), s.re.data(), s.im.data(), numRawBins);
        batchMag(s.re.data(), s.im.data(), s.mag.data(), numRawBins);
        fl::memset(s.rawBinsI.data(), 0, sizeof(u32) * mTotalBands);
        logRebinRange(s.mag.data(), N, static_cast<float>(mSampleRate), 0,
                      mTotalBands, s.rawBinsI.data(), mLogBinLut);
        // Coverage floor = 1/50 (0.02) of the full-rate FFT magnitude; a CQ
        // band at or above 20 counts as a detection. FIXED16 decides with
        // detail::coverageFloorApplies(); float modes keep float compares.
        static constexpr float kCoverageGain = 0.02f;
        s.cqSnapshot.resize(mTotalBands);
        s.coverageMaxQueue.resize(mTotalBands);
        for (int i = 0; i < mTotalBands; ++i) {
#ifdef FIXED_POINT
            // Exact: rawBins[i] was set from an integer fastMag() above.
            s.cqSnapshot[i] = static_cast<u32>(rawBins[i]);
#else
            s.cqSnapshot[i] = rawBins[i];
#endif
        }
        int head = 0;
        int tail = 0;
        int next = 0;
        for (int i = 0; i < mTotalBands; ++i) {
            while (next <= mCoverageLast[i]) {
                while (tail > head &&
                       s.cqSnapshot[s.coverageMaxQueue[tail - 1]] <=
                           s.cqSnapshot[next]) {
                    --tail;
                }
                s.coverageMaxQueue[tail++] = static_cast<u16>(next++);
            }
            while (head < tail &&
                   s.coverageMaxQueue[head] < mCoverageFirst[i]) {
                ++head;
            }
#ifdef FIXED_POINT
            // Integer form of `localCq < 20 && fft/50 > cq`; float appears
            // only when writing the Bins output.
            if (detail::coverageFloorApplies(
                    s.rawBinsI[i], s.cqSnapshot[i],
                    s.cqSnapshot[s.coverageMaxQueue[head]])) {
                rawBins[i] = static_cast<float>(s.rawBinsI[i]) * kCoverageGain;
            }
#else
            const float localCq = s.cqSnapshot[s.coverageMaxQueue[head]];
            static constexpr float kDetectedCqMagnitude = 20.0f;
            float coverage = static_cast<float>(s.rawBinsI[i]) * kCoverageGain;
            if (localCq < kDetectedCqMagnitude && coverage > rawBins[i]) {
                rawBins[i] = coverage;
            }
#endif
        }
    }
Referenced by run().
Here is the call graph for this function:
Here is the caller graph for this function: