Refactor reader into multiple smaller files

Author: NetroScript

src/api.rs

@@ -43,15 +43,15 @@ impl IResource for MCAPWriteOptions {
 impl MCAPWriteOptions {
     #[constant]
     /// No compression.
-    const MCAP_COMPRESSION_NONE: i32 = MCAPCompression::None as i32;
+    const MCAP_COMPRESSION_NONE: i64 = MCAPCompression::None as i64;
     #[cfg(feature = "zstd")]
     #[constant]
     /// Zstandard compression.
-    const MCAP_COMPRESSION_ZSTD: i32 = MCAPCompression::Zstd as i32;
+    const MCAP_COMPRESSION_ZSTD: i64 = MCAPCompression::Zstd as i64;
     #[cfg(feature = "lz4")]
     #[constant]
     /// LZ4 frame compression.
-    const MCAP_COMPRESSION_LZ4: i32 = MCAPCompression::Lz4 as i32;
+    const MCAP_COMPRESSION_LZ4: i64 = MCAPCompression::Lz4 as i64;
 }
 
 #[godot_api]

src/reader/buf.rs

@@ -0,0 +1,21 @@
+use godot::prelude::*;
+use std::sync::Arc;
+
+// Prefer on-demand access via memory mapping to avoid copying the whole file.
+// Fall back to an in-memory PackedByteArray when constructed from bytes or if mmap fails.
+pub(super) enum BufBackend {
+    Memory(PackedByteArray),
+    Mmap(memmap2::Mmap),
+}
+
+impl BufBackend {
+    #[inline]
+    pub fn as_slice(&self) -> &[u8] {
+        match self {
+            BufBackend::Memory(p) => p.as_slice(),
+            BufBackend::Mmap(m) => &m[..],
+        }
+    }
+}
+
+pub type SharedBuf = Arc<BufBackend>;

src/reader/filter.rs

@@ -0,0 +1,83 @@
+use crate::types::*;
+use godot::prelude::*;
+use mcap::read::Summary;
+use std::collections::HashSet;
+
+// Reusable message filter for time range and channel sets
+pub(super) struct MsgFilter {
+    pub time_start: Option<u64>,
+    pub time_end: Option<u64>,
+    pub channels: Option<HashSet<u16>>, // if None: accept all
+}
+
+impl MsgFilter {
+    #[inline]
+    pub fn matches_time(&self, t: u64) -> bool {
+        if let Some(s) = self.time_start {
+            if t < s {
+                return false;
+            }
+        }
+        if let Some(e) = self.time_end {
+            if t > e {
+                return false;
+            }
+        }
+        true
+    }
+
+    #[inline]
+    pub fn matches_ch(&self, id: u16) -> bool {
+        match &self.channels {
+            Some(set) => set.contains(&id),
+            None => true,
+        }
+    }
+
+    #[inline]
+    pub fn chunk_might_match(&self, idx: &mcap::records::ChunkIndex) -> bool {
+        if let Some(s) = self.time_start {
+            if idx.message_end_time < s {
+                return false;
+            }
+        }
+        if let Some(e) = self.time_end {
+            if idx.message_start_time > e {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+// Shared helper: stream a chunk, apply filter, build MCAPMessage, and call a closure with (log_time, message)
+pub(super) fn stream_chunk_apply<F>(
+    bytes: &[u8],
+    summary: &Summary,
+    chunk_idx: &mcap::records::ChunkIndex,
+    filter: &MsgFilter,
+    mut f: F,
+) -> Result<(), String>
+where
+    F: FnMut(u64, Gd<MCAPMessage>),
+{
+    let iter = summary
+        .stream_chunk(bytes, chunk_idx)
+        .map_err(|e| format!("stream_chunk open failed: {}", e))?;
+    for item in iter {
+        match item {
+            Ok(msg) => {
+                if !filter.matches_time(msg.log_time) {
+                    continue;
+                }
+                if !filter.matches_ch(msg.channel.id) {
+                    continue;
+                }
+                let gd = MCAPMessage::from_mcap(&msg);
+                f(msg.log_time, gd);
+            }
+            Err(e) => return Err(format!("stream_chunk failed: {}", e)),
+        }
+    }
+    Ok(())
+}