nex5file 1.2.1

Read and write NeuroExplorer .nex and .nex5 files
Documentation
use super::data_format::DataFormat;
use super::io_helpers::{
    read_bytes, read_f64_le, read_i32_le, read_i64_le, to_string, write_f64_le, write_i32_le,
    write_i64_le, write_padded_string, write_padding,
};
use crate::compat::String;
use crate::io_ext::{IoResult, Read, Write};
use core::fmt;

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct VariableHeader {
    pub var_type: i32,
    pub version: i32,
    pub name: String,
    pub data_offset: u64,
    pub count: u64,
    pub ts_data_type: i32,
    pub cont_data_type: i32,
    pub sampling_rate: f64,
    pub units: String,
    pub ad_to_mv: f64,
    pub mv_offset: f64,
    pub n_points_wave: u64,
    pub pre_thr_time: f64,
    pub marker_data_type: i32,
    pub n_markers: i32,
    pub marker_length: i32,
    pub cont_frag_index_type: i32,
    pub gain: i32,
    pub filter: i32,
    pub wire: i32,
    pub unit: i32,
    pub x_pos: f64,
    pub y_pos: f64,
}

impl Default for VariableHeader {
    fn default() -> Self {
        Self {
            var_type: -1,
            version: 0,
            name: String::new(),
            data_offset: 0,
            count: 0,
            ts_data_type: 0,
            cont_data_type: 0,
            sampling_rate: 0.0,
            units: String::new(),
            ad_to_mv: 0.0,
            mv_offset: 0.0,
            n_points_wave: 0,
            pre_thr_time: 0.0,
            marker_data_type: 0,
            n_markers: 0,
            marker_length: 0,
            cont_frag_index_type: 0,
            gain: 0,
            filter: 0,
            wire: 0,
            unit: 0,
            x_pos: 0.0,
            y_pos: 0.0,
        }
    }
}

impl fmt::Display for VariableHeader {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{self:?}")
    }
}

impl VariableHeader {
    pub fn read_from_nex(reader: &mut impl Read) -> IoResult<Self> {
        let header = Self {
            var_type: read_i32_le(reader)?,
            version: read_i32_le(reader)?,
            name: to_string(&read_bytes(reader, 64)?, true),
            data_offset: read_i32_le(reader)? as u64,
            count: read_i32_le(reader)? as u64,
            wire: read_i32_le(reader)?,
            unit: read_i32_le(reader)?,
            gain: read_i32_le(reader)?,
            filter: read_i32_le(reader)?,
            x_pos: read_f64_le(reader)?,
            y_pos: read_f64_le(reader)?,
            sampling_rate: read_f64_le(reader)?,
            ad_to_mv: read_f64_le(reader)?,
            n_points_wave: read_i32_le(reader)? as u64,
            n_markers: read_i32_le(reader)?,
            marker_length: read_i32_le(reader)?,
            mv_offset: read_f64_le(reader)?,
            pre_thr_time: read_f64_le(reader)?,
            ts_data_type: 0,
            cont_data_type: 0,
            units: String::new(),
            marker_data_type: 0,
            cont_frag_index_type: 0,
        };
        let _padding = read_bytes(reader, 52)?;
        Ok(header)
    }

    pub fn read_from_nex5(reader: &mut impl Read) -> IoResult<Self> {
        let mut header = Self {
            var_type: read_i32_le(reader)?,
            version: read_i32_le(reader)?,
            name: to_string(&read_bytes(reader, 64)?, false),
            data_offset: read_i64_le(reader)? as u64,
            count: read_i64_le(reader)? as u64,
            ts_data_type: read_i32_le(reader)?,
            cont_data_type: read_i32_le(reader)?,
            sampling_rate: read_f64_le(reader)?,
            units: to_string(&read_bytes(reader, 32)?, false),
            ad_to_mv: read_f64_le(reader)?,
            mv_offset: read_f64_le(reader)?,
            n_points_wave: read_i64_le(reader)? as u64,
            pre_thr_time: read_f64_le(reader)?,
            marker_data_type: read_i32_le(reader)?,
            n_markers: read_i32_le(reader)?,
            marker_length: read_i32_le(reader)?,
            cont_frag_index_type: read_i32_le(reader)?,
            gain: 0,
            filter: 0,
            wire: 0,
            unit: 0,
            x_pos: 0.0,
            y_pos: 0.0,
        };

        let _padding = read_bytes(reader, 60)?;

        if header.cont_data_type == 1 {
            header.ad_to_mv = 1.0;
            header.mv_offset = 0.0;
        }

        Ok(header)
    }

