listen-lib accepts device name

listen-lib/src/lib.rs

@@ -3,14 +3,68 @@ use signal_hook::{iterator::Signals, consts::signal::SIGINT};
 use std::thread;
 
 pub fn main(callback: impl FnMut(Vec<f32>)) {
-   new_listener().listen(callback);
+   new_listener(None).unwrap().listen(callback);
+}
+
+pub fn main_with(callback: impl FnMut(Vec<f32>), device_name: String) {
+   new_listener(Some(device_name)).unwrap().listen(callback);
+}
+
+pub fn devices() -> Vec<String> {
+   match _devices() {
+      Ok(devices) => devices.
+         iter().
+         map(|device| device.name()).
+         filter(|device_name| device_name.is_ok()).
+         map(|device_name| device_name.unwrap()).
+         collect(),
+      Err(_) => vec![],
+   }
+}
+
+fn _devices() -> Result<Vec<cpal::Device>, String> {
+   match cpal::default_host().devices() {
+      Ok(devices) => Ok(devices.collect()),
+      Err(msg) => Err(format!("failed to get devices: {}", msg)),
+   }
 }
 
 struct Listener {
+   device_name: String,
 }
 
-fn new_listener() -> Listener {
+fn new_listener(device_name: Option<String>) -> Result<Listener, String> {
-   Listener{}
+   let device_name = match device_name {
+      Some(device_name) => {
+         let devices: Vec<_> = _devices()?.
+            iter().
+            map(|device| device.name()).
+            filter(|device_name| device_name.is_ok()).
+            map(|device_name| device_name.unwrap()).
+            filter(|a_device_name| *a_device_name == device_name).
+            collect();
+         match devices.first() {
+            Some(_) => Ok(device_name),
+            None => Err(format!("device like {} not found", device_name)),
+         }
+      },
+      None => {
+         let host = cpal::default_host();
+         match host.default_input_device() {
+            Some(device) => {
+               match device.name() {
+                  Ok(device_name) => Ok(device_name),
+                  Err(msg) => Err(format!("failed to get default input device name: {}", msg)),
+               }
+            },
+            None => Err(format!("failed to get any input device")),
+         }
+      },
+   };
+   match device_name {
+      Ok(device_name) => Ok(Listener{device_name: device_name}),
+      Err(msg) => Err(msg),
+   }
 }
 
 impl Listener {
@@ -18,16 +72,19 @@ impl Listener {
       let (send, recv) = std::sync::mpsc::sync_channel(100);
       thread::spawn(move || { self._listen(send); });
       loop {
-         match recv.recv() {
+         match recv.recv_timeout(std::time::Duration::new(1, 0)) {
             Ok(msg) => cb(msg),
-            Err(_) => return,
+            Err(_) => break,
          };
       }
    }
 
    fn _listen(self, send: std::sync::mpsc::SyncSender<Vec<f32>>) {
-      let host = cpal::default_host();
+      let devices = _devices().unwrap();
-      let device = host.default_input_device().unwrap();
+      let devices = devices.iter().
+         filter(|device| device.name().unwrap() == self.device_name).
+         collect::<Vec<_>>();
+      let device = devices.first().unwrap();
       let cfg = device.supported_input_configs()
          .unwrap()
          .filter(|x| x.sample_format() == cpal::SampleFormat::F32)
@@ -65,7 +122,6 @@ impl Listener {
          eprintln!("sig {}", sig);
          break;
       }
-      stream.pause().unwrap();
+      let _ = stream.pause();
    }
 }
-

rust-whisper-baked/src/main.rs

@@ -26,4 +26,5 @@ fn main() {
    listen_lib::main(|data| {
       send.send(data).unwrap();
    });
+   eprintln!("/listen lib main...");
 }