use std::collections::BTreeMap;
use crate::{Rd, Result, bad, capacity};
pub const PROGRAM_LOOKUP: u32 = 0xE2E6_955B;
pub const TEXTURE_LOOKUP: u32 = 0x2D25_4A89;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ProgramLookup {
pub head: Vec<u8>,
pub rows: BTreeMap<u64, Vec<u32>>,
pub order: Vec<u64>,
}
pub fn read_programs(d: &[u8], meta: &[u8; 16]) -> Result<ProgramLookup> {
let m = Rd::new(meta, "program lookup meta");
let (program, reloc, lookup) = (m.size32le(0)?, m.size32le(4)?, m.size32le(8)?);
let start = program.saturating_add(reloc);
let (head, rows) = d.split_at_checked(start).ok_or_else(|| {
bad(
"program lookup",
0,
"metadata does not match the payload: the program and relocation sizes pass the end",
)
})?;
if lookup < 4 || lookup != rows.len() {
return Err(bad(
"program lookup",
0,
format!(
"metadata does not match the payload: expected {lookup} bytes of rows (at least 4), found {}",
rows.len()
),
));
}
let r = Rd::new(d, "program lookup");
let count = r.size32le(start)?;
let mut pos = start.saturating_add(4);
let mut out = ProgramLookup {
head: head.to_vec(),
rows: BTreeMap::new(),
order: Vec::with_capacity(capacity(
"program lookup",
count,
12,
rows.len().saturating_sub(4),
)?),
};
for _ in 0..count {
let (key, n) = (r.u64le(pos)?, r.size32le(pos.saturating_add(8))?);
pos = pos.saturating_add(12);
if n == 0 || n > 4096 {
return Err(bad("program lookup", pos, format!("row of {n} programs")));
}
let row = (0..n)
.map(|i| r.u32le(crate::at(pos, i, 4)))
.collect::<Result<Vec<_>>>()?;
pos = crate::at(pos, n, 4);
if out.rows.contains_key(&key) {
return Err(bad("program lookup", pos, format!("repeated key {key:016x}")));
}
out.rows.insert(key, row);
out.order.push(key);
}
if pos != d.len() {
return Err(bad("program lookup", pos, "trailing data"));
}
Ok(out)
}
pub fn write_programs(t: &ProgramLookup, meta: &[u8; 16]) -> Result<(Vec<u8>, [u8; 16])> {
const W: &str = "program lookup";
let mut keys = t.order.clone();
let mut extra: Vec<u64> = t.rows.keys().copied().filter(|k| !t.order.contains(k)).collect();
keys.retain(|k| t.rows.contains_key(k));
keys.append(&mut extra);
let mut out = t.head.clone();
out.extend(crate::u32_len(W, keys.len())?.to_le_bytes());
for k in keys {
let row = t.rows.get(&k).map(Vec::as_slice).unwrap_or_default();
out.extend(k.to_le_bytes());
out.extend(crate::u32_len(W, row.len())?.to_le_bytes());
for p in row {
out.extend(p.to_le_bytes());
}
}
let mut m = *meta;
let rows_len = crate::u32_len(W, out.len().saturating_sub(t.head.len()))?;
if let Some(slot) = m.get_mut(8..12) {
slot.copy_from_slice(&rows_len.to_le_bytes());
}
Ok((out, m))
}
pub fn read_texture_sets(d: &[u8]) -> Result<Vec<(u64, u64)>> {
if !d.len().is_multiple_of(16) {
return Err(bad("texture set lookup", d.len(), "not a whole number of rows"));
}
let r = Rd::new(d, "texture set lookup");
(0..d.len() / 16)
.map(|i| Ok((r.u64le(crate::at(0, i, 16))?, r.u64le(crate::at(8, i, 16))?)))
.collect()
}
pub fn write_texture_sets(rows: &[(u64, u64)]) -> Vec<u8> {
rows.iter()
.flat_map(|(k, v)| k.to_le_bytes().into_iter().chain(v.to_le_bytes()))
.collect()
}
pub const RECORD_LEN: usize = 168;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ProgramRecord {
pub key: u64,
pub permutations: Vec<u64>,
pub raw: [u8; RECORD_LEN],
}
pub fn read_records(d: &[u8], meta: &[u8; 16]) -> Result<Vec<ProgramRecord>> {
let m = Rd::new(meta, "program lookup meta");
let program = m.size32le(0)?;
let r = Rd::new(
d.get(..program)
.ok_or_else(|| bad("program records", 0, "metadata does not match the payload"))?,
"program records",
);
let (count, first) = (r.size32le(0)?, r.offset64le(4)?);
count
.checked_mul(RECORD_LEN)
.and_then(|n| n.checked_add(first))
.filter(|&end| end <= program)
.ok_or_else(|| {
bad(
"program records",
first,
format!("{count} records past the program section"),
)
})?;
(0..count)
.map(|i| {
let at = crate::at(first, i, RECORD_LEN);
let (n, ptr) = (
r.size32le(at.saturating_add(0x60))?,
r.offset64le(at.saturating_add(0x64))?,
);
r.bytes(
ptr,
n.checked_mul(8)
.ok_or_else(|| bad("program records", at, "permutation count"))?,
)?;
Ok(ProgramRecord {
key: r.u64le(at)?,
permutations: (0..n)
.map(|j| r.u64le(crate::at(ptr, j, 8)))
.collect::<Result<_>>()?,
raw: r.arr::<RECORD_LEN>(at)?,
})
})
.collect()
}
pub const STREAMABLE_TEXTURE_SET: u32 = 0x7A63_0735;