X-Git-Url: https://code.octet-stream.net/m17rt/blobdiff_plain/4cfda08117c4288a5408d45db1ef4be82f4facaa..bb98d1726f35a41236b66bcf9fa0a8fa36633342:/m17core/src/modem.rs

diff --git a/m17core/src/modem.rs b/m17core/src/modem.rs
index b2ab773..b333ef5 100644
--- a/m17core/src/modem.rs
+++ b/m17core/src/modem.rs
@@ -27,8 +27,8 @@ pub struct SoftDemodulator {
     candidate: Option<DecodeCandidate>,
     /// How many samples have we received?
     sample: u64,
-    /// Remaining samples to ignore so once we already parse a frame we flush it out in full
-    suppress: u16,
+    /// Remaining samples to read in before attempting to decode the current candidate
+    samples_until_decode: Option<u16>,
 }
 
 impl SoftDemodulator {
@@ -40,7 +40,7 @@ impl SoftDemodulator {
             rx_cursor: 0,
             candidate: None,
             sample: 0,
-            suppress: 0,
+            samples_until_decode: None,
         }
     }
 }
@@ -60,14 +60,50 @@ impl Demodulator for SoftDemodulator {
 
         self.sample += 1;
 
-        if self.suppress > 0 {
-            self.suppress -= 1;
-            return None;
+        if let Some(samples_until_decode) = self.samples_until_decode {
+            let sud = samples_until_decode - 1;
+            if sud > 0 {
+                self.samples_until_decode = Some(sud);
+                return None;
+            }
+            self.samples_until_decode = None;
+
+            if let Some(c) = self.candidate.take() {
+                // we have capacity for 192 symbols * 10 upsamples
+                // we have calculated that the ideal sample point for 192nd symbol is right on the edge
+                // so take samples from the 10th slot all the way through.
+                let start_idx = self.rx_cursor + 1920 + 9;
+                let mut pkt_samples = [0f32; 192];
+                for i in 0..192 {
+                    let rx_idx = (start_idx + i * 10) % 1920;
+                    pkt_samples[i] = (self.rx_win[rx_idx] - c.shift) / c.gain;
+                }
+                match c.burst {
+                    SyncBurst::Lsf => {
+                        if let Some(frame) = parse_lsf(&pkt_samples) {
+                            return Some(Frame::Lsf(frame));
+                        }
+                    }
+                    SyncBurst::Bert => {
+                        // TODO: BERT
+                    }
+                    SyncBurst::Stream => {
+                        if let Some(frame) = parse_stream(&pkt_samples) {
+                            return Some(Frame::Stream(frame));
+                        }
+                    }
+                    SyncBurst::Packet => {
+                        if let Some(frame) = parse_packet(&pkt_samples) {
+                            return Some(Frame::Packet(frame));
+                        }
+                    }
+                }
+            }
         }
 
-        let mut burst_window = [0f32; 71];
-        for i in 0..71 {
-            let c = (self.rx_cursor + i) % 1920;
+        let mut burst_window = [0f32; 8];
+        for i in 0..8 {
+            let c = (self.rx_cursor + 1920 - 1 - ((7 - i) * 10)) % 1920;
             burst_window[i] = self.rx_win[c];
         }
 
@@ -103,47 +139,15 @@ impl Demodulator for SoftDemodulator {
                     .map(|c| c.burst == burst)
                     .unwrap_or(false)
             {
-                if let Some(c) = self.candidate.take() {
-                    let start_idx = self.rx_cursor + 1920 - (c.age as usize);
-                    let start_sample = self.sample - c.age as u64;
-                    let mut pkt_samples = [0f32; 192];
-                    for i in 0..192 {
-                        let rx_idx = (start_idx + i * 10) % 1920;
-                        pkt_samples[i] = (self.rx_win[rx_idx] - c.shift) / c.gain;
-                    }
-                    match c.burst {
-                        SyncBurst::Lsf => {
-                            debug!(
-                                "Found LSF at sample {} diff {} max {} shift {}",
-                                start_sample, c.diff, c.gain, c.shift
-                            );
-                            if let Some(frame) = parse_lsf(&pkt_samples) {
-                                self.suppress = 191 * 10;
-                                return Some(Frame::Lsf(frame));
-                            }
-                        }
-                        SyncBurst::Bert => {
-                            debug!("Found BERT at sample {} diff {}", start_sample, c.diff);
-                        }
-                        SyncBurst::Stream => {
-                            debug!(
-                                "Found STREAM at sample {} diff {} max {} shift {}",
-                                start_sample, c.diff, c.gain, c.shift
-                            );
-                            if let Some(frame) = parse_stream(&pkt_samples) {
-                                self.suppress = 191 * 10;
-                                return Some(Frame::Stream(frame));
-                            }
-                        }
-                        SyncBurst::Packet => {
-                            debug!("Found PACKET at sample {} diff {}", start_sample, c.diff);
-                            if let Some(frame) = parse_packet(&pkt_samples) {
-                                self.suppress = 191 * 10;
-                                return Some(Frame::Packet(frame));
-                            }
-                        }
-                    }
-                }
+                // wait until the rest of the frame is in the buffer
+                let c = self.candidate.as_ref().unwrap();
+                self.samples_until_decode = Some((184 * 10) - (c.age as u16));
+                debug!(
+                    "Found {:?} at sample {} diff {}",
+                    c.burst,
+                    self.sample - c.age as u64,
+                    c.diff
+                );
             }
         }
 
@@ -311,12 +315,11 @@ impl SoftModulator {
         for i in 0..10 {
             // Right now we are encoding everything as 1.0-scaled dibit floats
             // This is a bit silly but it will do for a minute
-            // Max theoretical gain from the RRC filter is 4.328
-            // Let's bump everything to a baseline of 16383 / 4.328 = 3785.35
-            // This is not particularly high but at least we won't ever hit the top
+            // Max possible gain from the RRC filter with upsampling is about 0.462
+            // Let's bump everything to a baseline of 16383 / 0.462 = 35461
+            // For normal signals this yields roughly 0.5 magnitude which is plenty
             if i == 0 {
-                // 10x the impulse with zeroes between for upsampling
-                self.filter_win[self.filter_cursor] = dibit * 3785.0 * 10.0;
+                self.filter_win[self.filter_cursor] = dibit * 35461.0;
             } else {
                 self.filter_win[self.filter_cursor] = 0.0;
             }
@@ -420,7 +423,7 @@ impl Modulator for SoftModulator {
 
         // if we have pre-TX padding to accommodate TxDelay then expend that first
         if self.tx_delay_padding > 0 {
-            let len = out.len().max(self.tx_delay_padding);
+            let len = out.len().min(self.tx_delay_padding);
             self.tx_delay_padding -= len;
             for x in 0..len {
                 out[x] = 0;