665bfac0b339
rle.rs
//! Compact text encodings of mattes for project storage: run-length coding (LEB128 varints)
//! wrapped in standard base64 (RFC 4648 §4).
pub fn base64_encode(data: &[u8]) -> String {
craft_mime::base64::STANDARD.encode(data)
}
pub fn base64_decode(s: &str) -> Option<Vec<u8>> {
base64_decode_bounded(s, usize::MAX)
}
fn base64_decode_bounded(s: &str, max_bytes: usize) -> Option<Vec<u8>> {
let val = |c: u8| -> Option<u32> {
Some(match c {
b'A'..=b'Z' => (c - b'A') as u32,
b'a'..=b'z' => (c - b'a' + 26) as u32,
b'0'..=b'9' => (c - b'0' + 52) as u32,
b'+' => 62,
b'/' => 63,
_ => return None,
})
};
let significant = s.bytes().filter(|c| !c.is_ascii_whitespace()).count();
let max_encoded = max_bytes.checked_add(2).and_then(|n| n.checked_div(3)).and_then(|n| n.checked_mul(4)).unwrap_or(usize::MAX);
if !significant.is_multiple_of(4) || significant > max_encoded {
return None;
}
let mut bytes = Vec::new();
bytes.try_reserve_exact(significant).ok()?;
bytes.extend(s.bytes().filter(|c| !c.is_ascii_whitespace()));
let decoded_len = bytes.len().checked_div(4)?.checked_mul(3)?;
if decoded_len > max_bytes.saturating_add(2) {
return None;
}
let mut out = Vec::new();
out.try_reserve_exact(decoded_len.min(max_bytes)).ok()?;
for c in bytes.chunks(4) {
let pad = c.iter().rev().take_while(|b| **b == b'=').count();
if pad > 2 || c[..4 - pad].contains(&b'=') {
return None;
}
let mut n = 0u32;
for (i, b) in c.iter().enumerate() {
n |= if *b == b'=' { 0 } else { val(*b)? } << (18 - 6 * i);
}
out.push((n >> 16) as u8);
if pad < 2 {
out.push((n >> 8) as u8);
}
if pad < 1 {
out.push(n as u8);
}
}
Some(out)
}
fn put(out: &mut Vec<u8>, mut v: u64) {
loop {
let b = (v & 0x7f) as u8;
v >>= 7;
if v == 0 {
out.push(b);
return;
}
out.push(b | 0x80);
}
}
fn get(data: &[u8], pos: &mut usize) -> Option<u64> {
let mut v = 0u64;
let mut shift = 0;
loop {
let b = *data.get(*pos)?;
*pos += 1;
v |= ((b & 0x7f) as u64) << shift;
if b & 0x80 == 0 {
return Some(v);
}
shift += 7;
if shift > 63 {
return None;
}
}
}
/// Encode a byte plane as (value, run length) pairs.
pub fn encode(values: &[u8]) -> String {
let mut out = vec![];
put(&mut out, values.len() as u64);
let mut i = 0;
while i < values.len() {
let v = values[i];
let mut j = i + 1;
while j < values.len() && values[j] == v {
j += 1;
}
out.push(v);
put(&mut out, (j - i) as u64);
i = j;
}
base64_encode(&out)
}
/// Decode [`encode`]'s output (None when malformed or larger than the caller's validated plane).
pub fn decode_bounded(s: &str, max_len: usize) -> Option<Vec<u8>> {
let encoded_limit = max_len.saturating_mul(16).saturating_add(128);
if s.len() > encoded_limit {
return None;
}
// An alternating byte plane takes at most one value byte and a ten-byte varint per
// pixel, plus the declared-length varint.
let decoded_limit = max_len.saturating_mul(11).saturating_add(10);
let data = base64_decode_bounded(s, decoded_limit)?;
let mut pos = 0;
let n = usize::try_from(get(&data, &mut pos)?).ok()?;
if n > max_len {
return None;
}
let mut out = Vec::new();
out.try_reserve_exact(n).ok()?;
while out.len() < n {
let v = *data.get(pos)?;
pos += 1;
let run = usize::try_from(get(&data, &mut pos)?).ok()?;
let next = out.len().checked_add(run)?;
if run == 0 || next > n {
return None;
}
out.resize(next, v);
}
Some(out)
}
/// Decode [`encode`]'s output, capped at the standard matte-plane limit.
pub fn decode(s: &str) -> Option<Vec<u8>> {
decode_bounded(s, MAX_PLANE_BYTES)
}
/// Maximum frozen matte plane size (256 MiB at one byte per pixel).
pub const MAX_PLANE_BYTES: usize = 256 * 1024 * 1024;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn refuses_oversized_and_zero_runs_before_expansion() {
let mut declared = Vec::new();
put(&mut declared, 1024);
declared.extend_from_slice(&[255, 0x80, 0x08]); // 1024-byte run
assert!(decode_bounded(&base64_encode(&declared), 16).is_none());
let mut zero_run = Vec::new();
put(&mut zero_run, 1);
zero_run.extend_from_slice(&[0, 0]);
assert!(decode_bounded(&base64_encode(&zero_run), 16).is_none());
assert!(decode_bounded(&"A".repeat(100_000), 16).is_none());
}
#[test]
fn round_trips() {
for n in [0usize, 1, 2, 3, 4, 5, 100, 1000] {
let v: Vec<u8> = (0..n).map(|i| ((i / 7) % 3) as u8 * 100).collect();
assert_eq!(decode(&encode(&v)).unwrap(), v, "RLE n={n}");
let raw: Vec<u8> = (0..n).map(|i| (i * 31) as u8).collect();
assert_eq!(base64_decode(&base64_encode(&raw)).unwrap(), raw);
}
assert_eq!(base64_encode(b"Man"), "TWFu");
assert_eq!(base64_encode(b"Ma"), "TWE=");
assert!(decode("!!!!").is_none());
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.