Resampling (#2)

* minor(audio::input): use qualified path with imported Sample interface references

* deps(audio::input): add rubato for resampling input

* feat(cli): add subcommand to list input devices

* feat(audio::input): automatically resample input

Whisper wants an array of f32 encoding raw PCM data at a 16K sample rate.

* refactor(whisper): remove unnecessary conversion from i16, include job metadata in output

Cargo.toml

@@ -23,3 +23,4 @@ log = "0.4.21"
 crossbeam = "0.8.4"
 serde = { version = "1.0.197", features = ["derive"] }
 serde_json = "1.0.115"
+rubato = "0.15.0"

run.sh

@@ -25,7 +25,7 @@ model_path="$2"
 # The Unix socket the program will read and write to.
 socket_path="$3"
 
-./voice \
+./voice run-daemon \
     --socket-path "$socket_path" \
     --model       "$model_path" \
     --device-name "$device_name"

src/app/mod.rs

@@ -12,16 +12,16 @@ use sttx::{IteratorExt, Timing};
 
 use crate::app::input::iter::alpha_only;
 use crate::audio::input::{controlled_recording, Recording};
-use crate::sync;
-use crate::{socket::receive_instructions, whisper, App};
+use crate::whisper::TranscriptionJob;
+use crate::{socket::receive_instructions, sync, whisper, DaemonInit};
 
 use self::command::{CmdStream, Command};
 use self::input::iter;
 use self::response::Response;
 use self::state::{Chat, Mode};
 
 pub struct Daemon {
-    app: App,
+    config: DaemonInit,
     input_device: Option<Device>,
     state: state::State,
 }
@@ -139,9 +139,9 @@ fn handle_hey_robot(content: &str) -> Option<Command> {
 }
 
 impl Daemon {
-    pub fn new(app: App, input_device: Option<Device>) -> Self {
+    pub fn new(config: DaemonInit, input_device: Option<Device>) -> Self {
         Self {
-            app,
+            config,
             input_device,
             state: state::State::default(),
         }
@@ -150,23 +150,22 @@ impl Daemon {
     /// Runs the main application loop.
     ///
     pub fn run_loop(&mut self) -> Result<bool, anyhow::Error> {
-        let model = self.app.model.clone();
+        let model = self.config.model.clone();
         let device = self
             .input_device
             .as_ref()
             .ok_or_else(|| anyhow!("No input device"))?;
 
         let (to_whisper, from_recordings) = unbounded();
-        let (whisper_output, tx_worker) =
-            whisper::transcription_worker(&model, self.app.strategy(), from_recordings)?;
+        let (whisper_output, tx_worker) = whisper::transcription_worker(&model, from_recordings)?;
 
-        let ((rcmds, scmds), resps, listener) = receive_instructions(&self.app.socket_path)?;
+        let ((rcmds, scmds), resps, listener) = receive_instructions(&self.config.socket_path)?;
         let mut commands = CmdStream::new(rcmds);
 
         #[allow(unused_assignments)]
         let mut exit_code = 0_u8;
 
-        let mut rec: Option<Recording<_, Vec<i16>>> = None;
+        let mut rec: Option<Recording<_, Vec<f32>>> = None;
 
         for result in commands.run_state_machine(&mut self.state) {
             let (ref command, ref new_state) = match result {
@@ -204,8 +203,12 @@ impl Daemon {
                     assert!(rec.is_some());
                     assert!(!new_state.running());
 
-                    let audio = rec.take().unwrap().stop()?;
-                    to_whisper.send(audio)?;
+                    let (metadata, audio) = rec.take().unwrap().stop()?;
+                    to_whisper.send(TranscriptionJob::new(
+                        audio,
+                        self.config.strategy(),
+                        metadata.sample_rate.0 as i32,
+                    ))?;
                     let now = std::time::Instant::now();
 
                     let transcription = whisper_output
@@ -276,7 +279,7 @@ impl Daemon {
         listener.join().unwrap()?;
 
         // remove socket
-        std::fs::remove_file(&self.app.socket_path)?;
+        std::fs::remove_file(&self.config.socket_path)?;
         Ok(false)
     }
 }