Merge pull request #1 from OpenSauce/refactor-recorder

Create recorder.rs, spawn recorder in new thread

Author: OpenSauce

Cargo.lock

@@ -13,3 +13,4 @@ rubato = "0.16"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde_derive = "1.0"
+crossbeam = "0.8"

Cargo.toml

@@ -14,10 +14,12 @@ use std::{
 
 mod amp;
 mod processor;
+mod recorder;
 
 use amp::{Amp, AmpConfig};
 use clap::Parser;
 use processor::Processor;
+use recorder::Recorder;
 
 #[derive(Parser, Debug)]
 #[command(name = "rustortion")]
@@ -43,10 +45,6 @@ fn main() {
 
     let config = load_amp_config(&args.preset_path).expect("Failed to load preset file");
 
-    if recording {
-        std::fs::create_dir_all("./recordings").unwrap();
-    }
-
     println!(
         "🔥 Rustortion: {}",
         if recording { "🛑 Recording!" } else { "" }
@@ -57,7 +55,13 @@ fn main() {
     let sample_rate = client.sample_rate() as f32;
     let amp = Amp::new(config, sample_rate);
 
-    let (processor, writer) = Processor::new(&client, amp, recording);
+    let recorder = if recording {
+        Some(Recorder::new(sample_rate as u32, "./recordings").expect("failed to start recorder"))
+    } else {
+        None
+    };
+    let tx = recorder.as_ref().map(|r| r.sender());
+    let processor = Processor::new(&client, amp, tx);
     let process = processor.into_process_handler();
 
     let _active_client = client
@@ -66,26 +70,25 @@ fn main() {
 
     let running = Arc::new(AtomicBool::new(true));
     let r = Arc::clone(&running);
-    let writer_clone = writer.clone();
 
     ctrlc::set_handler(move || {
         println!("\nCtrl+C received, shutting down...");
 
-        if let Some(writer_arc) = &writer_clone {
-            if let Ok(mut maybe_writer) = writer_arc.lock() {
-                if let Some(writer) = maybe_writer.take() {
-                    writer.finalize().expect("Failed to finalize WAV file");
-                }
-            }
-        }
-
         r.store(false, Ordering::SeqCst);
     })
     .expect("Error setting Ctrl+C handler");
 
     while running.load(Ordering::SeqCst) {
         thread::sleep(Duration::from_secs(1));
     }
+
+    _active_client
+        .deactivate()
+        .expect("Failed to deactivate JACK client");
+
+    if let Some(rec) = recorder {
+        rec.stop(); // join disk thread
+    }
 }
 
 fn load_amp_config(path: &str) -> std::io::Result<AmpConfig> {

src/main.rs

@@ -1,18 +1,14 @@
 use crate::amp::Amp;
-use hound::WavWriter;
+use crate::recorder::{AudioBlock, BLOCK_FRAMES};
+use crossbeam::channel::Sender;
 use jack::{AudioIn, AudioOut, Client, Control, Port, ProcessScope};
 use rubato::{
     Resampler, SincFixedIn, SincInterpolationParameters, SincInterpolationType, WindowFunction,
 };
-use std::fs::File;
-use std::io::BufWriter;
-use std::sync::{Arc, Mutex};
-
-pub type RecordingWriter = Option<Arc<Mutex<Option<WavWriter<BufWriter<File>>>>>>;
 
 pub struct Processor {
     amp: Amp,
-    writer: RecordingWriter,
+    tx: Option<Sender<AudioBlock>>,
     in_port: Port<AudioIn>,
     out_l: Port<AudioOut>,
     out_r: Port<AudioOut>,
@@ -21,7 +17,7 @@ pub struct Processor {
 }
 
 impl Processor {
-    pub fn new(client: &Client, amp: Amp, recording: bool) -> (Self, RecordingWriter) {
+    pub fn new(client: &Client, amp: Amp, tx: Option<Sender<AudioBlock>>) -> Self {
         let in_port = client.register_port("in", AudioIn).unwrap();
         let out_l = client.register_port("out_l", AudioOut).unwrap();
         let out_r = client.register_port("out_r", AudioOut).unwrap();
@@ -30,26 +26,6 @@ impl Processor {
         let _ = client.connect_ports_by_name("rustortion:out_l", "system:playback_1");
         let _ = client.connect_ports_by_name("rustortion:out_r", "system:playback_2");
 
-        let sample_rate = client.sample_rate() as f32;
-
-        let writer = if recording {
-            let spec = hound::WavSpec {
-                channels: 2,
-                sample_rate: sample_rate as u32,
-                bits_per_sample: 16,
-                sample_format: hound::SampleFormat::Int,
-            };
-            let filename = format!(
-                "./recordings/recording_{}.wav",
-                chrono::Local::now().format("%Y%m%d_%H%M%S")
-            );
-            println!("Recording to: {}", filename);
-            let writer = hound::WavWriter::create(filename, spec).unwrap();
-            Some(Arc::new(Mutex::new(Some(writer))))
-        } else {
-            None
-        };
-
         let channels = 1;
         let oversample_factor: f32 = 2.0;
 
@@ -88,26 +64,23 @@ impl Processor {
         )
         .unwrap();
 
-        (
-            Self {
-                amp,
-                writer: writer.clone(),
-                in_port,
-                out_l,
-                out_r,
-                upsampler,
-                downsampler,
-            },
-            writer,
-        )
+        Self {
+            amp,
+            tx,
+            in_port,
+            out_l,
+            out_r,
+            upsampler,
+            downsampler,
+        }
     }
 
     pub fn into_process_handler(
         self,
     ) -> impl FnMut(&Client, &ProcessScope) -> Control + Send + 'static {
         let Processor {
             mut amp,
-            writer,
+            tx,
             in_port,
             mut out_l,
             mut out_r,
@@ -167,15 +140,13 @@ impl Processor {
                 out_buf_r[i] = out_sample;
             }
 
-            if let Some(mut writer_mutex) = writer.as_ref().map(|w| w.lock().unwrap()) {
-                if let Some(ref mut writer) = *writer_mutex {
-                    for &s in final_samples.iter().take(frames_to_copy) {
-                        let sample_i16 =
-                            (s * i16::MAX as f32).clamp(i16::MIN as f32, i16::MAX as f32) as i16;
-                        writer.write_sample(sample_i16).unwrap(); // left
-                        writer.write_sample(sample_i16).unwrap(); // right
-                    }
+            if let Some(ref tx) = tx {
+                let mut block = AudioBlock::with_capacity(BLOCK_FRAMES * 2);
+                for &s in final_samples.iter().take(BLOCK_FRAMES) {
+                    let v = (s * i16::MAX as f32).clamp(i16::MIN as f32, i16::MAX as f32) as i16;
+                    block.extend_from_slice(&[v, v]);
                 }
+                let _ = tx.try_send(block); // never blocks
             }
 
             Control::Continue

src/processor.rs

@@ -0,0 +1,57 @@
+use crossbeam::channel::{Receiver, Sender, bounded};
+use hound::WavWriter;
+use std::{fs, thread};
+
+/// One block = inter‑leaved stereo samples (L R L R …).
+pub type AudioBlock = Vec<i16>;
+pub const BLOCK_FRAMES: usize = 256; // tweak latency here
+
+/// Handle returned to the caller.
+pub struct Recorder {
+    tx: Sender<AudioBlock>,
+    handle: thread::JoinHandle<()>,
+}
+
+impl Recorder {
+    pub fn new(sample_rate: u32, record_dir: &str) -> std::io::Result<Self> {
+        let (tx, rx) = bounded::<AudioBlock>(32); // 32×256 ≈ 5 s @48 kHz
+        fs::create_dir_all(record_dir)?;
+
+        let filename = format!(
+            "{record_dir}/recording_{}.wav",
+            chrono::Local::now().format("%Y%m%d_%H%M%S")
+        );
+        println!("Recording to: {filename}");
+
+        let handle = thread::spawn(move || run_writer_thread(sample_rate, filename, rx));
+
+        Ok(Self { tx, handle })
+    }
+
+    pub fn sender(&self) -> Sender<AudioBlock> {
+        self.tx.clone()
+    }
+
+    pub fn stop(self) {
+        drop(self.tx);
+        self.handle.join().expect("Unable to join thread");
+    }
+}
+
+fn run_writer_thread(sample_rate: u32, filename: String, rx: Receiver<AudioBlock>) {
+    let spec = hound::WavSpec {
+        channels: 2,
+        sample_rate,
+        bits_per_sample: 16,
+        sample_format: hound::SampleFormat::Int,
+    };
+    let mut writer = WavWriter::create(filename, spec).unwrap();
+
+    for block in rx {
+        for sample in &block {
+            writer.write_sample(*sample).unwrap();
+        }
+    }
+
+    writer.finalize().expect("Failed to finalise WAV file");
+}