Support for baseband output to a soundcard

[m17rt] / m17app / src / app.rs

diff --git a/m17app/src/app.rs b/m17app/src/app.rs
index 05e3167139eb0f9ccadd27838643d3354970aaa2..561a2b7ae569b6266e6dc9d39a589fd18e712d0c 100644 (file)
--- a/m17app/src/app.rs
+++ b/m17app/src/app.rs
@@ -1,7 +1,7 @@
 use crate::adapter::{PacketAdapter, StreamAdapter};
 use crate::tnc::Tnc;
 use m17core::kiss::{KissBuffer, KissCommand, KissFrame};
 use crate::adapter::{PacketAdapter, StreamAdapter};
 use crate::tnc::Tnc;
 use m17core::kiss::{KissBuffer, KissCommand, KissFrame};

-use m17core::protocol::{EncryptionType, LsfFrame, PacketType};
+use m17core::protocol::{EncryptionType, LsfFrame, PacketType, StreamFrame};

 
 use log::debug;
 use std::collections::HashMap;
 
 use log::debug;
 use std::collections::HashMap;


@@ -60,14 +60,6 @@ impl M17App {
         }
     }
 
         }
     }
 

-    pub fn transmit_packet(&self, packet_type: PacketType, payload: &[u8]) {
-        // hang on where do we get the LSF details from? We need a destination obviously
-        // our source address needs to be configured here too
-        // also there is possible CAN, encryption, meta payload
-
-        // we will immediately convert this into a KISS payload before sending into channel so we only need borrow on data
-    }
-

     /// Create a handle that can be used to transmit data on the TNC
     pub fn tx(&self) -> TxHandle {
         TxHandle {
     /// Create a handle that can be used to transmit data on the TNC
     pub fn tx(&self) -> TxHandle {
         TxHandle {


@@ -89,13 +81,29 @@ pub struct TxHandle {
 }
 
 impl TxHandle {
 }
 
 impl TxHandle {

+    pub fn transmit_packet(&self, packet_type: PacketType, payload: &[u8]) {
+        // hang on where do we get the LSF details from? We need a destination obviously
+        // our source address needs to be configured here too
+        // also there is possible CAN, encryption, meta payload
+
+        // we will immediately convert this into a KISS payload before sending into channel so we only need borrow on data
+    }
+

     // add more methods here for stream outgoing
 
     // add more methods here for stream outgoing
 

-    pub fn transmit_stream_start(&self /* lsf?, payload? what needs to be configured ?! */) {}
+    pub fn transmit_stream_start(&self, lsf: LsfFrame) {
+        // TODO: is asking for an LsfFrame a good idea or unfriendly API?
+        // What I should do here is create a LinkSetup struct which wraps an LsfFrame and can be loaded with a raw one
+        let kiss_frame = KissFrame::new_stream_setup(&lsf.0).unwrap();
+        let _ = self.event_tx.send(TncControlEvent::Kiss(kiss_frame));
+    }

 
     // as long as there is only one TNC it is implied there is only ever one stream transmission in flight
 
 
     // as long as there is only one TNC it is implied there is only ever one stream transmission in flight
 

-    pub fn transmit_stream_next(&self, /* next payload,  */ end_of_stream: bool) {}
+    pub fn transmit_stream_next(&self, stream: StreamFrame) {
+        let kiss_frame = KissFrame::new_stream_data(&stream).unwrap();
+        let _ = self.event_tx.send(TncControlEvent::Kiss(kiss_frame));
+    }

 }
 
 /// Synchronised structure for listeners subscribing to packets and streams.
 }
 
 /// Synchronised structure for listeners subscribing to packets and streams.


@@ -125,9 +133,10 @@ enum TncControlEvent {
     Close,
 }
 
     Close,
 }
 

-fn spawn_reader<T: Tnc + Send + 'static>(mut tnc: T, listeners: Arc<RwLock<Adapters>>) {
+fn spawn_reader<T: Tnc>(mut tnc: T, adapters: Arc<RwLock<Adapters>>) {

     std::thread::spawn(move || {
         let mut kiss_buffer = KissBuffer::new();
     std::thread::spawn(move || {
         let mut kiss_buffer = KissBuffer::new();

+        let mut stream_running = false;

         loop {
             let mut buf = kiss_buffer.buf_remaining();
             let n = match tnc.read(&mut buf) {
         loop {
             let mut buf = kiss_buffer.buf_remaining();
             let n = match tnc.read(&mut buf) {


@@ -155,7 +164,7 @@ fn spawn_reader<T: Tnc + Send + 'static>(mut tnc: T, listeners: Arc<RwLock<Adapt
                             continue;
                         }
                         let lsf = LsfFrame(payload[0..30].try_into().unwrap());
                             continue;
                         }
                         let lsf = LsfFrame(payload[0..30].try_into().unwrap());

-                        if lsf.crc() != 0 {
+                        if lsf.check_crc() != 0 {

                             debug!("LSF in full packet frame did not pass CRC");
                             continue;
                         }
                             debug!("LSF in full packet frame did not pass CRC");
                             continue;
                         }


@@ -181,7 +190,7 @@ fn spawn_reader<T: Tnc + Send + 'static>(mut tnc: T, listeners: Arc<RwLock<Adapt
                             Arc::from(&payload[(30 + type_len)..(n - 2)]);
 
                         let subs: Vec<_> =
                             Arc::from(&payload[(30 + type_len)..(n - 2)]);
 
                         let subs: Vec<_> =

-                            listeners.read().unwrap().packet.values().cloned().collect();
+                            adapters.read().unwrap().packet.values().cloned().collect();

                         for s in subs {
                             s.packet_received(
                                 lsf.clone(),
                         for s in subs {
                             s.packet_received(
                                 lsf.clone(),


@@ -191,7 +200,47 @@ fn spawn_reader<T: Tnc + Send + 'static>(mut tnc: T, listeners: Arc<RwLock<Adapt
                         }
                     }
                     Ok(m17core::kiss::PORT_STREAM) => {
                         }
                     }
                     Ok(m17core::kiss::PORT_STREAM) => {

-                        // handle stream and send it to subscribers
+                        let mut payload = [0u8; 32];
+                        let Ok(n) = frame.decode_payload(&mut payload) else {
+                            debug!("failed to decode stream payload from KISS frame");
+                            continue;
+                        };
+                        if n == 30 {
+                            let lsf = LsfFrame(payload[0..30].try_into().unwrap());
+                            if lsf.check_crc() != 0 {
+                                debug!("initial LSF in stream did not pass CRC");
+                                continue;
+                            }
+                            stream_running = true;
+                            let subs: Vec<_> =
+                                adapters.read().unwrap().stream.values().cloned().collect();
+                            for s in subs {
+                                s.stream_began(lsf.clone());
+                            }
+                        } else if n == 26 {
+                            if !stream_running {
+                                debug!("ignoring stream data as we didn't get a valid LSF first");
+                                continue;
+                            }
+                            // TODO: parse LICH and handle the different changing subvalues META could have
+                            if m17core::crc::m17_crc(&payload[6..n]) != 0 {
+                                debug!("stream data CRC mismatch");
+                                continue;
+                            }
+                            let mut frame_number = u16::from_be_bytes([payload[6], payload[7]]);
+                            let is_final = (frame_number & 0x8000) > 0;
+                            frame_number &= 0x7fff;
+                            let data: [u8; 16] = payload[8..24].try_into().unwrap();
+                            let data = Arc::new(data);
+                            if is_final {
+                                stream_running = false;
+                            }
+                            let subs: Vec<_> =
+                                adapters.read().unwrap().stream.values().cloned().collect();
+                            for s in subs {
+                                s.stream_data(frame_number, is_final, data.clone());
+                            }
+                        }

                     }
                     _ => (),
                 }
                     }
                     _ => (),
                 }


@@ -200,7 +249,7 @@ fn spawn_reader<T: Tnc + Send + 'static>(mut tnc: T, listeners: Arc<RwLock<Adapt
     });
 }
 
     });
 }
 

-fn spawn_writer<T: Tnc + Send + 'static>(mut tnc: T, event_rx: mpsc::Receiver<TncControlEvent>) {
+fn spawn_writer<T: Tnc>(mut tnc: T, event_rx: mpsc::Receiver<TncControlEvent>) {

     std::thread::spawn(move || {
         while let Ok(ev) = event_rx.recv() {
             match ev {
     std::thread::spawn(move || {
         while let Ok(ev) = event_rx.recv() {
             match ev {