fix: move IR loading off RT thread and drain engine messages (#213) (#215)

Author: OpenSauce

benches/common/mod.rs

@@ -1,5 +1,7 @@
 use hound::{WavSpec, WavWriter};
-use rustortion::ir::cabinet::IrCabinet;
+use rustortion::ir::cabinet::{ConvolverType, DEFAULT_MAX_IR_MS, IrCabinet};
+use rustortion::ir::convolver::Convolver;
+use rustortion::ir::loader::IrLoader;
 use std::fs;
 use std::path::Path;
 
@@ -12,11 +14,18 @@ pub fn create_test_cabinet(ir_length: usize, sample_rate: usize) -> IrCabinet {
         create_synthetic_ir(&ir_path, ir_length, sample_rate as u32);
     }
 
-    let mut cabinet = IrCabinet::new(&ir_dir, sample_rate).unwrap();
-    cabinet
-        .select_ir(&format!("test_ir_{ir_length}.wav"))
+    let max_ir_samples = (sample_rate * DEFAULT_MAX_IR_MS) / 1000;
+    let mut cabinet = IrCabinet::new(ConvolverType::Fir, max_ir_samples);
+
+    let loader = IrLoader::new(&ir_dir, sample_rate).unwrap();
+    let ir_samples = loader
+        .load_by_name(&format!("test_ir_{ir_length}.wav"))
         .unwrap();
 
+    let mut convolver = Convolver::new_fir(max_ir_samples);
+    convolver.set_ir(&ir_samples).unwrap();
+    cabinet.swap_convolver(convolver);
+
     cabinet
 }
 

benches/engine.rs

@@ -8,6 +8,7 @@ use rustortion::amp::stages::level::LevelStage;
 use rustortion::audio::engine::{Engine, EngineHandle};
 use rustortion::audio::peak_meter::PeakMeter;
 use rustortion::audio::samplers::Samplers;
+use rustortion::ir::load_service::ConvolverDropHandle;
 use rustortion::metronome::Metronome;
 use rustortion::tuner::Tuner;
 
@@ -28,7 +29,15 @@ pub fn build_engine(
     let (peak_meter, _) = PeakMeter::new(SAMPLE_RATE);
     let samplers = Samplers::new(buffer_size, oversample, SAMPLE_RATE).unwrap();
     let metronome = Metronome::new(120.0, SAMPLE_RATE);
-    let (engine, handle) = Engine::new(tuner, samplers, ir_cabinet, peak_meter, metronome).unwrap();
+    let (engine, handle) = Engine::new(
+        tuner,
+        samplers,
+        ir_cabinet,
+        peak_meter,
+        metronome,
+        ConvolverDropHandle::new().0,
+    )
+    .unwrap();
     (engine, handle)
 }
 
