fast demod bin

[m17rt] / m17core / src / decode.rs

diff --git a/m17core/src/decode.rs b/m17core/src/decode.rs
index d3dd7ba087fe0c59b3cdcbf0e557c4d44405cb65..3195ed5d86e9398abc253e7c1b947cf90436772e 100644 (file)
--- a/m17core/src/decode.rs
+++ b/m17core/src/decode.rs
@@ -3,8 +3,8 @@ use crate::{
     fec::{self, p_1, p_2, p_3},
     interleave::interleave,
     protocol::{
     fec::{self, p_1, p_2, p_3},
     interleave::interleave,
     protocol::{

-        LsfFrame, PacketFrame, PacketFrameCounter, StreamFrame, BERT_SYNC, END_OF_TRANSMISSION,
-        LSF_SYNC, PACKET_SYNC, PREAMBLE, STREAM_SYNC,
+        BERT_SYNC, END_OF_TRANSMISSION, LSF_SYNC, LsfFrame, PACKET_SYNC, PREAMBLE, PacketFrame,
+        PacketFrameCounter, STREAM_SYNC, StreamFrame,

     },
     random::random_xor,
 };
     },
     random::random_xor,
 };


@@ -91,11 +91,11 @@ pub(crate) fn frame_initial_decode(frame: &[f32] /* length 192 */) -> [u8; 46] {
     interleave(&decoded[2..])
 }
 
     interleave(&decoded[2..])
 }
 

-pub(crate) fn parse_lsf(frame: &[f32] /* length 192 */) -> Option<LsfFrame> {
+pub(crate) fn parse_lsf(frame: &[f32] /* length 192 */) -> Option<(LsfFrame, u8)> {

     let deinterleaved = frame_initial_decode(frame);
     debug!("deinterleaved: {:?}", deinterleaved);
     let deinterleaved = frame_initial_decode(frame);
     debug!("deinterleaved: {:?}", deinterleaved);

-    let lsf = match fec::decode(&deinterleaved, 240, p_1) {
-        Some(lsf) => LsfFrame(lsf),
+    let (lsf, errors) = match fec::decode(&deinterleaved, 240, p_1) {
+        Some((lsf, errors)) => (LsfFrame(lsf), errors),

         None => return None,
     };
     debug!("full lsf: {:?}", lsf.0);
         None => return None,
     };
     debug!("full lsf: {:?}", lsf.0);


@@ -108,16 +108,13 @@ pub(crate) fn parse_lsf(frame: &[f32] /* length 192 */) -> Option<LsfFrame> {
     debug!("encryption type: {:?}", lsf.encryption_type());
     debug!("can: {}", lsf.channel_access_number());
     debug!("meta: {:?}", lsf.meta());
     debug!("encryption type: {:?}", lsf.encryption_type());
     debug!("can: {}", lsf.channel_access_number());
     debug!("meta: {:?}", lsf.meta());

-    Some(lsf)
+    Some((lsf, errors))

 }
 
 }
 

-pub(crate) fn parse_stream(frame: &[f32] /* length 192 */) -> Option<StreamFrame> {
+pub(crate) fn parse_stream(frame: &[f32] /* length 192 */) -> Option<(StreamFrame, u8)> {

     let deinterleaved = frame_initial_decode(frame);
     let stream_part = &deinterleaved[12..];
     let deinterleaved = frame_initial_decode(frame);
     let stream_part = &deinterleaved[12..];

-    let stream = match fec::decode(stream_part, 144, p_2) {
-        Some(stream) => stream,
-        None => return None,
-    };
+    let (stream, errors) = fec::decode(stream_part, 144, p_2)?;

     let frame_num = u16::from_be_bytes([stream[0], stream[1]]);
     let eos = (frame_num & 0x8000) > 0;
     let frame_num = frame_num & 0x7fff; // higher layer has to handle wraparound
     let frame_num = u16::from_be_bytes([stream[0], stream[1]]);
     let eos = (frame_num & 0x8000) > 0;
     let frame_num = frame_num & 0x7fff; // higher layer has to handle wraparound


@@ -128,24 +125,24 @@ pub(crate) fn parse_stream(frame: &[f32] /* length 192 */) -> Option<StreamFrame
             "LICH: received part {counter} part {part:?} from raw {:?}",
             &deinterleaved[0..12]
         );
             "LICH: received part {counter} part {part:?} from raw {:?}",
             &deinterleaved[0..12]
         );

-        Some(StreamFrame {
-            lich_idx: counter,
-            lich_part: part,
-            frame_number: frame_num,
-            end_of_stream: eos,
-            stream_data: stream[2..18].try_into().unwrap(),
-        })
+        Some((
+            StreamFrame {
+                lich_idx: counter,
+                lich_part: part,
+                frame_number: frame_num,
+                end_of_stream: eos,
+                stream_data: stream[2..18].try_into().unwrap(),
+            },
+            errors,
+        ))

     } else {
         None
     }
 }
 
     } else {
         None
     }
 }
 

-pub(crate) fn parse_packet(frame: &[f32] /* length 192 */) -> Option<PacketFrame> {
+pub(crate) fn parse_packet(frame: &[f32] /* length 192 */) -> Option<(PacketFrame, u8)> {

     let deinterleaved = frame_initial_decode(frame);
     let deinterleaved = frame_initial_decode(frame);

-    let packet = match fec::decode(&deinterleaved, 206, p_3) {
-        Some(packet) => packet,
-        None => return None,
-    };
+    let (packet, errors) = fec::decode(&deinterleaved, 206, p_3)?;

     let final_frame = (packet[25] & 0x80) > 0;
     let number = (packet[25] >> 2) & 0x1f;
     let counter = if final_frame {
     let final_frame = (packet[25] & 0x80) > 0;
     let number = (packet[25] >> 2) & 0x1f;
     let counter = if final_frame {


@@ -157,10 +154,13 @@ pub(crate) fn parse_packet(frame: &[f32] /* length 192 */) -> Option<PacketFrame
             index: number as usize,
         }
     };
             index: number as usize,
         }
     };

-    Some(PacketFrame {
-        payload: packet[0..25].try_into().unwrap(),
-        counter,
-    })
+    Some((
+        PacketFrame {
+            payload: packet[0..25].try_into().unwrap(),
+            counter,
+        },
+        errors,
+    ))

 }
 
 pub(crate) fn decode_lich(type2_bits: &[u8]) -> Option<(u8, [u8; 5])> {
 }
 
 pub(crate) fn decode_lich(type2_bits: &[u8]) -> Option<(u8, [u8; 5])> {