use crate::writer::ByteWriter;
mod matrix;
pub use matrix::matrix;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum TestCodec {
#[default]
None,
Lzma,
Lz4,
Lz4Hc,
Raw(u8),
}
impl TestCodec {
#[must_use]
pub fn id(self) -> u8 {
match self {
Self::None => 0,
Self::Lzma => 1,
Self::Lz4 => 2,
Self::Lz4Hc => 3,
Self::Raw(n) => n,
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct BlockOverride {
pub block: usize,
pub codec: Option<TestCodec>,
pub uncompressed: Option<u32>,
pub compressed: Option<u32>,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct EntrySpec {
pub name: Vec<u8>,
pub data: Vec<u8>,
pub flags: u32,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct BundleSpec {
pub format: u32,
pub version_player: Vec<u8>,
pub version_engine: Vec<u8>,
pub info_codec: TestCodec,
pub data_codec: TestCodec,
pub block_size: usize,
pub info_at_end: bool,
pub entries: Vec<EntrySpec>,
pub extra_flags: u32,
pub block_overrides: Vec<BlockOverride>,
pub truncate_to: Option<usize>,
pub encrypted: bool,
}
impl Default for BundleSpec {
fn default() -> Self {
Self {
format: 7,
version_player: b"5.x.x".to_vec(),
version_engine: b"2022.3.0f1".to_vec(),
info_codec: TestCodec::Lz4,
data_codec: TestCodec::Lz4,
block_size: 128 << 10,
info_at_end: false,
entries: Vec::new(),
extra_flags: 0,
block_overrides: Vec::new(),
truncate_to: None,
encrypted: false,
}
}
}
#[must_use]
pub fn compress(codec: TestCodec, data: &[u8]) -> Vec<u8> {
match codec {
TestCodec::None | TestCodec::Raw(_) => data.to_vec(),
TestCodec::Lz4 | TestCodec::Lz4Hc => lz4_flex::block::compress(data),
TestCodec::Lzma => lzma(data),
}
}
pub const LZMA_DICT: u32 = 1 << 19;
thread_local! {
static LZMA_MEMO: std::cell::RefCell<std::collections::HashMap<Vec<u8>, Vec<u8>>> =
std::cell::RefCell::new(std::collections::HashMap::new());
}
fn lzma(data: &[u8]) -> Vec<u8> {
let mut out = ByteWriter::le();
out.u8(0x5D).u32(LZMA_DICT);
let mut out = out.into_inner();
if let Some(hit) = LZMA_MEMO.with(|m| m.borrow().get(data).cloned()) {
out.extend_from_slice(&hit);
return out;
}
let stream = lzma_encode(data);
LZMA_MEMO.with(|m| {
let mut m = m.borrow_mut();
if m.len() >= 4096 {
m.clear();
}
m.insert(data.to_vec(), stream.clone());
});
out.extend_from_slice(&stream);
out
}
fn lzma_encode(data: &[u8]) -> Vec<u8> {
use liblzma::stream::{Action, Filters, LzmaOptions, Status, Stream};
let mut opts = LzmaOptions::new_preset(1).unwrap_or_else(|_| LzmaOptions::new());
opts.dict_size(LZMA_DICT)
.literal_context_bits(3)
.literal_position_bits(0)
.position_bits(2);
let mut filters = Filters::new();
filters.lzma1(&opts);
let Ok(mut stream) = Stream::new_raw_encoder(&filters) else {
return Vec::new();
};
let mut buf = vec![0u8; data.len() + data.len() / 2 + 1024];
loop {
let (read, written) = (stream.total_in(), stream.total_out());
let input = data.get(as_usize(read)..).unwrap_or_default();
let window = buf.get_mut(as_usize(written)..).unwrap_or_default();
match stream.process(input, window, Action::Finish) {
Ok(Status::StreamEnd) | Err(_) => break,
Ok(_) if window_full(&stream, buf.len()) => buf.resize(buf.len() * 2, 0),
Ok(_) => {}
}
}
buf.truncate(as_usize(stream.total_out()));
buf
}
fn window_full(stream: &liblzma::stream::Stream, len: usize) -> bool {
as_usize(stream.total_out()) >= len
}
fn as_usize(n: u64) -> usize {
usize::try_from(n).unwrap_or(usize::MAX)
}
fn engine_triple(engine: &[u8]) -> Option<(u32, u32, u32)> {
let s = std::str::from_utf8(engine).ok()?;
let mut parts = s.splitn(3, '.');
let major = parts.next()?.parse().ok()?;
let minor = parts.next()?.parse().ok()?;
let rest = parts.next()?;
let digits: String = rest.chars().take_while(char::is_ascii_digit).collect();
Some((major, minor, digits.parse().ok()?))
}
fn new_flags(engine: &[u8]) -> bool {
let Some(v) = engine_triple(engine) else {
return false;
};
!(v < (2020, 0, 0)
|| (v.0 == 2020 && v < (2020, 3, 34))
|| (v.0 == 2021 && v < (2021, 3, 2))
|| (v.0 == 2022 && v < (2022, 1, 1)))
}
fn aligned(format: u32, engine: &[u8]) -> bool {
format >= 7 || engine_triple(engine).is_some_and(|v| v.0 == 2019 && v >= (2019, 4, 15))
}
#[must_use]
pub fn build(spec: &BundleSpec) -> Vec<u8> {
build_with_signature(spec, b"UnityFS")
}
#[must_use]
pub fn build_with_signature(spec: &BundleSpec, signature: &[u8]) -> Vec<u8> {
build_with_encoder(spec, signature, compress)
}
#[must_use]
pub fn build_with_encoder(
spec: &BundleSpec,
signature: &[u8],
encode: impl Fn(TestCodec, &[u8]) -> Vec<u8>,
) -> Vec<u8> {
let mut data = Vec::new();
let mut directory = ByteWriter::be();
directory.i32(i32::try_from(spec.entries.len()).unwrap_or(i32::MAX));
for e in &spec.entries {
directory
.i64(i64::try_from(data.len()).unwrap_or(i64::MAX))
.i64(i64::try_from(e.data.len()).unwrap_or(i64::MAX))
.u32(e.flags)
.cstr(&e.name);
data.extend_from_slice(&e.data);
}
let size = spec.block_size.max(1);
let mut stored = Vec::new();
let mut rows = ByteWriter::be();
let chunks: Vec<&[u8]> = data.chunks(size).collect();
let count = chunks.len().max(
spec.block_overrides
.iter()
.map(|o| o.block + 1)
.max()
.unwrap_or(0),
);
rows.bytes(&[0; 16]);
rows.i32(i32::try_from(count).unwrap_or(i32::MAX));
for i in 0..count {
let chunk = chunks.get(i).copied().unwrap_or_default();
let over = spec.block_overrides.iter().find(|o| o.block == i);
let codec = over.and_then(|o| o.codec).unwrap_or(spec.data_codec);
let bytes = encode(codec, chunk);
let uncompressed = over
.and_then(|o| o.uncompressed)
.unwrap_or_else(|| u32::try_from(chunk.len()).unwrap_or(u32::MAX));
let compressed = over
.and_then(|o| o.compressed)
.unwrap_or_else(|| u32::try_from(bytes.len()).unwrap_or(u32::MAX));
rows.u32(uncompressed)
.u32(compressed)
.u16(u16::from(codec.id()));
stored.extend_from_slice(&bytes);
}
rows.bytes(directory.as_slice());
let info = rows.into_inner();
let info_stored = encode(spec.info_codec, &info);
let mut flags = u32::from(spec.info_codec.id()) | 0x40 | spec.extra_flags;
if spec.info_at_end {
flags |= 0x80;
}
if spec.encrypted {
flags |= if new_flags(&spec.version_engine) {
0x1000
} else {
0x200
};
}
let mut w = ByteWriter::be();
w.cstr(signature)
.u32(spec.format)
.cstr(&spec.version_player)
.cstr(&spec.version_engine);
let size_at = w.len();
w.i64(0)
.u32(u32::try_from(info_stored.len()).unwrap_or(u32::MAX))
.u32(u32::try_from(info.len()).unwrap_or(u32::MAX))
.u32(flags);
if signature != b"UnityFS" {
w.u8(0);
}
if spec.encrypted {
w.u32(0).bytes(&[0; 2 * (16 + 16 + 1)]);
}
if aligned(spec.format, &spec.version_engine) {
w.align(16);
}
let pad = flags & 0x200 != 0 && new_flags(&spec.version_engine);
if !spec.info_at_end {
w.bytes(&info_stored);
}
if pad {
w.align(16);
}
w.bytes(&stored);
if spec.info_at_end {
w.bytes(&info_stored);
}
let mut file = w.into_inner();
let mut total = ByteWriter::be();
total.i64(i64::try_from(file.len()).unwrap_or(i64::MAX));
if let Some(at) = file.get_mut(size_at..size_at + 8) {
at.copy_from_slice(total.as_slice());
}
if let Some(n) = spec.truncate_to {
file.truncate(n);
}
file
}
#[cfg(test)]
mod tests;