Refactor manager and a few others

Author: OpenSauce

README.md

@@ -1,29 +1,12 @@
-# Rustortion 🎸
+# Rustortion
 
 A basic low-latency guitar amp simulator, built in Rust using JACK (via PipeWire).
 
+This is heavily under development, probably broken, so use at your own risk.
+
 ## Requirements
 
 - Linux with PipeWire (with JACK support enabled)
 - `libjack` and JACK tools installed
 - Rust: [https://rust-lang.org/tools/install](https://rust-lang.org/tools/install)
 
-## Building
-
-`cargo build --release`
-
-## Running
-
-Pass the path to the preset file as an argument:  
-`cargo run -- --preset-path presets/metal.json`
-
-Use the recording flag to save the output to a file:  
-`cargo run -- --recording`
-
-Recordings are saved in the /recordings directory with a time-stamp in the filename.
-
-## TODO
-
-- Add real distortion effects (soft/hard clipping)
-- Real-time gain control
-- Cabinet IR loading

presets/clean.json

@@ -1,17 +1,17 @@
 use crossbeam::channel::{Sender, bounded};
 use jack::{AsyncClient, Client, ClientOptions, contrib::ClosureProcessHandler};
+use log::error;
 
 use crate::io::processor::{ProcessHandler, Processor};
 use crate::io::recorder::Recorder;
 use crate::sim::chain::AmplifierChain;
 
 /// Manages the audio processing chain and JACK client
 pub struct ProcessorManager {
-    client: Option<Client>,
-    active_client: Option<AsyncClient<Notifications, ClosureProcessHandler<(), ProcessHandler>>>,
+    _active_client: AsyncClient<Notifications, ClosureProcessHandler<(), ProcessHandler>>,
     recorder: Option<Recorder>,
     /// GUI → audio thread: push a completely new preset
-    amp_tx: Option<Sender<Box<AmplifierChain>>>,
+    amp_tx: Sender<Box<AmplifierChain>>,
     sample_rate: f32,
 }
 
@@ -25,80 +25,58 @@ impl ProcessorManager {
         let (client, _status) = Client::new("rustortion", ClientOptions::NO_START_SERVER)
             .map_err(|e| format!("Failed to create JACK client: {e}"))?;
 
+        let (tx_amp, rx_amp) = bounded::<Box<AmplifierChain>>(1); // SPSC, size 1
+
+        let processor = Processor::new_with_channel(&client, rx_amp, None);
+        let handler = ClosureProcessHandler::new(processor.into_process_handler());
+
+        let sample_rate = client.sample_rate() as f32;
+
+        let _active_client = client
+            .activate_async(Notifications, handler)
+            .map_err(|e| format!("activate_async: {e}"))?;
+
         Ok(Self {
-            sample_rate: client.sample_rate() as f32,
-            client: Some(client),
-            active_client: None,
+            sample_rate,
+            _active_client,
             recorder: None,
-            amp_tx: None,
+            amp_tx: tx_amp,
         })
     }
 
     /// Push a new amplifier chain from the GUI side.
     /// Never blocks; silently drops if the buffer is full.
     pub fn set_amp_chain(&self, new_chain: AmplifierChain) {
-        if let Some(tx) = &self.amp_tx {
-            tx.try_send(Box::new(new_chain)).unwrap_or_else(|e| {
-                log::error!("Failed to send new amplifier chain: {e}");
+        self.amp_tx
+            .try_send(Box::new(new_chain))
+            .unwrap_or_else(|e| {
+                error!("Failed to send new amplifier chain: {e}");
             });
-        }
     }
 
     /// Starts recording if enabled
     pub fn enable_recording(&mut self, record_dir: &str) -> Result<(), String> {
         if self.recorder.is_some() {
-            return Ok(()); // Already recording
+            return Ok(());
         }
 
         let recorder = Recorder::new(self.sample_rate as u32, record_dir)
             .map_err(|e| format!("Failed to start recorder: {e}"))?;
+        let _ = recorder.sender();
 
         self.recorder = Some(recorder);
         Ok(())
     }
 
     /// Stops recording if active
     pub fn disable_recording(&mut self) {
-        if let Some(recorder) = self.recorder.take() {
-            recorder.stop();
-        }
-    }
-
-    /// Starts the audio processing
-    pub fn start(&mut self) -> Result<(), String> {
-        if self.active_client.is_some() {
-            return Ok(());
+        if self.recorder.is_none() {
+            return;
         }
 
-        let client = self.client.take().ok_or("Client already active")?;
-        let (tx_amp, rx_amp) = bounded::<Box<AmplifierChain>>(1); // SPSC, size 1
-
-        let tx_audio = self.recorder.as_ref().map(|r| r.sender());
-
-        // Processor owns its mutable chain and a receiver for updates
-        let processor = Processor::new_with_channel(&client, rx_amp, tx_audio);
-
-        let callback = processor.into_process_handler();
-        let handler = ClosureProcessHandler::new(callback);
-        let active = client
-            .activate_async(Notifications, handler)
-            .map_err(|e| format!("activate_async: {e}"))?;
-
-        self.amp_tx = Some(tx_amp);
-        self.active_client = Some(active);
-        Ok(())
-    }
-
-    pub fn stop(&mut self) -> Result<(), String> {
-        if let Some(active) = self.active_client.take() {
-            let (client, _n, _h) = active
-                .deactivate()
-                .map_err(|e| format!("deactivate: {e:?}"))?;
-            self.client = Some(client);
+        if let Some(recorder) = self.recorder.take() {
+            recorder.stop();
         }
-        self.disable_recording();
-        self.amp_tx = None;
-        Ok(())
     }
 
     /// Returns the sample rate
@@ -109,6 +87,6 @@ impl ProcessorManager {
 
 impl Drop for ProcessorManager {
     fn drop(&mut self) {
-        let _ = self.stop();
+        self.disable_recording();
     }
 }

presets/metal.json

@@ -33,7 +33,7 @@ fn main() -> Result<(), String> {
     let recording = args.recording;
 
     info!(
-        "🔥 Rustortion: {}",
+        "Rustortion: {}",
         if recording { "🛑 Recording!" } else { "" }
     );
 
@@ -45,15 +45,13 @@ fn main() -> Result<(), String> {
         processor_manager.enable_recording("./recordings")?;
     }
 
-    processor_manager.start()?;
-
     processor_manager.set_amp_chain(chain);
 
     let running = Arc::new(AtomicBool::new(true));
     let r = Arc::clone(&running);
 
     ctrlc::set_handler(move || {
-        info!("\nCtrl+C received, shutting down...");
+        info!("Ctrl+C received, shutting down...");
         r.store(false, Ordering::SeqCst);
     })
     .expect("Error setting Ctrl+C handler");
@@ -62,7 +60,5 @@ fn main() -> Result<(), String> {
         thread::sleep(Duration::from_secs(1));
     }
 
-    processor_manager.stop()?;
-
     Ok(())
 }