gogs
/
rust-whisper
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

moved to a callback BUT costed me a global so lets iterate to someTrait

master
Bel LaPointe 2023-12-19 20:38:01 -05:00
parent 5f47b2c88b
commit 091958e08d
1 changed files with 30 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
src/main.rs
View File

@ -31,14 +31,17 @@ struct Flags {
debug: bool, debug: bool,
} }
static mut G_HANDLER: Handler = new_handler(&0.0, &0.0);
fn main() { fn main() {
let flags = Flags::parse(); let flags = Flags::parse();
let handler = Handler{ unsafe {
head: flags.stream_head, G_HANDLER.head = flags.stream_head.clone();
tail: flags.stream_tail, G_HANDLER.tail = flags.stream_tail.clone();
}; }
let w = new_whisper(flags.model, flags.threads, handler).unwrap();
let w = new_whisper(flags.model, flags.threads, new_handler(&flags.stream_head, &flags.stream_tail)).unwrap();
let stream_retain = (flags.stream_retain * 16_000.0) as usize; let stream_retain = (flags.stream_retain * 16_000.0) as usize;
let stream_step = Duration::new(flags.stream_step, 0); let stream_step = Duration::new(flags.stream_step, 0);
match flags.wav { match flags.wav {
@ -63,9 +66,11 @@ fn main() {
new_listener().listen(move |data: Vec<f32>| { new_listener().listen(move |data: Vec<f32>| {
data.iter().for_each(|x| buffer.push(*x)); data.iter().for_each(|x| buffer.push(*x));
if Instant::now() - last > stream_step { if Instant::now() - last > stream_step {
//match w.transcribe_async(&buffer) { match w.transcribe_async(&buffer, |result| {
match w.transcribe_callback(&buffer, |x| { match result {
println!("CALLBACK: {:?}", &x); Ok(whispered) => unsafe { G_HANDLER.on_success(&whispered) },
Err(msg) => unsafe { G_HANDLER.on_error(msg) },
};
}) { }) {
Ok(_) => (), Ok(_) => (),
Err(msg) => eprintln!("{}", msg), Err(msg) => eprintln!("{}", msg),
@ -124,15 +129,11 @@ impl Whisper {
recv.recv().unwrap(); recv.recv().unwrap();
} }
fn transcribe_callback(&self, data: &Vec<f32>, callback: fn(&Whispered)) -> Result<(), String> { fn transcribe_async(&self, data: &Vec<f32>, callback: fn(Result<Whispered, String>)) -> Result<(), String> {
self._transcribe_async(data, None, Some(callback)) self._transcribe_async(data, None, Some(callback))
} }
fn transcribe_async(&self, data: &Vec<f32>) -> Result<(), String> { fn _transcribe_async(&self, data: &Vec<f32>, ack: Option<std::sync::mpsc::SyncSender<bool>>, callback: Option<fn(Result<Whispered, String>)>) -> Result<(), String> {
self._transcribe_async(data, None, None)
}
fn _transcribe_async(&self, data: &Vec<f32>, ack: Option<std::sync::mpsc::SyncSender<bool>>, callback: Option<fn(&Whispered)>) -> Result<(), String> {
match self.jobs.try_send(AWhisper{ match self.jobs.try_send(AWhisper{
data: data.clone().to_vec(), data: data.clone().to_vec(),
ack: ack, ack: ack,
@ -164,16 +165,20 @@ impl WhisperEngine {
None => (), None => (),
}; };
match job.callback { match job.callback {
Some(foo) => foo(&result), Some(foo) => foo(Ok(result)),
None => (), None => (),
}; };
}, },
Err(msg) => { Err(msg) => {
self.handler.on_error(format!("failed to transcribe: {}", msg)); self.handler.on_error(format!("failed to transcribe: {}", &msg));
match job.ack { match job.ack {
Some(ack) => { let _ = ack.send(false); }, Some(ack) => { let _ = ack.send(false); },
None => (), None => (),
}; };
match job.callback {
Some(foo) => foo(Err(format!("failed to transcribe: {}", &msg))),
None => (),
};
}, },
}; };
}, },
@ -213,7 +218,7 @@ impl WhisperEngine {
struct AWhisper { struct AWhisper {
data: Vec<f32>, data: Vec<f32>,
ack: Option<std::sync::mpsc::SyncSender<bool>>, ack: Option<std::sync::mpsc::SyncSender<bool>>,
callback: Option<fn(&Whispered)>, callback: Option<fn(Result<Whispered, String>)>,
} }
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
@ -283,11 +288,19 @@ impl Whispered {
} }
} }
#[derive(Clone)]
struct Handler { struct Handler {
head: f32, head: f32,
tail: f32, tail: f32,
} }
const fn new_handler(seconds_head: &f32, seconds_tail: &f32) -> Handler {
Handler{
head: *seconds_head,
tail: *seconds_tail,
}
}
impl Handler { impl Handler {
fn on_success(&self, result: &Whispered) { fn on_success(&self, result: &Whispered) {
eprintln!("{}: {:?}", chrono::Local::now(), &result); eprintln!("{}: {:?}", chrono::Local::now(), &result);