136 lines
4.0 KiB
Rust
136 lines
4.0 KiB
Rust
use std::{convert::TryFrom, env::args, fs::File, io};
|
|
|
|
use eyre::Context;
|
|
use log::{error, info, trace};
|
|
use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
|
|
use regex::Regex;
|
|
use ros_message::{MessagePath, Msg};
|
|
use rsbag::{
|
|
chunk::ChunkHeader,
|
|
index::{BagIndex, ConnInfo},
|
|
reader::{BagReader, MmapReader},
|
|
Result,
|
|
};
|
|
|
|
fn parse_msgdef(message_name: &str, msgdef: &str) -> Result<Msg> {
|
|
trace!("message definition: {}", msgdef);
|
|
let path = MessagePath::try_from(message_name)?;
|
|
let msgtype = Msg::new(path, msgdef)?;
|
|
Ok(msgtype)
|
|
}
|
|
|
|
fn parse_message_definitions(conn: &ConnInfo) -> Result<Vec<Msg>> {
|
|
let msgdefs = &conn.message_definition;
|
|
let boundary_re = Regex::new(r"\r?\n==+\r?\nMSG: ([^\r\n]+)\r?\n")?;
|
|
let mut name = conn.datatype.clone();
|
|
let mut begin = 0usize;
|
|
let mut msgs = Vec::new();
|
|
|
|
for cap in boundary_re.captures_iter(msgdefs) {
|
|
let boundary_range = cap.get(0).unwrap();
|
|
let end = boundary_range.start();
|
|
|
|
let msgdef = &msgdefs[begin..end];
|
|
let msgtype = parse_msgdef(&name, msgdef)?;
|
|
msgs.push(msgtype);
|
|
|
|
name = cap[1].to_string();
|
|
begin = boundary_range.end();
|
|
}
|
|
|
|
let msgdef = &msgdefs[begin..];
|
|
|
|
let msg = parse_msgdef(&name, msgdef)?;
|
|
msgs.push(msg);
|
|
|
|
Ok(msgs)
|
|
}
|
|
|
|
fn read_chunk<R: BagReader>(bag_reader: &mut R, pos: u64) -> Result<Vec<u8>> {
|
|
let chunk_header = ChunkHeader::read(bag_reader, pos)?;
|
|
|
|
let compressed_data = bag_reader.read_data()?;
|
|
let mut data = Vec::with_capacity(chunk_header.uncompressed_size as usize);
|
|
let mut decompresor = chunk_header.compression.decompress(compressed_data);
|
|
io::copy(&mut decompresor, &mut data)?;
|
|
|
|
Ok(data)
|
|
}
|
|
|
|
fn main() -> Result<()> {
|
|
color_eyre::install()?;
|
|
env_logger::init();
|
|
|
|
let args: Vec<_> = args().collect();
|
|
if args.len() != 2 {
|
|
eprintln!("Usage: {} <bag path>", args[0]);
|
|
return Ok(());
|
|
}
|
|
|
|
let bag_path = &args[1];
|
|
let bag_file = File::open(bag_path).expect("Could not open bag file");
|
|
let mut bag_reader = MmapReader::new(bag_file)?;
|
|
|
|
let index = BagIndex::read_all(&mut bag_reader).wrap_err("bag parse error")?;
|
|
|
|
for conn in &index.connections {
|
|
match parse_message_definitions(conn) {
|
|
Ok(msgs) => {
|
|
for msg in &msgs {
|
|
trace!(
|
|
"message definition parsed: {:#?}",
|
|
msg.fields()
|
|
.iter()
|
|
.filter(|field| !field.is_constant())
|
|
.map(ToString::to_string)
|
|
.collect::<Vec<_>>()
|
|
);
|
|
}
|
|
}
|
|
Err(err) => error!("could not parse message definition: {}", err),
|
|
}
|
|
}
|
|
|
|
let total_size = index
|
|
.chunks
|
|
.par_iter()
|
|
.try_fold(
|
|
|| 0u64,
|
|
|total_size, chunk| -> rsbag::Result<_> {
|
|
let mut reader = bag_reader.clone();
|
|
let chunk_header = ChunkHeader::read(&mut reader, chunk.pos)?;
|
|
reader.skip_data()?;
|
|
|
|
// let data = read_chunk(&mut bag_reader.clone(), chunk.pos)?;
|
|
// chunks.push(data);
|
|
Ok(total_size + chunk_header.uncompressed_size as u64)
|
|
},
|
|
)
|
|
.reduce(
|
|
// || Ok(Vec::new()),
|
|
|| Ok(0),
|
|
|a, b| a.and_then(|a| b.map(|b| a + b)),
|
|
)
|
|
.unwrap();
|
|
|
|
// let total_size = index
|
|
// .chunks
|
|
// .par_iter()
|
|
// .try_fold(
|
|
// || 0u64,
|
|
// |total_size, chunk| -> Result<_> {
|
|
// let data = read_chunk(&mut bag_reader.clone(), chunk.pos)?;
|
|
// Ok(total_size + data.len() as u64)
|
|
// },
|
|
// )
|
|
// .reduce(
|
|
// // || Ok(Vec::new()),
|
|
// || Ok(0),
|
|
// |a, b| a.and_then(|a| b.map(|b| a + b)),
|
|
// )?;
|
|
|
|
info!("total uncompressed size: {}", total_size);
|
|
|
|
Ok(())
|
|
}
|