refactor: move sign_extend helpers to crate library (Phase 1)

- Create src/parser/helpers.rs with 7 sign_extend functions
- Export helpers from parser/mod.rs
- Remove bbl_format from lib.rs (will be CLI-only module)
- Update stream.rs to use shared helpers
- Update bbl_format.rs to use shared helpers
- All tests pass, CSV output identical to master

Author: nerdCopter

src/bbl_format.rs

@@ -1,6 +1,13 @@
 use anyhow::Result;
+use bbl_parser::parser::helpers::{
+    sign_extend_16bit, sign_extend_24bit, sign_extend_2bit, sign_extend_4bit, sign_extend_6bit,
+    sign_extend_8bit,
+};
 use std::collections::HashMap;
 
+// Re-export sign_extend_14bit for backward compatibility with main.rs
+pub use bbl_parser::parser::helpers::sign_extend_14bit;
+
 // BBL Encoding constants - directly from JavaScript reference
 pub const ENCODING_SIGNED_VB: u8 = 0;
 pub const ENCODING_UNSIGNED_VB: u8 = 1;
@@ -266,58 +273,6 @@ impl<'a> BBLDataStream<'a> {
     }
 }
 
-// Sign extension functions - exact replicas of JavaScript implementations
-pub fn sign_extend_2bit(value: u8) -> i32 {
-    let val = value as i32;
-    if (val & 0x02) != 0 {
-        val | !0x03
-    } else {
-        val & 0x03
-    }
-}
-
-pub fn sign_extend_4bit(value: u8) -> i32 {
-    let val = value as i32;
-    if (val & 0x08) != 0 {
-        val | !0x0f
-    } else {
-        val & 0x0f
-    }
-}
-
-pub fn sign_extend_6bit(value: u8) -> i32 {
-    let val = value as i32;
-    if (val & 0x20) != 0 {
-        val | !0x3f
-    } else {
-        val & 0x3f
-    }
-}
-
-pub fn sign_extend_8bit(value: u8) -> i32 {
-    value as i8 as i32
-}
-
-pub fn sign_extend_16bit(value: u16) -> i32 {
-    value as i16 as i32
-}
-
-pub fn sign_extend_24bit(value: u32) -> i32 {
-    if (value & 0x800000) != 0 {
-        (value | 0xff000000) as i32
-    } else {
-        (value & 0x7fffff) as i32
-    }
-}
-
-pub fn sign_extend_14bit(value: u16) -> i32 {
-    if (value & 0x2000) != 0 {
-        -((value & 0x1fff) as i32)
-    } else {
-        (value & 0x1fff) as i32
-    }
-}
-
 #[allow(clippy::too_many_arguments)]
 #[allow(dead_code)]
 pub fn apply_predictor(

src/lib.rs

@@ -16,7 +16,6 @@
 //! ```
 
 // Module declarations
-mod bbl_format;
 pub mod conversion;
 pub mod error;
 pub mod export;
@@ -25,8 +24,6 @@ pub mod types;
 
 // Re-export everything from modules for convenience
 #[allow(ambiguous_glob_reexports)]
-pub use bbl_format::*;
-#[allow(ambiguous_glob_reexports)]
 pub use conversion::*;
 #[allow(ambiguous_glob_reexports)]
 pub use error::*;

src/parser/helpers.rs

@@ -0,0 +1,130 @@
+//! Helper functions for BBL parsing
+//!
+//! This module provides sign extension functions used for decoding various
+//! fixed-width signed values from the blackbox binary format.
+
+/// Sign-extend a 2-bit value to i32
+pub fn sign_extend_2bit(value: u8) -> i32 {
+    let val = value as i32;
+    if (val & 0x02) != 0 {
+        val | !0x03
+    } else {
+        val & 0x03
+    }
+}
+
+/// Sign-extend a 4-bit value to i32
+pub fn sign_extend_4bit(value: u8) -> i32 {
+    let val = value as i32;
+    if (val & 0x08) != 0 {
+        val | !0x0f
+    } else {
+        val & 0x0f
+    }
+}
+
+/// Sign-extend a 6-bit value to i32
+pub fn sign_extend_6bit(value: u8) -> i32 {
+    let val = value as i32;
+    if (val & 0x20) != 0 {
+        val | !0x3f
+    } else {
+        val & 0x3f
+    }
+}
+
+/// Sign-extend an 8-bit value to i32
+pub fn sign_extend_8bit(value: u8) -> i32 {
+    value as i8 as i32
+}
+
+/// Sign-extend a 16-bit value to i32
+pub fn sign_extend_16bit(value: u16) -> i32 {
+    value as i16 as i32
+}
+
+/// Sign-extend a 24-bit value to i32
+pub fn sign_extend_24bit(value: u32) -> i32 {
+    if (value & 0x800000) != 0 {
+        (value | 0xff000000) as i32
+    } else {
+        (value & 0x7fffff) as i32
+    }
+}
+
+/// Sign-extend a 14-bit value to i32 (sign-magnitude format)
+/// Bit 13 indicates sign, bits 0-12 are the magnitude.
+/// Returns negative value if sign bit is set.
+pub fn sign_extend_14bit(value: u16) -> i32 {
+    if (value & 0x2000) != 0 {
+        -((value & 0x1fff) as i32)
+    } else {
+        (value & 0x1fff) as i32
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_sign_extend_2bit() {
+        assert_eq!(sign_extend_2bit(0), 0);
+        assert_eq!(sign_extend_2bit(1), 1);
+        assert_eq!(sign_extend_2bit(2), -2);
+        assert_eq!(sign_extend_2bit(3), -1);
+    }
+
+    #[test]
+    fn test_sign_extend_4bit() {
+        assert_eq!(sign_extend_4bit(0), 0);
+        assert_eq!(sign_extend_4bit(7), 7);
+        assert_eq!(sign_extend_4bit(8), -8);
+        assert_eq!(sign_extend_4bit(15), -1);
+    }
+
+    #[test]
+    fn test_sign_extend_6bit() {
+        assert_eq!(sign_extend_6bit(0), 0);
+        assert_eq!(sign_extend_6bit(31), 31);
+        assert_eq!(sign_extend_6bit(32), -32);
+        assert_eq!(sign_extend_6bit(63), -1);
+    }
+
+    #[test]
+    fn test_sign_extend_8bit() {
+        assert_eq!(sign_extend_8bit(0), 0);
+        assert_eq!(sign_extend_8bit(127), 127);
+        assert_eq!(sign_extend_8bit(128), -128);
+        assert_eq!(sign_extend_8bit(255), -1);
+    }
+
+    #[test]
+    fn test_sign_extend_16bit() {
+        assert_eq!(sign_extend_16bit(0), 0);
+        assert_eq!(sign_extend_16bit(32767), 32767);
+        assert_eq!(sign_extend_16bit(32768), -32768);
+        assert_eq!(sign_extend_16bit(65535), -1);
+    }
+
+    #[test]
+    fn test_sign_extend_24bit() {
+        assert_eq!(sign_extend_24bit(0), 0);
+        assert_eq!(sign_extend_24bit(0x7FFFFF), 0x7FFFFF);
+        assert_eq!(sign_extend_24bit(0x800000), -8388608);
+        assert_eq!(sign_extend_24bit(0xFFFFFF), -1);
+    }
+
+    #[test]
+    fn test_sign_extend_14bit() {
+        // Positive values (bit 13 clear)
+        assert_eq!(sign_extend_14bit(0), 0);
+        assert_eq!(sign_extend_14bit(1), 1);
+        assert_eq!(sign_extend_14bit(0x1FFF), 0x1FFF); // 8191
+
+        // Negative values (bit 13 set)
+        assert_eq!(sign_extend_14bit(0x2000), 0); // -0
+        assert_eq!(sign_extend_14bit(0x2001), -1);
+        assert_eq!(sign_extend_14bit(0x3FFF), -8191);
+    }
+}

src/parser/mod.rs

@@ -3,6 +3,7 @@ pub mod event;
 pub mod frame;
 pub mod gps;
 pub mod header;
+pub mod helpers;
 pub mod main;
 pub mod stream;
 
@@ -11,5 +12,6 @@ pub use event::*;
 pub use frame::*;
 pub use gps::*;
 pub use header::*;
+pub use helpers::*;
 pub use main::*;
 pub use stream::*;

src/parser/stream.rs

@@ -1,3 +1,7 @@
+use crate::parser::helpers::{
+    sign_extend_14bit, sign_extend_16bit, sign_extend_24bit, sign_extend_2bit, sign_extend_4bit,
+    sign_extend_6bit, sign_extend_8bit,
+};
 use anyhow::Result;
 
 /// BBL data stream for reading binary data
@@ -226,82 +230,32 @@ impl<'a> BBLDataStream<'a> {
     /// Returns the negated value to match blackbox_decode behavior.
     pub fn read_neg_14bit(&mut self) -> Result<i32> {
         let unsigned = self.read_unsigned_vb()? as u16;
-        Ok(-sign_extend_14bit_sign_magnitude(unsigned))
-    }
-}
-
-/// Sign-magnitude 14-bit encoding (matches bbl_format::sign_extend_14bit and blackbox_decode)
-/// Bit 13 indicates sign, bits 0-12 are the magnitude
-fn sign_extend_14bit_sign_magnitude(value: u16) -> i32 {
-    if (value & 0x2000) != 0 {
-        -((value & 0x1fff) as i32)
-    } else {
-        (value & 0x1fff) as i32
-    }
-}
-
-// Sign extension helper functions - exact replicas of JavaScript implementation
-fn sign_extend_2bit(value: u8) -> i32 {
-    if (value & 0x02) != 0 {
-        (value as i32) | !0x03
-    } else {
-        value as i32
-    }
-}
-
-fn sign_extend_4bit(value: u8) -> i32 {
-    if (value & 0x08) != 0 {
-        (value as i32) | !0x0f
-    } else {
-        value as i32
-    }
-}
-
-fn sign_extend_6bit(value: u8) -> i32 {
-    if (value & 0x20) != 0 {
-        (value as i32) | !0x3f
-    } else {
-        value as i32
-    }
-}
-
-fn sign_extend_8bit(value: u8) -> i32 {
-    value as i8 as i32
-}
-
-fn sign_extend_16bit(value: u16) -> i32 {
-    value as i16 as i32
-}
-
-fn sign_extend_24bit(value: u32) -> i32 {
-    if (value & 0x800000) != 0 {
-        (value as i32) | !0xffffff
-    } else {
-        value as i32
+        Ok(-sign_extend_14bit(unsigned))
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::parser::helpers::sign_extend_14bit;
 
     #[test]
     fn test_sign_extend_14bit_sign_magnitude_positive() {
         // Positive values have bit 13 = 0 (sign bit clear)
-        assert_eq!(sign_extend_14bit_sign_magnitude(0x0000), 0); // 0
-        assert_eq!(sign_extend_14bit_sign_magnitude(0x0001), 1); // 1
-        assert_eq!(sign_extend_14bit_sign_magnitude(0x1FFF), 0x1FFF); // 8191 (max positive magnitude)
+        assert_eq!(sign_extend_14bit(0x0000), 0); // 0
+        assert_eq!(sign_extend_14bit(0x0001), 1); // 1
+        assert_eq!(sign_extend_14bit(0x1FFF), 0x1FFF); // 8191 (max positive magnitude)
     }
 
     #[test]
     fn test_sign_extend_14bit_sign_magnitude_negative() {
         // Negative values have bit 13 = 1 (sign bit set), magnitude in bits 0-12
         // 0x2000 = bit 13 set, magnitude 0 -> returns -0 = 0 (actually negative zero)
-        assert_eq!(sign_extend_14bit_sign_magnitude(0x2000), 0); // -0
-                                                                 // 0x2001 = bit 13 set, magnitude 1 -> returns -1
-        assert_eq!(sign_extend_14bit_sign_magnitude(0x2001), -1);
+        assert_eq!(sign_extend_14bit(0x2000), 0); // -0
+                                                  // 0x2001 = bit 13 set, magnitude 1 -> returns -1
+        assert_eq!(sign_extend_14bit(0x2001), -1);
         // 0x3FFF = bit 13 set, magnitude 0x1FFF (8191) -> returns -8191
-        assert_eq!(sign_extend_14bit_sign_magnitude(0x3FFF), -8191);
+        assert_eq!(sign_extend_14bit(0x3FFF), -8191);
     }
 
     #[test]