X-Git-Url: https://code.octet-stream.net/m17rt/blobdiff_plain/253c89360003ac72c4f7078c03af973c58a1b129..23b1648b69b4fa11fdff5f43d704af216c1da401:/m17app/src/soundmodem.rs diff --git a/m17app/src/soundmodem.rs b/m17app/src/soundmodem.rs index 74c176b..59b56c9 100644 --- a/m17app/src/soundmodem.rs +++ b/m17app/src/soundmodem.rs @@ -1,13 +1,10 @@ +use crate::error::{M17Error, SoundmodemError}; use crate::tnc::{Tnc, TncError}; -use cpal::traits::DeviceTrait; -use cpal::traits::HostTrait; -use cpal::traits::StreamTrait; -use cpal::{SampleFormat, SampleRate}; -use log::debug; use m17core::kiss::MAX_FRAME_LEN; use m17core::modem::{Demodulator, Modulator, ModulatorAction, SoftDemodulator, SoftModulator}; use m17core::tnc::SoftTnc; use std::collections::VecDeque; +use std::fmt::Display; use std::fs::File; use std::io::{self, ErrorKind, Read, Write}; use std::path::PathBuf; @@ -15,6 +12,7 @@ use std::sync::mpsc::{channel, sync_channel, Receiver, Sender, SyncSender, TryRe use std::sync::RwLock; use std::sync::{Arc, Mutex}; use std::time::{Duration, Instant}; +use thiserror::Error; pub struct Soundmodem { event_tx: SyncSender, @@ -23,8 +21,12 @@ pub struct Soundmodem { } impl Soundmodem { - pub fn new_with_input_and_output(input: I, output: O) -> Self { - // must create TNC here + pub fn new( + input: I, + output: O, + ptt: P, + error: E, + ) -> Self { let (event_tx, event_rx) = sync_channel(128); let (kiss_out_tx, kiss_out_rx) = sync_channel(128); spawn_soundmodem_worker( @@ -33,6 +35,8 @@ impl Soundmodem { kiss_out_tx, Box::new(input), Box::new(output), + Box::new(ptt), + Box::new(error), ); Self { event_tx, @@ -42,6 +46,114 @@ impl Soundmodem { } } +#[derive(Debug, Clone, Copy)] +pub enum ErrorSource { + Input, + Output, + Ptt, +} + +impl Display for ErrorSource { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::Input => write!(f, "Input"), + Self::Output => write!(f, "Output"), + Self::Ptt => write!(f, "PTT"), + } + } +} + +pub trait ErrorHandler: Send + Sync + 'static { + fn soundmodem_error(&mut self, source: ErrorSource, err: SoundmodemError); +} + +impl ErrorHandler for F +where + F: FnMut(ErrorSource, SoundmodemError) + Send + Sync + 'static, +{ + fn soundmodem_error(&mut self, source: ErrorSource, err: SoundmodemError) { + self(source, err) + } +} + +/// Soundmodem errors will be ignored. +pub struct NullErrorHandler; + +impl NullErrorHandler { + pub fn new() -> Self { + Self {} + } +} + +impl Default for NullErrorHandler { + fn default() -> Self { + Self::new() + } +} + +impl ErrorHandler for NullErrorHandler { + fn soundmodem_error(&mut self, source: ErrorSource, err: SoundmodemError) { + let _ = source; + let _ = err; + } +} + +/// Soundmodem errors will be logged at DEBUG level via the `log` crate. +pub struct LogErrorHandler; + +impl LogErrorHandler { + pub fn new() -> Self { + Self {} + } +} + +impl Default for LogErrorHandler { + fn default() -> Self { + Self::new() + } +} + +impl ErrorHandler for LogErrorHandler { + fn soundmodem_error(&mut self, source: ErrorSource, err: SoundmodemError) { + log::debug!("Soundmodem error: {source} - {err}"); + } +} + +/// Soundmodem errors will be logged to stdout. +pub struct StdoutErrorHandler; + +impl StdoutErrorHandler { + pub fn new() -> Self { + Self {} + } +} + +impl Default for StdoutErrorHandler { + fn default() -> Self { + Self::new() + } +} + +impl ErrorHandler for StdoutErrorHandler { + fn soundmodem_error(&mut self, source: ErrorSource, err: SoundmodemError) { + println!("Soundmodem error: {source} - {err}"); + } +} + +#[derive(Clone)] +pub struct SoundmodemErrorSender { + source: ErrorSource, + event_tx: SyncSender, +} + +impl SoundmodemErrorSender { + pub fn send_error>(&self, err: E) { + let _ = self + .event_tx + .send(SoundmodemEvent::RuntimeError(self.source, err.into())); + } +} + struct PartialKissOut { output: Arc<[u8]>, idx: usize, @@ -101,14 +213,12 @@ impl Tnc for Soundmodem { }) } - fn start(&mut self) -> Result<(), TncError> { + fn start(&mut self) { let _ = self.event_tx.send(SoundmodemEvent::Start); - Ok(()) } - fn close(&mut self) -> Result<(), TncError> { + fn close(&mut self) { let _ = self.event_tx.send(SoundmodemEvent::Close); - Ok(()) } } @@ -119,6 +229,7 @@ pub enum SoundmodemEvent { Close, DidReadFromOutputBuffer { len: usize, timestamp: Instant }, OutputUnderrun, + RuntimeError(ErrorSource, SoundmodemError), } fn spawn_soundmodem_worker( @@ -127,6 +238,8 @@ fn spawn_soundmodem_worker( kiss_out_tx: SyncSender>, input: Box, output: Box, + mut ptt_driver: Box, + mut error_handler: Box, ) { std::thread::spawn(move || { // TODO: should be able to provide a custom Demodulator for a soundmodem @@ -140,8 +253,12 @@ fn spawn_soundmodem_worker( let mut ptt = false; while let Ok(ev) = event_rx.recv() { // Update clock on TNC before we do anything - let sample_time = (start.elapsed().as_nanos() / 48000) as u64; - tnc.set_now(sample_time); + let sample_time = start.elapsed(); + let secs = sample_time.as_secs(); + let nanos = sample_time.subsec_nanos(); + // Accurate to within approx 1 sample + let now_samples = 48000 * secs + (nanos as u64 / 20833); + tnc.set_now(now_samples); // Handle event match ev { @@ -167,10 +284,25 @@ fn spawn_soundmodem_worker( tnc.set_data_carrier_detect(demodulator.data_carrier_detect()); } SoundmodemEvent::Start => { - input.start(event_tx.clone()); - output.start(event_tx.clone(), out_buffer.clone()); + let input_errors = SoundmodemErrorSender { + source: ErrorSource::Input, + event_tx: event_tx.clone(), + }; + input.start(event_tx.clone(), input_errors); + let output_errors = SoundmodemErrorSender { + source: ErrorSource::Output, + event_tx: event_tx.clone(), + }; + output.start(event_tx.clone(), out_buffer.clone(), output_errors); + } + SoundmodemEvent::Close => { + input.close(); + output.close(); + if let Err(e) = ptt_driver.ptt_off() { + error_handler.soundmodem_error(ErrorSource::Ptt, e); + } + break; } - SoundmodemEvent::Close => break, SoundmodemEvent::DidReadFromOutputBuffer { len, timestamp } => { let (occupied, internal_latency) = { let out_buffer = out_buffer.read().unwrap(); @@ -186,17 +318,23 @@ fn spawn_soundmodem_worker( ); } SoundmodemEvent::OutputUnderrun => { + log::debug!("output underrun"); // TODO: cancel transmission, send empty data frame to host } + SoundmodemEvent::RuntimeError(source, err) => { + error_handler.soundmodem_error(source, err); + } } // Update PTT state let new_ptt = tnc.ptt(); if new_ptt != ptt { if new_ptt { - // turn it on - } else { - // turn it off + if let Err(e) = ptt_driver.ptt_on() { + error_handler.soundmodem_error(ErrorSource::Ptt, e); + } + } else if let Err(e) = ptt_driver.ptt_off() { + error_handler.soundmodem_error(ErrorSource::Ptt, e); } } ptt = new_ptt; @@ -230,100 +368,33 @@ fn spawn_soundmodem_worker( } pub trait InputSource: Send + Sync + 'static { - fn start(&self, samples: SyncSender); + fn start(&self, samples: SyncSender, errors: SoundmodemErrorSender); fn close(&self); } -pub struct InputSoundcard { - // TODO: allow for inversion both here and in output - cpal_name: Option, - end_tx: Mutex>>, -} - -impl InputSoundcard { - pub fn new() -> Self { - Self { - cpal_name: None, - end_tx: Mutex::new(None), - } - } - - pub fn new_with_card(card_name: String) -> Self { - Self { - cpal_name: Some(card_name), - end_tx: Mutex::new(None), - } - } -} - -impl InputSource for InputSoundcard { - fn start(&self, samples: SyncSender) { - let (end_tx, end_rx) = channel(); - let cpal_name = self.cpal_name.clone(); - std::thread::spawn(move || { - let host = cpal::default_host(); - let device = if let Some(name) = cpal_name.as_deref() { - host.input_devices() - .unwrap() - .find(|d| d.name().unwrap() == name) - .unwrap() - } else { - host.default_input_device().unwrap() - }; - let mut configs = device.supported_input_configs().unwrap(); - let config = configs - .find(|c| c.channels() == 1 && c.sample_format() == SampleFormat::I16) - .unwrap() - .with_sample_rate(SampleRate(48000)); - let stream = device - .build_input_stream( - &config.into(), - move |data: &[i16], _info: &cpal::InputCallbackInfo| { - let out: Vec = data.iter().map(|s| *s).collect(); - let _ = samples.try_send(SoundmodemEvent::BasebandInput(out.into())); - }, - |e| { - // TODO: abort? - debug!("error occurred in soundcard input: {e:?}"); - }, - None, - ) - .unwrap(); - stream.play().unwrap(); - let _ = end_rx.recv(); - }); - *self.end_tx.lock().unwrap() = Some(end_tx); - } - - fn close(&self) { - let _ = self.end_tx.lock().unwrap().take(); - } -} - pub struct InputRrcFile { - path: PathBuf, + baseband: Arc<[u8]>, end_tx: Mutex>>, } impl InputRrcFile { - pub fn new(path: PathBuf) -> Self { - Self { - path, + pub fn new(path: PathBuf) -> Result { + let mut file = File::open(&path).map_err(|_| M17Error::InvalidRrcPath(path.clone()))?; + let mut baseband = vec![]; + file.read_to_end(&mut baseband) + .map_err(|_| M17Error::RrcReadFailed(path))?; + Ok(Self { + baseband: baseband.into(), end_tx: Mutex::new(None), - } + }) } } impl InputSource for InputRrcFile { - fn start(&self, samples: SyncSender) { + fn start(&self, samples: SyncSender, errors: SoundmodemErrorSender) { let (end_tx, end_rx) = channel(); - let path = self.path.clone(); + let baseband = self.baseband.clone(); std::thread::spawn(move || { - // TODO: error handling - let mut file = File::open(path).unwrap(); - let mut baseband = vec![]; - file.read_to_end(&mut baseband).unwrap(); - // assuming 48 kHz for now const TICK: Duration = Duration::from_millis(25); const SAMPLES_PER_TICK: usize = 1200; @@ -339,10 +410,13 @@ impl InputSource for InputRrcFile { buf[idx] = sample; idx += 1; if idx == SAMPLES_PER_TICK { - if let Err(e) = samples.try_send(SoundmodemEvent::BasebandInput(buf.into())) { - debug!("overflow feeding soundmodem: {e:?}"); + if samples + .try_send(SoundmodemEvent::BasebandInput(buf.into())) + .is_err() + { + errors.send_error(InputRrcError::Overflow); } - next_tick = next_tick + TICK; + next_tick += TICK; idx = 0; std::thread::sleep(next_tick.duration_since(Instant::now())); } @@ -359,6 +433,12 @@ impl InputSource for InputRrcFile { } } +#[derive(Debug, Error)] +pub enum InputRrcError { + #[error("overflow occurred feeding sample to soundmodem")] + Overflow, +} + pub struct NullInputSource { end_tx: Mutex>>, } @@ -372,7 +452,7 @@ impl NullInputSource { } impl InputSource for NullInputSource { - fn start(&self, samples: SyncSender) { + fn start(&self, samples: SyncSender, errors: SoundmodemErrorSender) { let (end_tx, end_rx) = channel(); std::thread::spawn(move || { // assuming 48 kHz for now @@ -382,14 +462,17 @@ impl InputSource for NullInputSource { loop { std::thread::sleep(next_tick.duration_since(Instant::now())); - next_tick = next_tick + TICK; + next_tick += TICK; if end_rx.try_recv() != Err(TryRecvError::Empty) { break; } - if let Err(e) = samples.try_send(SoundmodemEvent::BasebandInput( - [0i16; SAMPLES_PER_TICK].into(), - )) { - debug!("overflow feeding soundmodem: {e:?}"); + if samples + .try_send(SoundmodemEvent::BasebandInput( + [0i16; SAMPLES_PER_TICK].into(), + )) + .is_err() + { + errors.send_error(NullInputError::Overflow); } } }); @@ -401,11 +484,23 @@ impl InputSource for NullInputSource { } } +#[derive(Debug, Error)] +pub enum NullInputError { + #[error("overflow occurred feeding sample to soundmodem")] + Overflow, +} + +impl Default for NullInputSource { + fn default() -> Self { + Self::new() + } +} + pub struct OutputBuffer { - idling: bool, + pub idling: bool, // TODO: something more efficient - samples: VecDeque, - latency: Duration, + pub samples: VecDeque, + pub latency: Duration, } impl OutputBuffer { @@ -418,8 +513,19 @@ impl OutputBuffer { } } +impl Default for OutputBuffer { + fn default() -> Self { + Self::new() + } +} + pub trait OutputSink: Send + Sync + 'static { - fn start(&self, event_tx: SyncSender, buffer: Arc>); + fn start( + &self, + event_tx: SyncSender, + buffer: Arc>, + errors: SoundmodemErrorSender, + ); fn close(&self); } @@ -438,13 +544,21 @@ impl OutputRrcFile { } impl OutputSink for OutputRrcFile { - fn start(&self, event_tx: SyncSender, buffer: Arc>) { + fn start( + &self, + event_tx: SyncSender, + buffer: Arc>, + errors: SoundmodemErrorSender, + ) { let (end_tx, end_rx) = channel(); - let path = self.path.clone(); + let mut file = match File::create(self.path.clone()) { + Ok(f) => f, + Err(e) => { + errors.send_error(OutputRrcError::Open(e)); + return; + } + }; std::thread::spawn(move || { - // TODO: error handling - let mut file = File::create(path).unwrap(); - // assuming 48 kHz for now const TICK: Duration = Duration::from_millis(25); const SAMPLES_PER_TICK: usize = 1200; @@ -455,7 +569,7 @@ impl OutputSink for OutputRrcFile { loop { std::thread::sleep(next_tick.duration_since(Instant::now())); - next_tick = next_tick + TICK; + next_tick += TICK; if end_rx.try_recv() != Err(TryRecvError::Empty) { break; } @@ -470,13 +584,12 @@ impl OutputSink for OutputRrcFile { out.copy_from_slice(&[be[0], be[1]]); buf_used += 2; } else if !buffer.idling { - debug!("output rrc file had underrun"); let _ = event_tx.send(SoundmodemEvent::OutputUnderrun); break; } } if let Err(e) = file.write_all(&buf[0..buf_used]) { - debug!("failed to write to rrc file: {e:?}"); + errors.send_error(OutputRrcError::WriteError(e)); break; } let _ = event_tx.send(SoundmodemEvent::DidReadFromOutputBuffer { @@ -493,6 +606,15 @@ impl OutputSink for OutputRrcFile { } } +#[derive(Debug, Error)] +pub enum OutputRrcError { + #[error("unable to open rrc file for writing: {0}")] + Open(#[source] std::io::Error), + + #[error("error writing to output file: {0}")] + WriteError(#[source] std::io::Error), +} + pub struct NullOutputSink { end_tx: Mutex>>, } @@ -505,8 +627,19 @@ impl NullOutputSink { } } +impl Default for NullOutputSink { + fn default() -> Self { + Self::new() + } +} + impl OutputSink for NullOutputSink { - fn start(&self, event_tx: SyncSender, buffer: Arc>) { + fn start( + &self, + event_tx: SyncSender, + buffer: Arc>, + _errors: SoundmodemErrorSender, + ) { let (end_tx, end_rx) = channel(); std::thread::spawn(move || { // assuming 48 kHz for now @@ -516,7 +649,7 @@ impl OutputSink for NullOutputSink { loop { std::thread::sleep(next_tick.duration_since(Instant::now())); - next_tick = next_tick + TICK; + next_tick += TICK; if end_rx.try_recv() != Err(TryRecvError::Empty) { break; } @@ -524,9 +657,8 @@ impl OutputSink for NullOutputSink { let mut buffer = buffer.write().unwrap(); let mut taken = 0; for _ in 0..SAMPLES_PER_TICK { - if !buffer.samples.pop_front().is_some() { + if buffer.samples.pop_front().is_none() { if !buffer.idling { - debug!("null output had underrun"); let _ = event_tx.send(SoundmodemEvent::OutputUnderrun); break; } @@ -548,92 +680,32 @@ impl OutputSink for NullOutputSink { } } -pub struct OutputSoundcard { - // TODO: allow for inversion both here and in output - cpal_name: Option, - end_tx: Mutex>>, +pub trait Ptt: Send + 'static { + fn ptt_on(&mut self) -> Result<(), SoundmodemError>; + fn ptt_off(&mut self) -> Result<(), SoundmodemError>; } -impl OutputSoundcard { +/// There is no PTT because this TNC will never make transmissions on a real radio. +pub struct NullPtt; + +impl NullPtt { pub fn new() -> Self { - Self { - cpal_name: None, - end_tx: Mutex::new(None), - } + Self } +} - pub fn new_with_card(card_name: String) -> Self { - Self { - cpal_name: Some(card_name), - end_tx: Mutex::new(None), - } +impl Default for NullPtt { + fn default() -> Self { + Self::new() } } -impl OutputSink for OutputSoundcard { - fn start(&self, event_tx: SyncSender, buffer: Arc>) { - let (end_tx, end_rx) = channel(); - let cpal_name = self.cpal_name.clone(); - std::thread::spawn(move || { - let host = cpal::default_host(); - let device = if let Some(name) = cpal_name.as_deref() { - host.output_devices() - .unwrap() - .find(|d| d.name().unwrap() == name) - .unwrap() - } else { - host.default_output_device().unwrap() - }; - let mut configs = device.supported_output_configs().unwrap(); - // TODO: more error handling - let config = configs - .find(|c| c.channels() == 1 && c.sample_format() == SampleFormat::I16) - .unwrap() - .with_sample_rate(SampleRate(48000)); - let stream = device - .build_output_stream( - &config.into(), - move |data: &mut [i16], info: &cpal::OutputCallbackInfo| { - let mut taken = 0; - let ts = info.timestamp(); - let latency = ts - .playback - .duration_since(&ts.callback) - .unwrap_or(Duration::ZERO); - let mut buffer = buffer.write().unwrap(); - buffer.latency = latency; - for out in data.iter_mut() { - if let Some(s) = buffer.samples.pop_front() { - *out = s; - taken += 1; - } else if buffer.idling { - *out = 0; - } else { - debug!("output soundcard had underrun"); - let _ = event_tx.send(SoundmodemEvent::OutputUnderrun); - break; - } - } - //debug!("latency is {} ms, taken {taken}", latency.as_millis()); - let _ = event_tx.send(SoundmodemEvent::DidReadFromOutputBuffer { - len: taken, - timestamp: Instant::now(), - }); - }, - |e| { - // TODO: abort? - debug!("error occurred in soundcard output: {e:?}"); - }, - None, - ) - .unwrap(); - stream.play().unwrap(); - let _ = end_rx.recv(); - }); - *self.end_tx.lock().unwrap() = Some(end_tx); +impl Ptt for NullPtt { + fn ptt_on(&mut self) -> Result<(), SoundmodemError> { + Ok(()) } - fn close(&self) { - let _ = self.end_tx.lock().unwrap().take(); + fn ptt_off(&mut self) -> Result<(), SoundmodemError> { + Ok(()) } }