use std::io::{Cursor, Read, Seek, SeekFrom};
use std::path::Path;
use crate::error::{Med64Error, Result};
use crate::header::{HeaderBuilder, Med64Header, FILE_HEADER_BYTES};
use crate::recording::Recording;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RecordingFormat {
Modat,
Dat,
Dax,
Modax,
}
impl RecordingFormat {
pub fn from_path(path: &Path) -> Option<Self> {
path.extension().and_then(|e| e.to_str()).and_then(|e| {
match e.to_ascii_lowercase().as_str() {
"modat" => Some(Self::Modat),
"dat" => Some(Self::Dat),
"dax" => Some(Self::Dax),
"modax" => Some(Self::Modax),
_ => None,
}
})
}
pub fn is_waveform(self) -> bool {
matches!(self, Self::Modat | Self::Dat | Self::Dax | Self::Modax)
}
}
pub fn open_recording_any(path: impl AsRef<Path>) -> Result<Recording> {
let path = path.as_ref();
match sniff_layout(path)? {
Sniff::Standard => Recording::open(path),
Sniff::XmlPreamble { data_offset, meta } => {
if meta.indexer_table_offset.is_some() {
open_indexed_presto_modax(path, data_offset, &meta)
} else {
open_with_xml_meta(path, data_offset, meta)
}
}
}
}
#[derive(Debug)]
enum Sniff {
Standard,
XmlPreamble { data_offset: u64, meta: XmlMeta },
}
#[derive(Debug, Clone, Default)]
struct XmlMeta {
conversion_factor: Option<f64>,
sampling_hz: Option<f64>,
num_channels: Option<usize>,
write_format_version: Option<u8>,
active_channels: Option<Vec<usize>>,
active_channel_flags: Option<Vec<u8>>,
indexer_table_offset: Option<u64>,
blocks_per_trace: Option<u32>,
num_traces: Option<u32>,
duration_total_ms: Option<f64>,
daq_voltage_range: Option<f64>,
}
fn sniff_layout(path: &Path) -> Result<Sniff> {
let mut file = std::fs::File::open(path)
.map_err(|source| Med64Error::Io { path: path.to_path_buf(), source })?;
let mut probe = [0u8; 8192];
let n = file
.read(&mut probe)
.map_err(|source| Med64Error::Io { path: path.to_path_buf(), source })?;
let head = &probe[..n];
let text = String::from_utf8_lossy(head);
if text.contains("<WriteFormatVersion>")
|| text.contains("<ConversionFactor>")
|| head.first() == Some(&b'<')
{
let preamble_len = meta_header_length(&text).unwrap_or(n);
let full_text = if preamble_len > n {
read_text_prefix(path, preamble_len)?
} else {
text.into_owned()
};
let meta = parse_xml_meta(&full_text);
let data_offset = meta_header_length(&full_text).unwrap_or(preamble_len) as u64;
return Ok(Sniff::XmlPreamble { data_offset, meta });
}
Ok(Sniff::Standard)
}
fn read_text_prefix(path: &Path, len: usize) -> Result<String> {
let mut buf = vec![0u8; len];
let mut file = std::fs::File::open(path)
.map_err(|source| Med64Error::Io { path: path.to_path_buf(), source })?;
file.read_exact(&mut buf)
.map_err(|source| Med64Error::Io { path: path.to_path_buf(), source })?;
Ok(String::from_utf8_lossy(&buf).into_owned())
}
fn meta_header_length(text: &str) -> Option<usize> {
tag_usize(text, "headerStringsLength")
}
fn parse_xml_meta(text: &str) -> XmlMeta {
XmlMeta {
conversion_factor: tag_f64(text, "ConversionFactor"),
sampling_hz: tag_f64(text, "SamplingFrequency")
.or_else(|| tag_f64(text, "SamplingFreq_Hz"))
.or_else(|| tag_f64(text, "sampling")),
num_channels: tag_usize(text, "NumberChannels"),
write_format_version: tag_usize(text, "WriteFormatVersion").map(|v| v as u8),
active_channels: tag_active(text),
active_channel_flags: tag_active_flags(text),
indexer_table_offset: tag_u64(text, "IndexerTableOffsert")
.or_else(|| tag_u64(text, "IndexerTableOffset")),
blocks_per_trace: tag_u32(text, "NumBlocksPerTrace"),
num_traces: tag_u32(text, "NumTraces"),
duration_total_ms: tag_f64(text, "DurationTotalMilliseconds")
.or_else(|| tag_f64(text, "TraceLastDuration_ms")),
daq_voltage_range: tag_f64(text, "DaqVoltageRange_V"),
}
}
fn tag_f64(text: &str, name: &str) -> Option<f64> {
let open = format!("<{name}>");
let close = format!("</{name}>");
let start = text.find(&open)? + open.len();
let end = text[start..].find(&close)? + start;
text[start..end].trim().parse().ok()
}
fn tag_usize(text: &str, name: &str) -> Option<usize> {
let open = format!("<{name}>");
let close = format!("</{name}>");
let start = text.find(&open)? + open.len();
let end = text[start..].find(&close)? + start;
text[start..end].trim().parse().ok()
}
fn tag_u32(text: &str, name: &str) -> Option<u32> {
tag_usize(text, name).map(|v| v as u32)
}
fn tag_u64(text: &str, name: &str) -> Option<u64> {
let open = format!("<{name}>");
let close = format!("</{name}>");
let start = text.find(&open)? + open.len();
let end = text[start..].find(&close)? + start;
text[start..end].trim().parse().ok()
}
fn tag_active(text: &str) -> Option<Vec<usize>> {
if let Some(flags) = tag_active_flags(text) {
return Some(
flags
.iter()
.enumerate()
.filter_map(|(idx, &flag)| (flag != 0).then_some(idx))
.collect(),
);
}
let open = "<ActiveChannels>";
let close = "</ActiveChannels>";
let start = text.find(open)? + open.len();
let end = text[start..].find(close)? + start;
let body = text[start..end].trim();
let idxs: Vec<usize> = body
.split(|c: char| c == ',' || c.is_whitespace())
.filter_map(|p| p.parse().ok())
.collect();
if idxs.is_empty() {
None
} else {
Some(idxs)
}
}
fn tag_active_flags(text: &str) -> Option<Vec<u8>> {
let open = "<ActiveChannels>";
let close = "</ActiveChannels>";
let start = text.find(open)? + open.len();
let end = text[start..].find(close)? + start;
let body = text[start..end].trim();
let nums: Vec<u32> = body
.split(|c: char| c == ',' || c.is_whitespace())
.filter(|p| !p.is_empty())
.filter_map(|p| p.parse().ok())
.collect();
if nums.is_empty() {
return None;
}
if nums.iter().any(|&v| v > 1) {
return None;
}
if nums.len() >= 128 {
return Some(nums.into_iter().map(|v| if v != 0 { 1 } else { 0 }).collect());
}
if let Some(n) = tag_usize(text, "NumberChannels") {
if nums.len() == n {
return Some(nums.into_iter().map(|v| if v != 0 { 1 } else { 0 }).collect());
}
}
None
}
fn open_indexed_presto_modax(path: &Path, data_offset: u64, meta: &XmlMeta) -> Result<Recording> {
let idx_off = meta.indexer_table_offset.ok_or_else(|| Med64Error::InvalidHeader {
path: path.to_path_buf(),
message: "indexed PRESTO .modax missing IndexerTableOffsert".into(),
})?;
if data_offset >= idx_off {
return Err(Med64Error::InvalidHeader {
path: path.to_path_buf(),
message: format!("invalid indexed payload range {data_offset}..{idx_off}"),
});
}
let payload_len = idx_off - data_offset;
let block_size = probe_indexed_block_size(path, data_offset)?;
let header = build_presto_header_from_xml(path, meta, payload_len, block_size)?;
Recording::open_indexed(path, header, data_offset, idx_off, block_size)
}
fn build_presto_header_from_xml(
path: &Path,
meta: &XmlMeta,
payload_len: u64,
block_size: u64,
) -> Result<Med64Header> {
let blocks_per_trace = meta.blocks_per_trace.unwrap_or(1).max(1);
let num_traces = meta.num_traces.unwrap_or(1).max(1);
let sampling_hz = meta.sampling_hz.unwrap_or(20_000.0);
let duration_ms = meta.duration_total_ms.unwrap_or(0.0);
let mut header = HeaderBuilder::new()
.path(path)
.number_of_traces(num_traces)
.blocks_per_trace(blocks_per_trace)
.sampling_frequency_hz(sampling_hz)
.trace_duration_ms(duration_ms.max(1.0))
.build();
if let Some(cf) = meta.conversion_factor {
header.conversion_factor = cf;
}
if let Some(v) = meta.daq_voltage_range {
header.daq_voltage_range = v;
}
if let Some(v) = meta.write_format_version {
header.data_format_version = v;
}
let slots = meta.num_channels.unwrap_or(384).max(64);
if slots > 64 || meta.active_channel_flags.is_some() {
header.data_format_version = 6;
let mut ext = vec![0u8; 384];
if let Some(ref flags) = meta.active_channel_flags {
for (idx, &flag) in flags.iter().enumerate() {
if idx < ext.len() {
ext[idx] = flag;
}
}
} else if let Some(ref idxs) = meta.active_channels {
for &ch in idxs {
if ch < ext.len() {
ext[ch] = 1;
}
}
} else if let Some(n) = meta.num_channels {
for ch in 0..n.min(384) {
ext[ch] = 1;
}
}
header.extended_active_channels = Some(ext);
header.active_channels = [0u8; 64];
}
let block_size = if block_size > 0 {
block_size
} else {
return Err(Med64Error::InvalidHeader {
path: path.to_path_buf(),
message: "indexed PRESTO block size must be positive".into(),
});
};
header.finalize_block_counts(header.header_bytes_on_disk() + payload_len, block_size);
Ok(header)
}
fn probe_indexed_block_size(path: &Path, data_offset: u64) -> Result<u64> {
use crate::block::{DATA_BLOCK_HEADER_BYTES, DATA_BLOCK_SIZE_FIELD_BYTES};
const PREFIX: usize = DATA_BLOCK_HEADER_BYTES + DATA_BLOCK_SIZE_FIELD_BYTES;
let mut file = std::fs::File::open(path)
.map_err(|source| Med64Error::Io { path: path.to_path_buf(), source })?;
file.seek(SeekFrom::Start(data_offset))
.map_err(|source| Med64Error::Io { path: path.to_path_buf(), source })?;
let mut buf = [0u8; PREFIX];
file.read_exact(&mut buf)
.map_err(|source| Med64Error::Io { path: path.to_path_buf(), source })?;
let payload_size =
u32::from_le_bytes(buf[DATA_BLOCK_HEADER_BYTES..PREFIX].try_into().unwrap());
Ok(PREFIX as u64 + u64::from(payload_size))
}
fn open_with_xml_meta(path: &Path, data_offset: u64, meta: XmlMeta) -> Result<Recording> {
let mut file = std::fs::File::open(path)
.map_err(|source| Med64Error::Io { path: path.to_path_buf(), source })?;
file.seek(SeekFrom::Start(data_offset))
.map_err(|source| Med64Error::Io { path: path.to_path_buf(), source })?;
let mut hdr_buf = [0u8; FILE_HEADER_BYTES];
if file.read_exact(&mut hdr_buf).is_ok() {
if let Ok(mut header) = Med64Header::read_from(path, &mut Cursor::new(hdr_buf)) {
if let Some(cf) = meta.conversion_factor {
header.conversion_factor = cf;
}
if let Some(v) = meta.write_format_version {
header.data_format_version = v;
}
let file_size = std::fs::metadata(path)
.map_err(|source| Med64Error::Io { path: path.to_path_buf(), source })?
.len();
let block_start = data_offset + header.header_bytes_on_disk();
return open_payload_view(path, block_start, file_size, header);
}
}
let mut builder = HeaderBuilder::new().path(path);
if let Some(hz) = meta.sampling_hz {
builder = builder.sampling_frequency_hz(hz);
}
let mut header = builder.build();
if let Some(cf) = meta.conversion_factor {
header.conversion_factor = cf;
}
if let Some(v) = meta.write_format_version {
header.data_format_version = v;
}
if let Some(chs) = meta.active_channels {
header.active_channels = [0u8; 64];
for ch in chs {
if ch < 64 {
header.active_channels[ch] = 1;
}
}
} else if let Some(n) = meta.num_channels {
header.active_channels = [0u8; 64];
for ch in 0..n.min(64) {
header.active_channels[ch] = 1;
}
}
let file_size = std::fs::metadata(path)
.map_err(|source| Med64Error::Io { path: path.to_path_buf(), source })?
.len();
open_payload_view(path, data_offset, file_size, header)
}
fn open_payload_view(
path: &Path,
block_start: u64,
file_end: u64,
mut header: Med64Header,
) -> Result<Recording> {
if block_start >= file_end {
return Err(Med64Error::InvalidHeader {
path: path.to_path_buf(),
message: format!("payload view empty at offset {block_start}"),
});
}
let block_size = probe_indexed_block_size(path, block_start)?;
let payload_len = file_end - block_start;
header.finalize_block_counts(header.header_bytes_on_disk() + payload_len, block_size);
Recording::open_indexed(path, header, block_start, file_end, block_size)
}
pub fn write_modax_wrapper(
modat_path: &Path,
out_path: &Path,
header_strings_len: usize,
) -> Result<()> {
write_modax_wrapper_with_meta(
modat_path,
out_path,
header_strings_len,
ModaxWrapperMeta::default(),
)
}
#[derive(Debug, Clone)]
pub struct ModaxWrapperMeta {
pub write_format_version: u32,
pub number_channels: u32,
pub conversion_factor: f64,
pub sampling_hz: Option<f64>,
pub active_channels: Option<Vec<usize>>,
}
impl Default for ModaxWrapperMeta {
fn default() -> Self {
Self {
write_format_version: 1,
number_channels: 64,
conversion_factor: 0.00015259254737998596,
sampling_hz: None,
active_channels: None,
}
}
}
impl ModaxWrapperMeta {
pub fn presto384() -> Self {
Self {
write_format_version: 6,
number_channels: 384,
conversion_factor: 0.00015259254737998596,
sampling_hz: Some(20_000.0),
active_channels: None,
}
}
pub fn presto384_with_channels(active: &[usize], sampling_hz: f64) -> Self {
let mut m = Self::presto384();
m.sampling_hz = Some(sampling_hz);
m.active_channels = Some(active.to_vec());
m
}
}
pub fn write_modax_wrapper_with_meta(
modat_path: &Path,
out_path: &Path,
header_strings_len: usize,
meta: ModaxWrapperMeta,
) -> Result<()> {
let payload = std::fs::read(modat_path)
.map_err(|source| Med64Error::Io { path: modat_path.to_path_buf(), source })?;
let body = |hlen: usize| {
let mut xml = format!(
"<headerStringsLength>{hlen}</headerStringsLength>\n\
<WriteFormatVersion>{}</WriteFormatVersion>\n\
<ConversionFactor>{}</ConversionFactor>\n\
<NumberChannels>{}</NumberChannels>\n",
meta.write_format_version, meta.conversion_factor, meta.number_channels
);
if let Some(hz) = meta.sampling_hz {
xml.push_str(&format!("<SamplingFrequency>{hz}</SamplingFrequency>\n"));
}
if let Some(ref chans) = meta.active_channels {
let list: Vec<String> = chans.iter().map(|c| c.to_string()).collect();
xml.push_str(&format!("<ActiveChannels>{}</ActiveChannels>\n", list.join(" ")));
}
xml
};
let mut target = header_strings_len.max(body(header_strings_len).len());
let mut xml = body(target);
if xml.len() > target {
target = xml.len();
xml = body(target);
}
let mut bytes = xml.into_bytes();
bytes.resize(target, b' ');
bytes.extend_from_slice(&payload);
std::fs::write(out_path, bytes)
.map_err(|source| Med64Error::WriteIo { path: out_path.to_path_buf(), source })
}
pub fn is_waveform_file(path: &Path) -> bool {
RecordingFormat::from_path(path).is_some_and(|f| f.is_waveform())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn opens_modat_via_any() {
let path = crate::fixture_paths::sample_data1();
let rec = open_recording_any(path).unwrap();
assert!(rec.header().sampling_frequency_hz > 0.0);
}
#[test]
fn parses_xml_meta_tags() {
let xml = r#"<headerStringsLength>128</headerStringsLength>
<WriteFormatVersion>6</WriteFormatVersion>
<ConversionFactor>0.001</ConversionFactor>
<NumberChannels>16</NumberChannels>
<ActiveChannels>0 1 2 3</ActiveChannels>"#;
let meta = parse_xml_meta(xml);
assert_eq!(meta.write_format_version, Some(6));
assert!((meta.conversion_factor.unwrap() - 0.001).abs() < 1e-12);
assert_eq!(meta.num_channels, Some(16));
assert_eq!(meta.active_channels.as_ref().unwrap().len(), 4);
assert_eq!(meta_header_length(xml), Some(128));
}
#[test]
fn dat_extension_detected() {
assert_eq!(RecordingFormat::from_path(Path::new("x.dat")), Some(RecordingFormat::Dat));
assert_eq!(RecordingFormat::from_path(Path::new("x.MODAX")), Some(RecordingFormat::Modax));
}
#[test]
fn modax_wrapper_roundtrip() {
let dir = std::env::temp_dir().join(format!("med64-modax-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let modat = crate::fixture_paths::sample_data1();
let modax = dir.join("wrap.modax");
write_modax_wrapper(&modat, &modax, 256).unwrap();
let rec = open_recording_any(&modax).unwrap();
assert!(rec.header().num_active_channels() > 0);
let dax = dir.join("wrap.dax");
std::fs::copy(&modat, &dax).unwrap();
let rec2 = open_recording_any(&dax).unwrap();
assert_eq!(
rec2.header().sampling_frequency_hz,
Recording::open(&modat).unwrap().header().sampling_frequency_hz
);
let _ = std::fs::remove_dir_all(dir);
}
#[cfg(feature = "layouts")]
#[test]
fn copy_as_dat_still_opens() {
use crate::synthetic::{write_synthetic_well384, SyntheticWell384Options};
let dir = std::env::temp_dir().join(format!("med64-dat-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let modat = dir.join("t.modat");
write_synthetic_well384(&modat, &SyntheticWell384Options::default()).unwrap();
let dat = dir.join("t.dat");
std::fs::copy(&modat, &dat).unwrap();
let rec = open_recording_any(&dat).unwrap();
assert_eq!(rec.header().data_format_version, 6);
let _ = std::fs::remove_dir_all(dir);
}
}