Add a skeleton for the rosbag decoder

Cargo.toml

@@ -19,6 +19,7 @@ neuromorphic-types = "0.6.0"
 numpy = {version = "0.23.0"}
 pyo3 = {version = "0.23.4", features = ["extension-module"]}
 resvg = "0.44.0"
+rosbag = "0.6.3"
 roxmltree = "0.20.0"
 serde = {version = "1.0", features = ["derive"]}
 serde_json = "1.0"

src/lib.rs

@@ -13,6 +13,7 @@ mod mp4;
 mod mustache;
 mod raster;
 mod render;
+mod rosbag;
 //mod event_spectrogram;
 mod types;
 mod utilities;
@@ -107,5 +108,10 @@ fn faery(python: Python<'_>, module: &pyo3::Bound<'_, pyo3::types::PyModule>) ->
         submodule.add_class::<render::Renderer>()?;
         module.add_submodule(&submodule)?;
     }
+    {
+        let submodule = PyModule::new(python, "rosbag")?;
+        submodule.add_class::<rosbag::Decoder>()?;
+        module.add_submodule(&submodule)?;
+    }
     Ok(())
 }

src/rosbag/decoder.rs

@@ -0,0 +1,44 @@
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[error("io error: {0}")]
+    Io(#[from] std::io::Error),
+
+    #[error("rosbag error: {0}")]
+    Rosbag(String),
+}
+
+pub struct Decoder {
+    inner: rosbag::RosBag,
+    event_buffer: Vec<neuromorphic_types::PolarityEvent<u64, u16, u16>>,
+    dimensions: (u16, u16),
+    t: u64,
+}
+
+impl Decoder {
+    pub fn new<P: AsRef<std::path::Path>>(path: P) -> Result<Self, Error> {
+        let inner = rosbag::RosBag::new(path)?;
+        for record in inner.chunk_records() {
+            match record.map_err(|error| Error::Rosbag(format!("{error:?}")))? {
+                rosbag::ChunkRecord::Chunk(chunk) => {
+                    for message in chunk.messages() {
+                        if message.is_ok() {
+                            todo!("decode the message");
+                        }
+                    }
+                }
+                rosbag::ChunkRecord::IndexData(_) => {}
+            }
+        }
+
+        Ok(Decoder {
+            inner,
+            event_buffer: Vec::new(),
+            dimensions: (0, 0),
+            t: 0,
+        })
+    }
+
+    pub fn dimensions(&self) -> (u16, u16) {
+        self.dimensions
+    }
+}

src/rosbag/mod.rs

@@ -0,0 +1,98 @@
+mod decoder;
+
+use crate::types;
+
+use pyo3::prelude::*;
+
+impl From<decoder::Error> for PyErr {
+    fn from(error: decoder::Error) -> Self {
+        PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(error.to_string())
+    }
+}
+
+#[pyclass]
+pub struct Decoder {
+    inner: Option<decoder::Decoder>,
+}
+
+#[pymethods]
+impl Decoder {
+    #[new]
+    #[pyo3(signature = (path))]
+    fn new(path: &pyo3::Bound<'_, pyo3::types::PyAny>) -> PyResult<Self> {
+        Ok(Decoder {
+            inner: Some(decoder::Decoder::new(types::python_path_to_string(path)?)?),
+        })
+    }
+
+    #[getter]
+    fn dimensions(&self) -> PyResult<(u16, u16)> {
+        match self.inner {
+            Some(ref decoder) => Ok(decoder.dimensions()),
+            None => Err(pyo3::exceptions::PyException::new_err(
+                "called dimensions after __exit__",
+            )),
+        }
+    }
+
+    /*
+    fn __enter__(slf: Py<Self>) -> Py<Self> {
+        slf
+    }
+
+    #[pyo3(signature = (_exception_type, _value, _traceback))]
+    fn __exit__(
+        &mut self,
+        _exception_type: Option<PyObject>,
+        _value: Option<PyObject>,
+        _traceback: Option<PyObject>,
+    ) -> PyResult<bool> {
+        if self.inner.is_none() {
+            return Err(pyo3::exceptions::PyException::new_err(
+                "multiple calls to __exit__",
+            ));
+        }
+        let _ = self.inner.take();
+        Ok(false)
+    }
+
+    fn __iter__(shell: PyRefMut<Self>) -> PyResult<Py<Decoder>> {
+        Ok(shell.into())
+    }
+
+    fn __next__(mut shell: PyRefMut<Self>) -> PyResult<Option<PyObject>> {
+        let packet = match shell.inner {
+            Some(ref mut decoder) => match decoder.next() {
+                Ok(result) => match result {
+                    Some(result) => result,
+                    None => return Ok(None),
+                },
+                Err(result) => return Err(result.into()),
+            },
+            None => {
+                return Err(pyo3::exceptions::PyException::new_err(
+                    "called __next__ after __exit__",
+                ))
+            }
+        };
+        Python::with_gil(|python| -> PyResult<Option<PyObject>> {
+            let length = packet.len() as numpy::npyffi::npy_intp;
+            let array = types::ArrayType::Dat.new_array(python, length);
+            unsafe {
+                for index in 0..length {
+                    let event_cell = types::array_at(python, array, index);
+                    std::ptr::copy(
+                        &packet[index as usize] as *const common::Event as *const u8,
+                        event_cell,
+                        std::mem::size_of::<common::Event>(),
+                    );
+                }
+                Ok(Some(PyObject::from_owned_ptr(
+                    python,
+                    array as *mut pyo3::ffi::PyObject,
+                )))
+            }
+        })
+    }
+    */
+}