From 2211232ed1e89397dfe7393d5f554ca1601c8b73 Mon Sep 17 00:00:00 2001 From: Robbert van der Helm Date: Mon, 28 Mar 2022 17:51:36 +0200 Subject: [PATCH] Use realfft for Puberty Simulator --- Cargo.lock | 2 +- plugins/puberty_simulator/Cargo.toml | 2 +- plugins/puberty_simulator/src/lib.rs | 71 +++++++++++++--------------- 3 files changed, 35 insertions(+), 40 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 5b514bc3..43985861 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2725,8 +2725,8 @@ checksum = "9145ac0af1d93c638c98c40cf7d25665f427b2a44ad0a99b1dccf3e2f25bb987" name = "puberty_simulator" version = "0.1.0" dependencies = [ - "fftw", "nih_plug", + "realfft", ] [[package]] diff --git a/plugins/puberty_simulator/Cargo.toml b/plugins/puberty_simulator/Cargo.toml index 8a9547df..58edddfc 100644 --- a/plugins/puberty_simulator/Cargo.toml +++ b/plugins/puberty_simulator/Cargo.toml @@ -11,4 +11,4 @@ crate-type = ["cdylib"] [dependencies] nih_plug = { path = "../../", features = ["assert_process_allocs"] } -fftw = "0.7" +realfft = "3.0" diff --git a/plugins/puberty_simulator/src/lib.rs b/plugins/puberty_simulator/src/lib.rs index 2f18d9c2..49a102c2 100644 --- a/plugins/puberty_simulator/src/lib.rs +++ b/plugins/puberty_simulator/src/lib.rs @@ -14,12 +14,12 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use fftw::array::AlignedVec; -use fftw::plan::{C2RPlan, C2RPlan32, R2CPlan, R2CPlan32}; -use fftw::types::{c32, Flag}; use nih_plug::prelude::*; +use realfft::num_complex::Complex32; +use realfft::{ComplexToReal, RealFftPlanner, RealToComplex}; use std::f32; use std::pin::Pin; +use std::sync::Arc; const MIN_WINDOW_ORDER: usize = 6; #[allow(dead_code)] @@ -52,21 +52,18 @@ struct PubertySimulator { /// The algorithms for the FFT and IFFT operations, for each supported order so we can switch /// between them without replanning or allocations. Initialized during `initialize()`. plan_for_order: Option<[Plan; MAX_WINDOW_ORDER - MIN_WINDOW_ORDER + 1]>, - /// Scratch buffers for computing our FFT. The [`StftHelper`] already contains a buffer for the - /// real values. This type cannot be resized, so we'll simply take a slice of it with the - /// correct length instead. - complex_fft_scratch_buffer: AlignedVec, + /// The output of our real->complex FFT. + complex_fft_buffer: Vec, } -/// FFTW uses raw pointers which aren't Send+Sync, so we'll wrap this in a separate struct. +/// A plan for a specific window size, all of which will be precomputed during initilaization. struct Plan { - r2c_plan: R2CPlan32, - c2r_plan: C2RPlan32, + /// The algorithm for the FFT operation. + r2c_plan: Arc>, + /// The algorithm for the IFFT operation. + c2r_plan: Arc>, } -unsafe impl Send for Plan {} -unsafe impl Sync for Plan {} - #[derive(Params)] struct PubertySimulatorParams { /// The pitch change in octaves. @@ -91,7 +88,7 @@ impl Default for PubertySimulator { window_function: Vec::with_capacity(MAX_WINDOW_SIZE), plan_for_order: None, - complex_fft_scratch_buffer: AlignedVec::new(MAX_WINDOW_SIZE / 2 + 1), + complex_fft_buffer: Vec::with_capacity(MAX_WINDOW_SIZE / 2 + 1), } } } @@ -168,23 +165,14 @@ impl Plugin for PubertySimulator { _buffer_config: &BufferConfig, context: &mut impl ProcessContext, ) -> bool { + // Planning with RustFFT is very fast, but it will still allocate we we'll plan all of the + // FFTs we might need in advance if self.plan_for_order.is_none() { + let mut planner = RealFftPlanner::new(); let plan_for_order: Vec = (MIN_WINDOW_ORDER..=MAX_WINDOW_ORDER) - // `Flag::MEASURE` is pretty slow above 1024 which hurts initialization time. - // `Flag::ESTIMATE` does not seem to hurt performance much at reasonable orders, so - // that's good enough for now. An alternative would be to replan on a worker thread, - // but this makes switching between window sizes a bit cleaner. .map(|order| Plan { - r2c_plan: R2CPlan32::aligned( - &[1 << order], - Flag::ESTIMATE | Flag::DESTROYINPUT, - ) - .unwrap(), - c2r_plan: C2RPlan32::aligned( - &[1 << order], - Flag::ESTIMATE | Flag::DESTROYINPUT, - ) - .unwrap(), + r2c_plan: planner.plan_fft_forward(1 << order), + c2r_plan: planner.plan_fft_inverse(1 << order), }) .collect(); self.plan_for_order = Some( @@ -227,9 +215,6 @@ impl Plugin for PubertySimulator { context.set_latency_samples(self.stft.latency_samples()); } - // Since this type cannot be resized, we'll simply slice the full buffer instead - let complex_fft_scratch_buffer = - &mut self.complex_fft_scratch_buffer.as_slice_mut()[..window_size / 2 + 1]; // These plans have already been made during initialization we can switch between versions // without reallocating let fft_plan = &mut self.plan_for_order.as_mut().unwrap() @@ -240,7 +225,7 @@ impl Plugin for PubertySimulator { buffer, &self.window_function, overlap_times, - |channel_idx, real_fft_scratch_buffer| { + |channel_idx, real_fft_buffer| { // This loop runs whenever there's a block ready, so we can't easily do any post- or // pre-processing without muddying up the interface. But if this is channel 0, then // we're dealing with a new block. We'll use this for our parameter smoothing. @@ -255,15 +240,17 @@ impl Plugin for PubertySimulator { let frequency_multiplier = 2.0f32.powf(-smoothed_pitch_value); // Forward FFT, the helper has already applied window function + // RustFFT doesn't actually need a scratch buffer here, so we'll pass an empty + // buffer instead fft_plan .r2c_plan - .r2c(real_fft_scratch_buffer, complex_fft_scratch_buffer) + .process_with_scratch(real_fft_buffer, &mut self.complex_fft_buffer, &mut []) .unwrap(); // This simply interpolates between the complex sinusoids from the frequency bins // for this bin's frequency scaled by the octave pitch multiplies. The iteration // order dependson the pitch shifting direction since we're doing it in place. - let num_bins = complex_fft_scratch_buffer.len(); + let num_bins = self.complex_fft_buffer.len(); let mut process_bin = |bin_idx| { let frequency = bin_idx as f32 / window_size as f32 * sample_rate; let target_frequency = frequency * frequency_multiplier; @@ -274,16 +261,18 @@ impl Plugin for PubertySimulator { let target_bin_high = target_bin.ceil() as usize; let target_low_t = target_bin % 1.0; let target_high_t = 1.0 - target_low_t; - let target_low = complex_fft_scratch_buffer + let target_low = self + .complex_fft_buffer .get(target_bin_low) .copied() .unwrap_or_default(); - let target_high = complex_fft_scratch_buffer + let target_high = self + .complex_fft_buffer .get(target_bin_high) .copied() .unwrap_or_default(); - complex_fft_scratch_buffer[bin_idx] = (target_low * target_low_t + self.complex_fft_buffer[bin_idx] = (target_low * target_low_t + target_high * target_high_t) * 3.0 // Random extra gain, not sure * gain_compensation; @@ -299,11 +288,15 @@ impl Plugin for PubertySimulator { } } + // Make sure the imaginary components on the first and last bin are zero + self.complex_fft_buffer[0].im = 0.0; + self.complex_fft_buffer[num_bins - 1].im = 0.0; + // Inverse FFT back into the scratch buffer. This will be added to a ring buffer // which gets written back to the host at a one block delay. fft_plan .c2r_plan - .c2r(complex_fft_scratch_buffer, real_fft_scratch_buffer) + .process_with_scratch(&mut self.complex_fft_buffer, real_fft_buffer, &mut []) .unwrap(); }, ); @@ -326,6 +319,8 @@ impl PubertySimulator { // The FFT algorithms for this window size have already been planned self.stft.set_block_size(window_size); self.window_function.resize(window_size, 0.0); + self.complex_fft_buffer + .resize(window_size / 2 + 1, Complex32::default()); util::window::hann_in_place(&mut self.window_function); } }