pub const TOUCH_MAP_MAGIC: u8 = 0x7A;
pub const TOUCH_MAP_VERSION: u8 = 0x01;
pub const TOUCH_MAP_FLAG_OVERFLOWED: u8 = 1 << 0;
pub const TOUCH_MAP_FLAG_SKIPPED: u8 = 1 << 1;
pub const TOUCH_MAP_HEADER_LEN: usize = 4;
pub const TOUCH_MAP_RECORD_LEN: usize = 9;
pub const MAX_TOUCH_RECORDS: usize = 32;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct TouchRecord {
pub slot: u8,
pub offset: u32,
pub size: u32,
pub write: bool,
}
impl TouchRecord {
pub fn end(&self) -> u64 {
self.offset as u64 + self.size as u64
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct TouchMap {
pub overflowed: bool,
pub skipped: bool,
pub records: Vec<TouchRecord>,
}
impl TouchMap {
pub fn is_partial(&self) -> bool {
self.overflowed || self.skipped
}
pub fn writes(&self) -> impl Iterator<Item = &TouchRecord> {
self.records.iter().filter(|r| r.write)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DecodeError {
TooShort { len: usize },
BadMagic(u8),
BadVersion(u8),
LengthMismatch {
declared_count: usize,
expected_len: usize,
actual_len: usize,
},
}
impl core::fmt::Display for DecodeError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
DecodeError::TooShort { len } => {
write!(
f,
"touch map too short: {len} bytes (need >= {TOUCH_MAP_HEADER_LEN})"
)
}
DecodeError::BadMagic(b) => {
write!(
f,
"bad touch-map magic: 0x{b:02x} (expected 0x{TOUCH_MAP_MAGIC:02x})"
)
}
DecodeError::BadVersion(b) => {
write!(
f,
"bad touch-map version: 0x{b:02x} (expected 0x{TOUCH_MAP_VERSION:02x})"
)
}
DecodeError::LengthMismatch {
declared_count,
expected_len,
actual_len,
} => write!(
f,
"touch-map length mismatch: count {declared_count} implies {expected_len} bytes, \
got {actual_len}"
),
}
}
}
impl std::error::Error for DecodeError {}
pub fn decode_touch_map(bytes: &[u8]) -> Result<TouchMap, DecodeError> {
if bytes.len() < TOUCH_MAP_HEADER_LEN {
return Err(DecodeError::TooShort { len: bytes.len() });
}
if bytes[0] != TOUCH_MAP_MAGIC {
return Err(DecodeError::BadMagic(bytes[0]));
}
if bytes[1] != TOUCH_MAP_VERSION {
return Err(DecodeError::BadVersion(bytes[1]));
}
let flags = bytes[2];
let count = bytes[3] as usize;
let expected_len = TOUCH_MAP_HEADER_LEN + count * TOUCH_MAP_RECORD_LEN;
if bytes.len() != expected_len {
return Err(DecodeError::LengthMismatch {
declared_count: count,
expected_len,
actual_len: bytes.len(),
});
}
let mut records = Vec::with_capacity(count);
for i in 0..count {
let base = TOUCH_MAP_HEADER_LEN + i * TOUCH_MAP_RECORD_LEN;
let packed = u32::from_le_bytes(bytes[base + 1..base + 5].try_into().unwrap());
let size = u32::from_le_bytes(bytes[base + 5..base + 9].try_into().unwrap());
records.push(TouchRecord {
slot: bytes[base],
offset: packed & 0x7FFF_FFFF,
size,
write: packed & 0x8000_0000 != 0,
});
}
Ok(TouchMap {
overflowed: flags & TOUCH_MAP_FLAG_OVERFLOWED != 0,
skipped: flags & TOUCH_MAP_FLAG_SKIPPED != 0,
records,
})
}