apply_spectral()

std::vector< double > MayaFlux::Kinesis::Discrete::apply_spectral	(	std::span< const double >	src,
		uint32_t	window_size,
		uint32_t	hop_size,
		const SpectrumProcessor &	processor
	)

Apply a per-frame spectrum processor via WOLA analysis-synthesis.

Frames the input with a Hann window, calls processor on each frame's one-sided spectrum, reconstructs via IFFT, and accumulates with WOLA normalisation. Output length equals input length.

Parameters

src	Input samples
window_size	FFT frame size (power of 2, >= 64)
hop_size	Hop between analysis frames
processor	Per-frame spectrum callback

Returns

Processed output, same length as src

Definition at line 59 of file Spectral.cpp.

{
    if (src.empty())
        return {};
 
    const uint32_t N = window_size;
    const uint32_t bins = N / 2 + 1;
    const std::vector<double> win = make_hann(N);
 
    const size_t n_frames = (src.size() >= N)
        ? (src.size() - N) / hop_size + 1
        : 1;
 
    std::vector<double> output(src.size(), 0.0);
    std::vector<double> norm(src.size(), 0.0);
 
    Eigen::FFT<double> fft;
    Eigen::VectorXd frame(N);
    Eigen::VectorXcd spectrum;
    Eigen::VectorXd ifft_out;
 
    for (size_t f = 0; f < n_frames; ++f) {
        const size_t pos = f * hop_size;
 
        for (uint32_t k = 0; k < N; ++k) {
            const size_t idx = pos + k;
            frame(static_cast<Eigen::Index>(k)) = (idx < src.size()) ? src[idx] * win[k] : 0.0;
        }
 
        fft.fwd(spectrum, frame);
 
        std::vector<std::complex<double>> onesided(bins);
        for (uint32_t b = 0; b < bins; ++b)
            onesided[b] = spectrum(static_cast<Eigen::Index>(b));
 
        processor(onesided, f);
 
        Eigen::VectorXcd full = to_full_spectrum(onesided, N);
        fft.inv(ifft_out, full);
 
        const double inv_N = 1.0 / static_cast<double>(N);
        for (uint32_t k = 0; k < N && pos + k < src.size(); ++k) {
            const double w = win[k];
            output[pos + k] += ifft_out(static_cast<Eigen::Index>(k)) * inv_N * w;
            norm[pos + k] += w * w;
        }
    }
 
    for (size_t i = 0; i < src.size(); ++i) {
        if (norm[i] > 1e-10)
            output[i] /= norm[i];
    }
 
    return output;
}

References b, and N.

Referenced by harmonic_enhance(), spectral_filter(), spectral_gate(), and spectral_invert().

Here is the caller graph for this function: