X-Git-Url: https://code.octet-stream.net/m17rt/blobdiff_plain/9058451e46e4d36264282abe381aa9b6fd2c773f..253c89360003ac72c4f7078c03af973c58a1b129:/m17app/src/soundmodem.rs

diff --git a/m17app/src/soundmodem.rs b/m17app/src/soundmodem.rs
index 99085a0..74c176b 100644
--- a/m17app/src/soundmodem.rs
+++ b/m17app/src/soundmodem.rs
@@ -279,7 +279,6 @@ impl InputSource for InputSoundcard {
                 .build_input_stream(
                     &config.into(),
                     move |data: &[i16], _info: &cpal::InputCallbackInfo| {
-                        debug!("input has given us {} samples", data.len());
                         let out: Vec<i16> = data.iter().map(|s| *s).collect();
                         let _ = samples.try_send(SoundmodemEvent::BasebandInput(out.into()));
                     },
@@ -360,6 +359,48 @@ impl InputSource for InputRrcFile {
     }
 }
 
+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
@@ -418,24 +459,30 @@ impl OutputSink for OutputRrcFile {
                 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_be_bytes();
+                        let be = s.to_le_bytes();
                         out.copy_from_slice(&[be[0], be[1]]);
-                    } else if buffer.idling {
-                        out.copy_from_slice(&[0, 0]);
-                    } else {
+                        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) {
+                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);
@@ -475,13 +522,22 @@ 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() && !buffer.idling {
-                        debug!("null output had underrun");
-                        let _ = event_tx.send(SoundmodemEvent::OutputUnderrun);
-                        break;
+                    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);
@@ -491,3 +547,93 @@ impl OutputSink for NullOutputSink {
         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();
+    }
+}