phase_vocoder_stretch()

std::vector< double > MayaFlux::Kinesis::Discrete::phase_vocoder_stretch	(	std::span< const double >	src,
		double	stretch_factor,
		uint32_t	window_size = 2048,
		uint32_t	analysis_hop = 512
	)

Time-stretch via phase vocoder analysis-synthesis.

Produces output of length approximately src.size() * stretch_factor. Spectral envelopes and pitched content are preserved without aliasing. Sharp transients exhibit mild pre-echo at high stretch ratios (> 2×), which is inherent to the standard phase vocoder algorithm.

Recommended parameters for audio at 48 kHz: window_size = 2048, analysis_hop = 512 (75% overlap).

Parameters

src	Input samples
stretch_factor	>1 = slower/longer, <1 = faster/shorter; 1 returns copy
window_size	FFT frame size (power of 2, >= 64)
analysis_hop	Analysis hop Ha; synthesis hop Hs = Ha * stretch_factor

Returns

Time-stretched output

Definition at line 193 of file Spectral.cpp.

{
    if (src.empty() || stretch_factor <= 0.0)
        return {};
 
    if (stretch_factor == 1.0)
        return { src.begin(), src.end() };
 
    const uint32_t N = window_size;
    const uint32_t Ha = analysis_hop;
    const auto Hs = static_cast<uint32_t>(std::round(Ha * stretch_factor));
    const uint32_t bins = N / 2 + 1;
 
    const std::vector<double> win = make_hann(N);
 
    const double omega_factor = k_tau * static_cast<double>(Ha) / static_cast<double>(N);
 
    const size_t n_frames = (src.size() >= N)
        ? (src.size() - N) / Ha + 1
        : 1;
 
    const size_t out_len = static_cast<size_t>(static_cast<double>(src.size()) * stretch_factor) + N;
 
    std::vector<double> output(out_len, 0.0);
    std::vector<double> norm(out_len, 0.0);
 
    std::vector<double> phase_accum(bins, 0.0);
    std::vector<double> prev_phase(bins, 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 src_pos = f * Ha;
 
        for (uint32_t k = 0; k < N; ++k) {
            const size_t idx = src_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>> synth(bins);
        for (uint32_t b = 0; b < bins; ++b) {
            const std::complex<double> bin = spectrum(static_cast<Eigen::Index>(b));
            const double mag = std::abs(bin);
            const double phase = std::arg(bin);
 
            const double delta = phase - prev_phase[b]
                - omega_factor * static_cast<double>(b);
            const double true_f = omega_factor * static_cast<double>(b)
                + wrap_phase(delta);
 
            phase_accum[b] += static_cast<double>(Hs) * true_f
                / static_cast<double>(Ha);
            prev_phase[b] = phase;
 
            synth[b] = std::polar(mag, phase_accum[b]);
        }
 
        Eigen::VectorXcd full = to_full_spectrum(synth, N);
        fft.inv(ifft_out, full);
 
        const size_t out_pos = f * Hs;
        const double inv_N = 1.0 / static_cast<double>(N);
        for (uint32_t k = 0; k < N && out_pos + k < out_len; ++k) {
            const double w = win[k];
            output[out_pos + k] += ifft_out(static_cast<Eigen::Index>(k)) * inv_N * w;
            norm[out_pos + k] += w * w;
        }
    }
 
    for (size_t i = 0; i < out_len; ++i) {
        if (norm[i] > 1e-10)
            output[i] /= norm[i];
    }
 
    output.resize(
        static_cast<size_t>(static_cast<double>(src.size()) * stretch_factor));
 
    return output;
}

References b, and N.

Referenced by pitch_shift().

Here is the caller graph for this function: