From 7c66f5d8561d35952ed1baf1260c216b9a4c4407 Mon Sep 17 00:00:00 2001 From: Robbert van der Helm Date: Wed, 20 Jul 2022 18:40:32 +0200 Subject: [PATCH] Add a dry-wet mixer to Spectral Compressor --- .../spectral_compressor/src/dry_wet_mixer.rs | 168 ++++++++++++++++++ plugins/spectral_compressor/src/lib.rs | 35 +++- 2 files changed, 200 insertions(+), 3 deletions(-) create mode 100644 plugins/spectral_compressor/src/dry_wet_mixer.rs diff --git a/plugins/spectral_compressor/src/dry_wet_mixer.rs b/plugins/spectral_compressor/src/dry_wet_mixer.rs new file mode 100644 index 00000000..7c16b58c --- /dev/null +++ b/plugins/spectral_compressor/src/dry_wet_mixer.rs @@ -0,0 +1,168 @@ +// Spectral Compressor: an FFT based compressor +// Copyright (C) 2021-2022 Robbert van der Helm +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +use nih_plug::prelude::Buffer; + +/// A simple dry-wet mixer with latency compensation that operates on entire buffers. +pub struct DryWetMixer { + /// The delay line for the latency compensation. This is indexed by `[channel_idx][sample_idx]`, + /// with the size set to the maximum latency plus the maximum block size rounded up to the next + /// power of two. + delay_line: Vec>, + /// The position in the inner delay line buffer where the next samples should be written from. + /// This is incremented after writing. When reading the data for mixing the dry signal back in, + /// the starting read position is determined by subtracting the buffer's length from this + /// position and then subtracting the latency. + next_write_position: usize, +} + +/// The mixing style for the [`DryWetMixer`]. +#[derive(Debug, Clone, Copy)] +#[allow(unused)] +pub enum MixingStyle { + Linear, + EqualPower, +} + +impl DryWetMixer { + /// Set up the mixer for the given parameters. + pub fn new(num_channels: usize, max_block_size: usize, max_latency: usize) -> Self { + // TODO: This could be more efficient if we don't use the entire buffer when the actual + // latency is lower than the maximum latency, but that's an optimization for later + let delay_line_len = (max_block_size + max_latency).next_power_of_two(); + + DryWetMixer { + delay_line: vec![vec![0.0; delay_line_len]; num_channels], + next_write_position: 0, + } + } + + /// Resize the itnernal buffers to fit new parameters. + pub fn resize(&mut self, num_channels: usize, max_block_size: usize, max_latency: usize) { + let delay_line_len = (max_block_size + max_latency).next_power_of_two(); + + self.delay_line.resize_with(num_channels, Vec::new); + for buffer in &mut self.delay_line { + buffer.resize(delay_line_len, 0.0); + buffer.fill(0.0); + } + self.next_write_position = 0; + } + + /// Clear out the buffers. + pub fn reset(&mut self) { + for buffer in &mut self.delay_line { + buffer.fill(0.0); + } + self.next_write_position = 0; + } + + /// Write the dry signal into the buffer. This should be called at the start of the process + /// function. + /// + /// # Panics + /// + /// Panics if the buffer is larger than the maximum block size or if the channel counts don't + /// match. + pub fn write_dry(&mut self, buffer: &Buffer) { + if buffer.channels() == 0 { + return; + } + + assert_eq!(buffer.channels(), self.delay_line.len()); + let delay_line_len = self.delay_line[0].len(); + assert!(buffer.len() <= delay_line_len); + + let num_samples_before_wrap = buffer.len().min(delay_line_len - self.next_write_position); + let num_samples_after_wrap = buffer.len() - num_samples_before_wrap; + + for (buffer_channel, delay_line) in buffer + .as_slice_immutable() + .iter() + .zip(self.delay_line.iter_mut()) + { + delay_line + [self.next_write_position..self.next_write_position + num_samples_before_wrap] + .copy_from_slice(&buffer_channel[..num_samples_before_wrap]); + delay_line[..num_samples_after_wrap] + .copy_from_slice(&buffer_channel[num_samples_before_wrap..]); + } + + self.next_write_position = (self.next_write_position + buffer.len()) % delay_line_len; + } + + /// Mix the dry signal into the buffer. The ratio is a `[0, 1]` integer where 0 results in an + /// all-dry signal, and 1 results in an all-wet signal. This should be called at the start of + /// the process function. + /// + /// # Panics + /// + /// Panics if the buffer is larger than the maximum block size, if the latency is larger than + /// the maximum latency, or if the channel counts don't match. + pub fn mix_in_dry( + &mut self, + buffer: &mut Buffer, + ratio: f32, + style: MixingStyle, + latency: usize, + ) { + if buffer.channels() == 0 { + return; + } + + let ratio = ratio.clamp(0.0, 1.0); + if ratio == 1.0 { + return; + } + let (wet_t, dry_t) = match style { + MixingStyle::Linear => (ratio, 1.0 - ratio), + MixingStyle::EqualPower => (ratio.sqrt(), (1.0 - ratio).sqrt()), + }; + + assert_eq!(buffer.channels(), self.delay_line.len()); + let delay_line_len = self.delay_line[0].len(); + assert!(buffer.len() + latency <= delay_line_len); + + let read_position = + (self.next_write_position + delay_line_len - buffer.len() - latency) % delay_line_len; + let num_samples_before_wrap = buffer.len().min(delay_line_len - read_position); + let num_samples_after_wrap = buffer.len() - num_samples_before_wrap; + + for (buffer_channel, delay_line) in buffer.as_slice().iter_mut().zip(self.delay_line.iter()) + { + if ratio == 0.0 { + buffer_channel[..num_samples_before_wrap].copy_from_slice( + &delay_line[read_position..read_position + num_samples_before_wrap], + ); + buffer_channel[num_samples_before_wrap..] + .copy_from_slice(&delay_line[..num_samples_after_wrap]); + } else { + for (buffer_sample, delay_sample) in buffer_channel[..num_samples_before_wrap] + .iter_mut() + .zip(&delay_line[read_position..read_position + num_samples_before_wrap]) + { + *buffer_sample = (*buffer_sample * wet_t) + (delay_sample * dry_t); + } + for (buffer_sample, delay_sample) in buffer_channel[num_samples_before_wrap..] + .iter_mut() + .zip(&delay_line[..num_samples_after_wrap]) + { + *buffer_sample = (*buffer_sample * wet_t) + (delay_sample * dry_t); + } + } + } + } +} diff --git a/plugins/spectral_compressor/src/lib.rs b/plugins/spectral_compressor/src/lib.rs index d67b7877..93d66f87 100644 --- a/plugins/spectral_compressor/src/lib.rs +++ b/plugins/spectral_compressor/src/lib.rs @@ -20,6 +20,7 @@ use realfft::num_complex::Complex32; use realfft::{ComplexToReal, RealFftPlanner, RealToComplex}; use std::sync::Arc; +mod dry_wet_mixer; mod editor; const MIN_WINDOW_ORDER: usize = 6; @@ -51,6 +52,8 @@ struct SpectralCompressor { /// Contains a Hann window function of the current window length, passed to the overlap-add /// helper. Allocated with a `MAX_WINDOW_SIZE` initial capacity. window_function: Vec, + /// A mixer to mix the dry signal back into the processed signal with latency compensation. + dry_wet_mixer: dry_wet_mixer::DryWetMixer, /// 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()`. @@ -96,9 +99,10 @@ impl Default for SpectralCompressor { params: Arc::new(SpectralCompressorParams::default()), editor_state: editor::default_state(), - // These two will be set to the correct values in the initialize function + // These three will be set to the correct values in the initialize function stft: util::StftHelper::new(Self::DEFAULT_NUM_OUTPUTS as usize, MAX_WINDOW_SIZE, 0), window_function: Vec::with_capacity(MAX_WINDOW_SIZE), + dry_wet_mixer: dry_wet_mixer::DryWetMixer::new(0, 0, 0), // This is initialized later since we don't want to do non-trivial computations before // the plugin is initialized @@ -136,6 +140,7 @@ impl Default for SpectralCompressorParams { auto_makeup_gain: BoolParam::new("Auto Makeup Gain", true), dry_wet_ratio: FloatParam::new("Mix", 1.0, FloatRange::Linear { min: 0.0, max: 1.0 }) .with_unit("%") + .with_smoother(SmoothingStyle::Linear(15.0)) .with_value_to_string(formatters::v2s_f32_percentage(0)) .with_string_to_value(formatters::s2v_f32_percentage()), dc_filter: BoolParam::new("DC Filter", true), @@ -172,7 +177,7 @@ impl Plugin for SpectralCompressor { fn initialize( &mut self, bus_config: &BusConfig, - _buffer_config: &BufferConfig, + buffer_config: &BufferConfig, context: &mut impl InitContext, ) -> bool { // This plugin can accept any number of channels, so we need to resize channel-dependent @@ -181,6 +186,12 @@ impl Plugin for SpectralCompressor { self.stft = util::StftHelper::new(self.stft.num_channels(), MAX_WINDOW_SIZE, 0); } + self.dry_wet_mixer.resize( + bus_config.num_output_channels as usize, + buffer_config.max_buffer_size as usize, + MAX_WINDOW_SIZE, + ); + // 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() { @@ -206,6 +217,10 @@ impl Plugin for SpectralCompressor { true } + fn reset(&mut self) { + self.dry_wet_mixer.reset(); + } + fn process( &mut self, buffer: &mut Buffer, @@ -244,7 +259,10 @@ impl Plugin for SpectralCompressor { util::db_to_gain(self.params.input_gain_db.value) * gain_compensation.sqrt(); let output_gain = util::db_to_gain(self.params.output_gain_db.value) * gain_compensation.sqrt(); - // TODO: Mix in the dry signal + // TODO: Auto makeup gain + + // This is mixed in later with latency compensation applied + self.dry_wet_mixer.write_dry(buffer); self.stft .process_overlap_add(buffer, overlap_times, |_channel_idx, real_fft_buffer| { @@ -291,6 +309,17 @@ impl Plugin for SpectralCompressor { } }); + self.dry_wet_mixer.mix_in_dry( + buffer, + self.params + .dry_wet_ratio + .smoothed + .next_step(buffer.len() as u32), + // The dry and wet signals are in phase, so we can do a linear mix + dry_wet_mixer::MixingStyle::Linear, + self.stft.latency_samples() as usize, + ); + ProcessStatus::Normal } }