@@ -104,8 +113,15 @@ fn bench_engine_with_ir_cabinet(c: &mut Criterion) {
                 let ir_cabinet = Some(create_test_cabinet(20000, SAMPLE_RATE));
                 let (peak_meter, _) = PeakMeter::new(SAMPLE_RATE);
                 let metronome = Metronome::new(120.0, SAMPLE_RATE);
-                let (mut engine, _) =
-                    Engine::new(tuner, samplers, ir_cabinet, peak_meter, metronome).unwrap();
+                let (mut engine, _) = Engine::new(
+                    tuner,
+                    samplers,
+                    ir_cabinet,
+                    peak_meter,
+                    metronome,
+                    ConvolverDropHandle::new().0,
+                )
+                .unwrap();
 
                 let input = vec![0.5f32; BUFFER_SIZE];
                 let mut output = vec![0.0f32; BUFFER_SIZE];

src/audio/engine.rs

@@ -9,15 +9,23 @@ use crate::audio::pitch_shifter::PitchShifter;
 use crate::audio::recorder::Recorder;
 use crate::audio::samplers::Samplers;
 use crate::ir::cabinet::IrCabinet;
+use crate::ir::convolver::Convolver;
+use crate::ir::load_service::ConvolverDropHandle;
 use crate::metronome::Metronome;
 use crate::tuner::Tuner;
 
+pub struct PreparedIr {
+    pub name: String,
+    pub convolver: Convolver,
+}
+
 pub enum EngineMessage {
     SetAmpChain(Box<AmplifierChain>),
     SetInputFilters(Option<Box<dyn Stage>>, Option<Box<dyn Stage>>),
     StartRecording(Recorder),
     StopRecording,
-    SetIrCabinet(Option<String>),
+    SwapIrConvolver(Box<PreparedIr>),
+    ClearIr,
     SetIrBypass(bool),
     SetIrGain(f32),
     SetTunerEnabled(bool),
@@ -31,6 +39,8 @@ pub struct Engine {
     ir_cabinet: Option<IrCabinet>,
     /// Channel for updating the amplifier chain.
     engine_receiver: Receiver<EngineMessage>,
+    /// Handle for sending old convolvers off the RT thread for deallocation.
+    convolver_drop: ConvolverDropHandle,
     samplers: Samplers,
     tuner: Tuner,
     recorder: Option<Recorder>,
@@ -41,6 +51,7 @@ pub struct Engine {
     input_lowpass: Option<Box<dyn Stage>>,
 }
 
+#[derive(Clone)]
 pub struct EngineHandle {
     engine_sender: Sender<EngineMessage>,
 }
@@ -52,6 +63,7 @@ impl Engine {
         ir_cabinet: Option<IrCabinet>,
         peak_meter: PeakMeter,
         metronome: Metronome,
+        convolver_drop: ConvolverDropHandle,
     ) -> Result<(Self, EngineHandle)> {
         let (engine_sender, engine_receiver) = bounded::<EngineMessage>(10);
 
@@ -60,6 +72,7 @@ impl Engine {
                 chain: Box::new(AmplifierChain::new()),
                 ir_cabinet,
                 engine_receiver,
+                convolver_drop,
                 samplers,
                 tuner,
                 recorder: None,
@@ -173,7 +186,7 @@ impl Engine {
     }
 
     pub fn handle_messages(&mut self) {
-        if let Ok(message) = self.engine_receiver.try_recv() {
+        while let Ok(message) = self.engine_receiver.try_recv() {
             match message {
                 EngineMessage::SetAmpChain(chain) => {
                     self.chain = chain;
@@ -184,15 +197,17 @@ impl Engine {
                     self.input_lowpass = lp;
                     debug!("Updated input filters");
                 }
-                EngineMessage::SetIrCabinet(ir_name) => {
-                    if let Some(ref mut cab) = self.ir_cabinet
-                        && let Some(name) = ir_name
-                    {
-                        if let Err(e) = cab.select_ir(&name) {
-                            error!("Failed to set IR: {e}");
-                        } else {
-                            debug!("IR Cabinet set to: {name}");
-                        }
+                EngineMessage::SwapIrConvolver(prepared) => {
+                    if let Some(ref mut cab) = self.ir_cabinet {
+                        debug!("IR convolver swapped: {}", prepared.name);
+                        let old = cab.swap_convolver(prepared.convolver);
+                        self.convolver_drop.retire(old);
+                    }
+                }
+                EngineMessage::ClearIr => {
+                    if let Some(ref mut cab) = self.ir_cabinet {
+                        cab.clear_convolver();
+                        debug!("IR cleared");
                     }
                 }
                 EngineMessage::SetIrBypass(bypass) => {
@@ -211,44 +226,56 @@ impl Engine {
                     self.tuner.set_enabled(enabled);
                 }
                 EngineMessage::StartRecording(recorder) => {
-                    if self.recorder.is_some() {
-                        debug!("Recorder already active, ignoring start request");
-                        return;
-                    }
-
-                    debug!("Recorder updated");
-                    self.recorder = Some(recorder);
+                    self.handle_start_recording(recorder);
                 }
                 EngineMessage::StopRecording => {
-                    if self.recorder.is_none() {
-                        debug!("No active recorder to stop");
-                        return;
-                    }
-
-                    debug!("Stopping recorder");
-                    if let Some(recorder) = self.recorder.take()
-                        && let Err(e) = recorder.stop()
-                    {
-                        error!("Failed to stop recorder: {e}");
-                    }
-
-                    self.recorder = None;
+                    self.handle_stop_recording();
                 }
                 EngineMessage::SetPitchShift(semitones) => {
-                    if semitones == 0 {
-                        self.pitch_shifter = None;
-                        debug!("Pitch shift disabled (bypass)");
-                    } else if let Some(ref mut shifter) = self.pitch_shifter {
-                        shifter.set_semitones(semitones as f32);
-                        debug!("Pitch shift set to {semitones} semitones");
-                    } else {
-                        self.pitch_shifter = Some(PitchShifter::new(semitones as f32));
-                        debug!("Pitch shift set to {semitones} semitones");
-                    }
+                    self.handle_pitch_shift(semitones);
                 }
             }
         }
     }
+
+    fn handle_start_recording(&mut self, recorder: Recorder) {
+        if self.recorder.is_some() {
+            debug!("Recorder already active, ignoring start request");
+            return;
+        }
+
+        debug!("Recorder updated");
+        self.recorder = Some(recorder);
+    }
+
+    fn handle_stop_recording(&mut self) {
+        if self.recorder.is_none() {
+            debug!("No active recorder to stop");
+            return;
+        }
+
+        debug!("Stopping recorder");
+        if let Some(recorder) = self.recorder.take()
+            && let Err(e) = recorder.stop()
+        {
+            error!("Failed to stop recorder: {e}");
+        }
+
+        self.recorder = None;
+    }
+
+    fn handle_pitch_shift(&mut self, semitones: i32) {
+        if semitones == 0 {
+            self.pitch_shifter = None;
+            debug!("Pitch shift disabled (bypass)");
+        } else if let Some(ref mut shifter) = self.pitch_shifter {
+            shifter.set_semitones(semitones as f32);
+            debug!("Pitch shift set to {semitones} semitones");
+        } else {
+            self.pitch_shifter = Some(PitchShifter::new(semitones as f32));
+            debug!("Pitch shift set to {semitones} semitones");
+        }
+    }
 }
 
 impl Drop for Engine {
@@ -269,11 +296,15 @@ impl EngineHandle {
         });
     }
 
-    pub fn set_ir_cabinet(&self, ir_name: Option<String>) {
-        let update = EngineMessage::SetIrCabinet(ir_name);
+    pub fn swap_ir_convolver(&self, prepared: PreparedIr) {
+        let update = EngineMessage::SwapIrConvolver(Box::new(prepared));
         self.send(update);
     }
 
+    pub fn clear_ir(&self) {
+        self.send(EngineMessage::ClearIr);
+    }
+
     pub fn set_ir_bypass(&self, bypass: bool) {
         let update = EngineMessage::SetIrBypass(bypass);
         self.send(update);

src/audio/manager.rs

@@ -5,15 +5,15 @@ use anyhow::{Context, Result};
 use jack::{AsyncClient, Client, ClientOptions};
 use log::{error, info, warn};
 
-use std::path::Path;
-
 use crate::amp::stages::clipper;
 use crate::audio::engine::Engine;
 use crate::audio::engine::EngineHandle;
 use crate::audio::jack::{NotificationHandler, ProcessHandler};
 use crate::audio::peak_meter::{PeakMeter, PeakMeterHandle};
 use crate::audio::samplers::Samplers;
-use crate::ir::cabinet::IrCabinet;
+use crate::ir::cabinet::{ConvolverType, DEFAULT_MAX_IR_MS, IrCabinet};
+use crate::ir::load_service::{self, ConvolverDropHandle, IrLoadHandle};
+use crate::ir::loader::IrLoader;
 use crate::metronome::Metronome;
 use crate::settings::{AudioSettings, Settings};
 use crate::tuner::{Tuner, TunerHandle};
@@ -26,6 +26,7 @@ pub struct Manager {
     peak_meter_handle: PeakMeterHandle,
     xrun_count: Arc<AtomicU64>,
     available_irs: Vec<String>,
+    ir_load_handle: Option<IrLoadHandle>,
 }
 
 impl Manager {
@@ -48,21 +49,45 @@ impl Manager {
         let mut metronome = Metronome::new(120.0, sample_rate);
         metronome.load_wav_file("click.wav");
 
-        let ir_cabinet = match IrCabinet::new(Path::new(&settings.ir_dir), sample_rate) {
-            Ok(cab) => Some(cab),
-            Err(e) => {
-                warn!("Failed to load IR Cabinet: {e}");
-                None
-            }
-        };
+        let convolver_type = ConvolverType::default();
+        let max_ir_samples = (sample_rate * DEFAULT_MAX_IR_MS) / 1000;
+
+        let (ir_loader, available_irs) =
+            match IrLoader::new(std::path::Path::new(&settings.ir_dir), sample_rate) {
+                Ok(loader) => {
+                    let names = loader.available_ir_names();
+                    (Some(loader), names)
+                }
+                Err(e) => {
+                    warn!("Failed to load IR directory: {e}");
+                    (None, Vec::new())
+                }
+            };
+
+        let ir_cabinet = Some(IrCabinet::new(convolver_type, max_ir_samples));
+
+        let (convolver_drop_handle, convolver_drop_rx) = ConvolverDropHandle::new();
+
+        let (engine, engine_handle) = Engine::new(
+            tuner,
+            samplers,
+            ir_cabinet,
+            peak_meter,
+            metronome,
+            convolver_drop_handle,
+        )?;
 
-        let available_irs = ir_cabinet
-            .as_ref()
-            .map(IrCabinet::available_ir_names)
-            .unwrap_or_default();
+        let ir_load_handle = ir_loader.map(|loader| {
+            load_service::spawn(
+                loader,
+                engine_handle.clone(),
+                sample_rate,
+                DEFAULT_MAX_IR_MS,
+                convolver_type,
+                convolver_drop_rx,
+            )
+        });
 
-        let (engine, engine_handle) =
-            Engine::new(tuner, samplers, ir_cabinet, peak_meter, metronome)?;
         let jack_handler =
             ProcessHandler::new(&client, engine).context("failed to create process handler")?;
 
@@ -81,6 +106,7 @@ impl Manager {
             peak_meter_handle,
             xrun_count,
             available_irs,
+            ir_load_handle,
         };
 
         manager.connect_ports(&settings.audio);
@@ -180,6 +206,24 @@ impl Manager {
         self.available_irs.clone()
     }
 
+    pub fn request_ir_load(&self, name: &str) {
+        if let Some(ref handle) = self.ir_load_handle {
+            handle.request_load(name);
+        }
+    }
+
+    pub fn clear_ir(&self) {
+        self.engine_handle.clear_ir();
+    }
+
+    pub fn preload_irs(&self, names: &[String]) {
+        if let Some(ref handle) = self.ir_load_handle {
+            for name in names {
+                handle.preload(name);
+            }
+        }
+    }
+
     pub fn sample_rate(&self) -> usize {
         self.active_client.as_client().sample_rate() as usize
     }