+ let _ = self.event_tx.send(SoundmodemEvent::Close);
+ Ok(())
+ }
+}
+
+pub enum SoundmodemEvent {
+ Kiss(Arc<[u8]>),
+ BasebandInput(Arc<[i16]>),
+ Start,
+ Close,
+ DidReadFromOutputBuffer { len: usize, timestamp: Instant },
+ OutputUnderrun,
+}
+
+fn spawn_soundmodem_worker(
+ event_tx: SyncSender<SoundmodemEvent>,
+ event_rx: Receiver<SoundmodemEvent>,
+ kiss_out_tx: SyncSender<Arc<[u8]>>,
+ input: Box<dyn InputSource>,
+ output: Box<dyn OutputSink>,
+) {
+ std::thread::spawn(move || {
+ // TODO: should be able to provide a custom Demodulator for a soundmodem
+ let mut demodulator = SoftDemodulator::new();
+ let mut modulator = SoftModulator::new();
+ let mut tnc = SoftTnc::new();
+ let mut buf = [0u8; MAX_FRAME_LEN];
+ let out_buffer = Arc::new(RwLock::new(OutputBuffer::new()));
+ let mut out_samples = [0i16; 1024];
+ let start = Instant::now();
+ 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);
+
+ // Handle event
+ match ev {
+ SoundmodemEvent::Kiss(k) => {
+ let _n = tnc.write_kiss(&k);
+ // TODO: what does it mean if we fail to write it all?
+ // Probably we have to read frames for tx first - revisit this during tx
+ }
+ SoundmodemEvent::BasebandInput(b) => {
+ for sample in &*b {
+ if let Some(frame) = demodulator.demod(*sample) {
+ tnc.handle_frame(frame);
+ loop {
+ let n = tnc.read_kiss(&mut buf);
+ if n > 0 {
+ let _ = kiss_out_tx.try_send(buf[0..n].into());
+ } else {
+ break;
+ }
+ }
+ }
+ }
+ tnc.set_data_carrier_detect(demodulator.data_carrier_detect());
+ }
+ SoundmodemEvent::Start => {
+ input.start(event_tx.clone());
+ output.start(event_tx.clone(), out_buffer.clone());
+ }
+ SoundmodemEvent::Close => break,
+ SoundmodemEvent::DidReadFromOutputBuffer { len, timestamp } => {
+ let (occupied, internal_latency) = {
+ let out_buffer = out_buffer.read().unwrap();
+ (out_buffer.samples.len(), out_buffer.latency)
+ };
+ let internal_latency = (internal_latency.as_secs_f32() * 48000.0) as usize;
+ let dynamic_latency =
+ len.saturating_sub((timestamp.elapsed().as_secs_f32() * 48000.0) as usize);
+ modulator.update_output_buffer(
+ occupied,
+ 48000,
+ internal_latency + dynamic_latency,
+ );
+ }
+ SoundmodemEvent::OutputUnderrun => {
+ // TODO: cancel transmission, send empty data frame to host
+ }
+ }
+
+ // Update PTT state
+ let new_ptt = tnc.ptt();
+ if new_ptt != ptt {
+ if new_ptt {
+ // turn it on
+ } else {
+ // turn it off
+ }
+ }
+ ptt = new_ptt;
+
+ // Let the modulator do what it wants
+ while let Some(action) = modulator.run() {
+ match action {
+ ModulatorAction::SetIdle(idling) => {
+ out_buffer.write().unwrap().idling = idling;
+ }
+ ModulatorAction::GetNextFrame => {
+ modulator.provide_next_frame(tnc.read_tx_frame());
+ }
+ ModulatorAction::ReadOutput => loop {
+ let n = modulator.read_output_samples(&mut out_samples);
+ if n == 0 {
+ break;
+ }
+ let mut out_buffer = out_buffer.write().unwrap();
+ for s in &out_samples[0..n] {
+ out_buffer.samples.push_back(*s);
+ }
+ },
+ ModulatorAction::TransmissionWillEnd(in_samples) => {
+ tnc.set_tx_end_time(in_samples);
+ }
+ }
+ }
+ }
+ });
+}
+
+pub trait InputSource: Send + Sync + 'static {
+ fn start(&self, samples: SyncSender<SoundmodemEvent>);
+ fn close(&self);
+}
+
+pub struct InputSoundcard {
+ // TODO: allow for inversion both here and in output
+ cpal_name: Option<String>,
+ end_tx: Mutex<Option<Sender<()>>>,
+}
+
+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<SoundmodemEvent>) {
+ 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<i16> = 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,
+ end_tx: Mutex<Option<Sender<()>>>,
+}
+
+impl InputRrcFile {
+ pub fn new(path: PathBuf) -> Self {
+ Self {
+ path,
+ end_tx: Mutex::new(None),
+ }
+ }
+}
+
+impl InputSource for InputRrcFile {
+ fn start(&self, samples: SyncSender<SoundmodemEvent>) {
+ let (end_tx, end_rx) = channel();
+ let path = self.path.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;
+
+ let mut next_tick = Instant::now() + TICK;
+ let mut buf = [0i16; SAMPLES_PER_TICK];
+ let mut idx = 0;
+
+ for sample in baseband
+ .chunks(2)
+ .map(|pair| i16::from_le_bytes([pair[0], pair[1]]))
+ {
+ 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:?}");
+ }
+ next_tick = next_tick + TICK;
+ idx = 0;
+ std::thread::sleep(next_tick.duration_since(Instant::now()));
+ }
+ if end_rx.try_recv() != Err(TryRecvError::Empty) {
+ break;
+ }
+ }
+ });
+ *self.end_tx.lock().unwrap() = Some(end_tx);
+ }
+
+ fn close(&self) {
+ let _ = self.end_tx.lock().unwrap().take();
+ }
+}
+
+pub struct NullInputSource {
+ end_tx: Mutex<Option<Sender<()>>>,
+}
+
+impl NullInputSource {
+ pub fn new() -> Self {
+ Self {
+ end_tx: Mutex::new(None),
+ }
+ }
+}
+
+impl InputSource for NullInputSource {
+ fn start(&self, samples: SyncSender<SoundmodemEvent>) {
+ let (end_tx, end_rx) = channel();
+ std::thread::spawn(move || {
+ // assuming 48 kHz for now
+ const TICK: Duration = Duration::from_millis(25);
+ const SAMPLES_PER_TICK: usize = 1200;
+ let mut next_tick = Instant::now() + TICK;
+
+ loop {
+ std::thread::sleep(next_tick.duration_since(Instant::now()));
+ next_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:?}");
+ }
+ }
+ });
+ *self.end_tx.lock().unwrap() = Some(end_tx);
+ }
+
+ fn close(&self) {
+ let _ = self.end_tx.lock().unwrap().take();
+ }
+}
+
+pub struct OutputBuffer {
+ idling: bool,
+ // TODO: something more efficient
+ samples: VecDeque<i16>,
+ latency: Duration,
+}
+
+impl OutputBuffer {
+ pub fn new() -> Self {
+ Self {
+ idling: true,
+ samples: VecDeque::new(),
+ latency: Duration::ZERO,
+ }
+ }
+}
+
+pub trait OutputSink: Send + Sync + 'static {
+ fn start(&self, event_tx: SyncSender<SoundmodemEvent>, buffer: Arc<RwLock<OutputBuffer>>);
+ fn close(&self);
+}
+
+pub struct OutputRrcFile {
+ path: PathBuf,
+ end_tx: Mutex<Option<Sender<()>>>,
+}
+
+impl OutputRrcFile {
+ pub fn new(path: PathBuf) -> Self {
+ Self {
+ path,
+ end_tx: Mutex::new(None),
+ }
+ }
+}
+
+impl OutputSink for OutputRrcFile {
+ fn start(&self, event_tx: SyncSender<SoundmodemEvent>, buffer: Arc<RwLock<OutputBuffer>>) {
+ let (end_tx, end_rx) = channel();
+ let path = self.path.clone();
+ 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;
+
+ // flattened BE i16s for writing
+ let mut buf = [0u8; SAMPLES_PER_TICK * 2];
+ let mut next_tick = Instant::now() + TICK;
+
+ loop {
+ std::thread::sleep(next_tick.duration_since(Instant::now()));
+ next_tick = next_tick + TICK;
+ if end_rx.try_recv() != Err(TryRecvError::Empty) {
+ break;
+ }
+ // For now only write deliberately modulated (non-idling) samples
+ // Multiple transmissions will get smooshed together
+ let mut buf_used = 0;
+
+ let mut buffer = buffer.write().unwrap();
+ for out in buf.chunks_mut(2) {
+ if let Some(s) = buffer.samples.pop_front() {
+ let be = s.to_le_bytes();
+ 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:?}");
+ break;
+ }
+ let _ = event_tx.send(SoundmodemEvent::DidReadFromOutputBuffer {
+ len: buf_used / 2,
+ timestamp: Instant::now(),
+ });
+ }
+ });
+ *self.end_tx.lock().unwrap() = Some(end_tx);
+ }
+
+ fn close(&self) {
+ let _ = self.end_tx.lock().unwrap().take();
+ }
+}
+
+pub struct NullOutputSink {
+ end_tx: Mutex<Option<Sender<()>>>,
+}
+
+impl NullOutputSink {
+ pub fn new() -> Self {
+ Self {
+ end_tx: Mutex::new(None),
+ }
+ }
+}
+
+impl OutputSink for NullOutputSink {
+ fn start(&self, event_tx: SyncSender<SoundmodemEvent>, buffer: Arc<RwLock<OutputBuffer>>) {
+ let (end_tx, end_rx) = channel();
+ std::thread::spawn(move || {
+ // assuming 48 kHz for now
+ const TICK: Duration = Duration::from_millis(25);
+ const SAMPLES_PER_TICK: usize = 1200;
+ let mut next_tick = Instant::now() + TICK;
+
+ loop {
+ std::thread::sleep(next_tick.duration_since(Instant::now()));
+ next_tick = next_tick + TICK;
+ if end_rx.try_recv() != Err(TryRecvError::Empty) {
+ break;
+ }
+
+ 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.idling {
+ debug!("null output had underrun");
+ let _ = event_tx.send(SoundmodemEvent::OutputUnderrun);
+ break;
+ }
+ } else {
+ taken += 1;
+ }
+ }
+ let _ = event_tx.send(SoundmodemEvent::DidReadFromOutputBuffer {
+ len: taken,
+ timestamp: Instant::now(),
+ });
+ }
+ });
+ *self.end_tx.lock().unwrap() = Some(end_tx);
+ }
+
+ fn close(&self) {
+ let _ = self.end_tx.lock().unwrap().take();
+ }
+}
+
+pub struct OutputSoundcard {
+ // TODO: allow for inversion both here and in output
+ cpal_name: Option<String>,
+ end_tx: Mutex<Option<Sender<()>>>,
+}
+
+impl OutputSoundcard {
+ 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 OutputSink for OutputSoundcard {
+ fn start(&self, event_tx: SyncSender<SoundmodemEvent>, buffer: Arc<RwLock<OutputBuffer>>) {
+ 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);
+ }
+
+ fn close(&self) {
+ let _ = self.end_tx.lock().unwrap().take();
projects / m17rt / blobdiff