    pub fn write_to_nex(&self, writer: &mut impl Write) -> IoResult<()> {
        write_i32_le(writer, self.var_type)?;
        write_i32_le(writer, self.version)?;
        write_padded_string(writer, &self.name, 64)?;
        write_i32_le(writer, self.data_offset as i32)?;
        write_i32_le(writer, self.count as i32)?;
        write_i32_le(writer, self.wire)?;
        write_i32_le(writer, self.unit)?;
        write_i32_le(writer, self.gain)?;
        write_i32_le(writer, self.filter)?;
        write_f64_le(writer, self.x_pos)?;
        write_f64_le(writer, self.y_pos)?;
        write_f64_le(writer, self.sampling_rate)?;
        write_f64_le(writer, self.ad_to_mv)?;
        write_i32_le(writer, self.n_points_wave as i32)?;
        write_i32_le(writer, self.n_markers)?;
        write_i32_le(writer, self.marker_length)?;
        write_f64_le(writer, self.mv_offset)?;
        write_f64_le(writer, self.pre_thr_time)?;
        write_padding(writer, 52)
    }

    pub fn write_to_nex5(&self, writer: &mut impl Write) -> IoResult<()> {
        write_i32_le(writer, self.var_type)?;
        write_i32_le(writer, self.version)?;
        write_padded_string(writer, &self.name, 64)?;
        write_i64_le(writer, self.data_offset as i64)?;
        write_i64_le(writer, self.count as i64)?;
        write_i32_le(writer, self.ts_data_type)?;
        write_i32_le(writer, self.cont_data_type)?;
        write_f64_le(writer, self.sampling_rate)?;
        write_padded_string(writer, &self.units, 32)?;
        write_f64_le(writer, self.ad_to_mv)?;
        write_f64_le(writer, self.mv_offset)?;
        write_i64_le(writer, self.n_points_wave as i64)?;
        write_f64_le(writer, self.pre_thr_time)?;
        write_i32_le(writer, self.marker_data_type)?;
        write_i32_le(writer, self.n_markers)?;
        write_i32_le(writer, self.marker_length)?;
        write_i32_le(writer, self.cont_frag_index_type)?;
        write_padding(writer, 60)
    }

    pub fn cont_data_pars(&self) -> (DataFormat, f64, f64) {
        if self.cont_data_type == 1 {
            (DataFormat::Float32, 1.0, 0.0)
        } else {
            (DataFormat::Int16, self.ad_to_mv, self.mv_offset)
        }
    }

    pub fn timestamp_data_format(&self) -> DataFormat {
        if self.ts_data_type == 1 {
            DataFormat::Int64
        } else {
            DataFormat::Int32
        }
    }

    pub fn bytes_in_timestamp(&self) -> usize {
        if self.ts_data_type == 0 {
            4
        } else {
            8
        }
    }

    pub fn bytes_in_cont_value(&self) -> usize {
        if self.cont_data_type == 0 {
            2
        } else {
            4
        }
    }

    pub fn bytes_in_fragment_index(&self) -> usize {
        4
    }
}

#[cfg(all(test, feature = "std"))]
mod tests {
    use super::*;

    #[test]
    fn nex_var_header_write_size_and_version() {
        let mut buf = Vec::new();
        let h = VariableHeader {
            var_type: 0,
            version: 102,
            name: "nr".to_string(),
            ..Default::default()
        };
        h.write_to_nex(&mut buf).unwrap();
        assert_eq!(buf.len(), 208);
        assert_eq!(i32::from_le_bytes(buf[0..4].try_into().unwrap()), 0);
        assert_eq!(i32::from_le_bytes(buf[4..8].try_into().unwrap()), 102);
        assert_eq!(&buf[8..10], b"nr");
    }
}