322 lines
8.7 KiB
Rust
322 lines
8.7 KiB
Rust
use crate::audio::node_graph::{AudioNode, NodeCategory, NodePort, Parameter, ParameterUnit, SignalType};
|
|
use crate::audio::midi::MidiEvent;
|
|
|
|
const PARAM_ROOM_SIZE: u32 = 0;
|
|
const PARAM_DAMPING: u32 = 1;
|
|
const PARAM_WET_DRY: u32 = 2;
|
|
|
|
// Schroeder reverb uses a parallel bank of comb filters followed by series all-pass filters
|
|
// Comb filter delays (in samples at 48kHz)
|
|
const COMB_DELAYS: [usize; 8] = [1557, 1617, 1491, 1422, 1277, 1356, 1188, 1116];
|
|
// All-pass filter delays (in samples at 48kHz)
|
|
const ALLPASS_DELAYS: [usize; 4] = [225, 556, 441, 341];
|
|
|
|
/// Process a single channel through comb and all-pass filters
|
|
fn process_channel(
|
|
input: f32,
|
|
comb_filters: &mut [CombFilter],
|
|
allpass_filters: &mut [AllPassFilter],
|
|
) -> f32 {
|
|
// Sum parallel comb filters and scale down to prevent excessive gain
|
|
// With 8 comb filters, we need to scale the output significantly
|
|
let mut output = 0.0;
|
|
for comb in comb_filters.iter_mut() {
|
|
output += comb.process(input);
|
|
}
|
|
output *= 0.015; // Scale down the summed comb output
|
|
|
|
// Series all-pass filters
|
|
for allpass in allpass_filters.iter_mut() {
|
|
output = allpass.process(output);
|
|
}
|
|
|
|
output
|
|
}
|
|
|
|
/// Single comb filter for reverb
|
|
struct CombFilter {
|
|
buffer: Vec<f32>,
|
|
buffer_size: usize,
|
|
filter_store: f32,
|
|
write_pos: usize,
|
|
damp: f32,
|
|
feedback: f32,
|
|
}
|
|
|
|
impl CombFilter {
|
|
fn new(size: usize) -> Self {
|
|
Self {
|
|
buffer: vec![0.0; size],
|
|
buffer_size: size,
|
|
filter_store: 0.0,
|
|
write_pos: 0,
|
|
damp: 0.5,
|
|
feedback: 0.5,
|
|
}
|
|
}
|
|
|
|
fn process(&mut self, input: f32) -> f32 {
|
|
let output = self.buffer[self.write_pos];
|
|
|
|
// One-pole lowpass filter
|
|
self.filter_store = output * (1.0 - self.damp) + self.filter_store * self.damp;
|
|
|
|
self.buffer[self.write_pos] = input + self.filter_store * self.feedback;
|
|
|
|
self.write_pos = (self.write_pos + 1) % self.buffer_size;
|
|
|
|
output
|
|
}
|
|
|
|
fn mute(&mut self) {
|
|
self.buffer.fill(0.0);
|
|
self.filter_store = 0.0;
|
|
}
|
|
|
|
fn set_damp(&mut self, val: f32) {
|
|
self.damp = val;
|
|
}
|
|
|
|
fn set_feedback(&mut self, val: f32) {
|
|
self.feedback = val;
|
|
}
|
|
}
|
|
|
|
/// Single all-pass filter for reverb
|
|
struct AllPassFilter {
|
|
buffer: Vec<f32>,
|
|
buffer_size: usize,
|
|
write_pos: usize,
|
|
}
|
|
|
|
impl AllPassFilter {
|
|
fn new(size: usize) -> Self {
|
|
Self {
|
|
buffer: vec![0.0; size],
|
|
buffer_size: size,
|
|
write_pos: 0,
|
|
}
|
|
}
|
|
|
|
fn process(&mut self, input: f32) -> f32 {
|
|
let delayed = self.buffer[self.write_pos];
|
|
let output = -input + delayed;
|
|
|
|
self.buffer[self.write_pos] = input + delayed * 0.5;
|
|
|
|
self.write_pos = (self.write_pos + 1) % self.buffer_size;
|
|
|
|
output
|
|
}
|
|
|
|
fn mute(&mut self) {
|
|
self.buffer.fill(0.0);
|
|
}
|
|
}
|
|
|
|
/// Schroeder reverb node with room size and damping controls
|
|
pub struct ReverbNode {
|
|
name: String,
|
|
room_size: f32, // 0.0 to 1.0
|
|
damping: f32, // 0.0 to 1.0
|
|
wet_dry: f32, // 0.0 = dry only, 1.0 = wet only
|
|
|
|
// Left channel filters
|
|
comb_filters_left: Vec<CombFilter>,
|
|
allpass_filters_left: Vec<AllPassFilter>,
|
|
|
|
// Right channel filters
|
|
comb_filters_right: Vec<CombFilter>,
|
|
allpass_filters_right: Vec<AllPassFilter>,
|
|
|
|
inputs: Vec<NodePort>,
|
|
outputs: Vec<NodePort>,
|
|
parameters: Vec<Parameter>,
|
|
}
|
|
|
|
impl ReverbNode {
|
|
pub fn new(name: impl Into<String>) -> Self {
|
|
let name = name.into();
|
|
|
|
let inputs = vec![
|
|
NodePort::new("Audio In", SignalType::Audio, 0),
|
|
];
|
|
|
|
let outputs = vec![
|
|
NodePort::new("Audio Out", SignalType::Audio, 0),
|
|
];
|
|
|
|
let parameters = vec![
|
|
Parameter::new(PARAM_ROOM_SIZE, "Room Size", 0.0, 1.0, 0.5, ParameterUnit::Generic),
|
|
Parameter::new(PARAM_DAMPING, "Damping", 0.0, 1.0, 0.5, ParameterUnit::Generic),
|
|
Parameter::new(PARAM_WET_DRY, "Wet/Dry", 0.0, 1.0, 0.3, ParameterUnit::Generic),
|
|
];
|
|
|
|
// Create comb filters for both channels
|
|
// Right channel has slightly different delays to create stereo effect
|
|
let comb_filters_left: Vec<CombFilter> = COMB_DELAYS.iter().map(|&d| CombFilter::new(d)).collect();
|
|
let comb_filters_right: Vec<CombFilter> = COMB_DELAYS.iter().map(|&d| CombFilter::new(d + 23)).collect();
|
|
|
|
// Create all-pass filters for both channels
|
|
let allpass_filters_left: Vec<AllPassFilter> = ALLPASS_DELAYS.iter().map(|&d| AllPassFilter::new(d)).collect();
|
|
let allpass_filters_right: Vec<AllPassFilter> = ALLPASS_DELAYS.iter().map(|&d| AllPassFilter::new(d + 23)).collect();
|
|
|
|
let mut node = Self {
|
|
name,
|
|
room_size: 0.5,
|
|
damping: 0.5,
|
|
wet_dry: 0.3,
|
|
comb_filters_left,
|
|
allpass_filters_left,
|
|
comb_filters_right,
|
|
allpass_filters_right,
|
|
inputs,
|
|
outputs,
|
|
parameters,
|
|
};
|
|
|
|
node.update_filters();
|
|
node
|
|
}
|
|
|
|
fn update_filters(&mut self) {
|
|
// Room size affects feedback (larger room = more feedback)
|
|
let feedback = 0.28 + self.room_size * 0.7;
|
|
|
|
// Update all comb filters
|
|
for comb in &mut self.comb_filters_left {
|
|
comb.set_feedback(feedback);
|
|
comb.set_damp(self.damping);
|
|
}
|
|
for comb in &mut self.comb_filters_right {
|
|
comb.set_feedback(feedback);
|
|
comb.set_damp(self.damping);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
impl AudioNode for ReverbNode {
|
|
fn category(&self) -> NodeCategory {
|
|
NodeCategory::Effect
|
|
}
|
|
|
|
fn inputs(&self) -> &[NodePort] {
|
|
&self.inputs
|
|
}
|
|
|
|
fn outputs(&self) -> &[NodePort] {
|
|
&self.outputs
|
|
}
|
|
|
|
fn parameters(&self) -> &[Parameter] {
|
|
&self.parameters
|
|
}
|
|
|
|
fn set_parameter(&mut self, id: u32, value: f32) {
|
|
match id {
|
|
PARAM_ROOM_SIZE => {
|
|
self.room_size = value.clamp(0.0, 1.0);
|
|
self.update_filters();
|
|
}
|
|
PARAM_DAMPING => {
|
|
self.damping = value.clamp(0.0, 1.0);
|
|
self.update_filters();
|
|
}
|
|
PARAM_WET_DRY => {
|
|
self.wet_dry = value.clamp(0.0, 1.0);
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
fn get_parameter(&self, id: u32) -> f32 {
|
|
match id {
|
|
PARAM_ROOM_SIZE => self.room_size,
|
|
PARAM_DAMPING => self.damping,
|
|
PARAM_WET_DRY => self.wet_dry,
|
|
_ => 0.0,
|
|
}
|
|
}
|
|
|
|
fn process(
|
|
&mut self,
|
|
inputs: &[&[f32]],
|
|
outputs: &mut [&mut [f32]],
|
|
_midi_inputs: &[&[MidiEvent]],
|
|
_midi_outputs: &mut [&mut Vec<MidiEvent>],
|
|
_sample_rate: u32,
|
|
) {
|
|
if inputs.is_empty() || outputs.is_empty() {
|
|
return;
|
|
}
|
|
|
|
let input = inputs[0];
|
|
let output = &mut outputs[0];
|
|
|
|
// Audio signals are stereo (interleaved L/R)
|
|
let frames = input.len() / 2;
|
|
let output_frames = output.len() / 2;
|
|
let frames_to_process = frames.min(output_frames);
|
|
|
|
let dry_gain = 1.0 - self.wet_dry;
|
|
let wet_gain = self.wet_dry;
|
|
|
|
for frame in 0..frames_to_process {
|
|
let left_in = input[frame * 2];
|
|
let right_in = input[frame * 2 + 1];
|
|
|
|
// Process both channels
|
|
let left_wet = process_channel(
|
|
left_in,
|
|
&mut self.comb_filters_left,
|
|
&mut self.allpass_filters_left,
|
|
);
|
|
let right_wet = process_channel(
|
|
right_in,
|
|
&mut self.comb_filters_right,
|
|
&mut self.allpass_filters_right,
|
|
);
|
|
|
|
// Mix dry and wet signals
|
|
output[frame * 2] = left_in * dry_gain + left_wet * wet_gain;
|
|
output[frame * 2 + 1] = right_in * dry_gain + right_wet * wet_gain;
|
|
}
|
|
}
|
|
|
|
fn reset(&mut self) {
|
|
for comb in &mut self.comb_filters_left {
|
|
comb.mute();
|
|
}
|
|
for comb in &mut self.comb_filters_right {
|
|
comb.mute();
|
|
}
|
|
for allpass in &mut self.allpass_filters_left {
|
|
allpass.mute();
|
|
}
|
|
for allpass in &mut self.allpass_filters_right {
|
|
allpass.mute();
|
|
}
|
|
}
|
|
|
|
fn node_type(&self) -> &str {
|
|
"Reverb"
|
|
}
|
|
|
|
fn name(&self) -> &str {
|
|
&self.name
|
|
}
|
|
|
|
fn clone_node(&self) -> Box<dyn AudioNode> {
|
|
Box::new(Self::new(self.name.clone()))
|
|
}
|
|
|
|
fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
|
|
self
|
|
}
|
|
|
|
fn as_any(&self) -> &dyn std::any::Any {
|
|
self
|
|
}
|
|
}
|