const FCC_RIFF: [u8; 4] = *b"RIFF";
const FCC_WEBP: [u8; 4] = *b"WEBP";
const FCC_VP8X: [u8; 4] = *b"VP8X";
const FCC_EXIF: [u8; 4] = *b"EXIF";
const EXIF_HEADER: [u8; 6] = *b"Exif\0\0";
const VP8X_FLAG_ICC: u8 = 1 << 5;
const VP8X_FLAG_ALPHA: u8 = 1 << 4;
const VP8X_FLAG_EXIF: u8 = 1 << 3;
#[allow(dead_code)]
const VP8X_FLAG_XMP: u8 = 1 << 2;
const VP8X_FLAG_ANIMATION: u8 = 1 << 1;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Chunk {
pub id: [u8; 4],
pub payload: Vec<u8>,
}
impl Chunk {
fn new(id: [u8; 4], payload: Vec<u8>) -> Self {
Chunk { id, payload }
}
}
#[must_use]
pub fn parse_webp(data: &[u8]) -> Option<Vec<Chunk>> {
if data.len() < 12 || data[0..4] != FCC_RIFF || data[8..12] != FCC_WEBP {
return None;
}
let declared = u32::from_le_bytes([data[4], data[5], data[6], data[7]]) as usize;
let available = data.len() - 8;
let body_len = if (4..=available).contains(&declared) {
declared - 4
} else {
available - 4
};
let mut chunks = Vec::new();
let mut offset = 12;
let end = 12 + body_len;
while offset + 8 <= end.min(data.len()) {
let id: [u8; 4] = data[offset..offset + 4].try_into().ok()?;
let size = u32::from_le_bytes(data[offset + 4..offset + 8].try_into().ok()?) as usize;
offset += 8;
let payload_end = offset.checked_add(size)?;
if payload_end > data.len() {
return None;
}
chunks.push(Chunk::new(id, data[offset..payload_end].to_vec()));
offset = payload_end;
if size % 2 == 1 {
offset += 1;
}
}
Some(chunks)
}
fn write_webp(chunks: &[Chunk]) -> Vec<u8> {
let body_size: usize = chunks
.iter()
.map(|chunk| 8 + chunk.payload.len() + (chunk.payload.len() % 2))
.sum();
let mut out = Vec::with_capacity(12 + body_size);
out.extend_from_slice(&FCC_RIFF);
out.extend_from_slice(
&u32::try_from(4 + body_size)
.unwrap_or(u32::MAX)
.to_le_bytes(),
);
out.extend_from_slice(&FCC_WEBP);
for chunk in chunks {
out.extend_from_slice(&chunk.id);
out.extend_from_slice(
&u32::try_from(chunk.payload.len())
.unwrap_or(u32::MAX)
.to_le_bytes(),
);
out.extend_from_slice(&chunk.payload);
if chunk.payload.len() % 2 == 1 {
out.push(0);
}
}
out
}
fn order_rank(id: &[u8; 4]) -> u8 {
match id {
_ if id == &FCC_VP8X => 0,
b"ICCP" => 1,
b"ANIM" | b"ANMF" | b"ALPH" | b"VP8 " | b"VP8L" => 2,
_ if id == &FCC_EXIF => 4,
b"XMP " => 5,
_ => 6, }
}
#[must_use]
pub fn extract_exif_payload(webp: &[u8]) -> Option<Vec<u8>> {
let chunks = parse_webp(webp)?;
let chunk = chunks.iter().find(|chunk| chunk.id == FCC_EXIF)?;
let payload = strip_exif_header(&chunk.payload);
if payload.is_empty() {
None
} else {
Some(payload.to_vec())
}
}
#[must_use]
pub fn strip_exif_header(body: &[u8]) -> &[u8] {
if body.len() > EXIF_HEADER.len() && body[..EXIF_HEADER.len()] == EXIF_HEADER {
&body[EXIF_HEADER.len()..]
} else {
body
}
}
#[must_use]
pub fn mux_exif(webp: &[u8], tiff_payload: &[u8]) -> Option<Vec<u8>> {
if tiff_payload.is_empty() {
return None;
}
let mut chunks = parse_webp(webp)?;
if !chunks
.iter()
.any(|chunk| chunk.id == *b"VP8 " || chunk.id == *b"VP8L" || chunk.id == *b"ANMF")
{
return None;
}
chunks.retain(|chunk| chunk.id != FCC_EXIF);
match chunks.iter_mut().find(|chunk| chunk.id == FCC_VP8X) {
Some(vp8x) => {
if let Some(flags) = vp8x.payload.first_mut() {
*flags |= VP8X_FLAG_EXIF;
}
}
None => {
let vp8x = build_vp8x(&chunks)?;
chunks.insert(0, Chunk::new(FCC_VP8X, vp8x));
}
}
let mut ranked: Vec<(u8, Chunk)> = chunks
.into_iter()
.map(|chunk| {
let rank = order_rank(&chunk.id);
(rank, chunk)
})
.collect();
let exif = Chunk::new(FCC_EXIF, embed_body(tiff_payload));
ranked.push((order_rank(&FCC_EXIF), exif));
ranked.sort_by_key(|(rank, _)| *rank);
let ordered: Vec<Chunk> = ranked.into_iter().map(|(_, chunk)| chunk).collect();
Some(write_webp(&ordered))
}
fn embed_body(tiff_payload: &[u8]) -> Vec<u8> {
let mut body = Vec::with_capacity(EXIF_HEADER.len() + tiff_payload.len());
body.extend_from_slice(&EXIF_HEADER);
body.extend_from_slice(tiff_payload);
body
}
fn build_vp8x(chunks: &[Chunk]) -> Option<Vec<u8>> {
for chunk in chunks {
match &chunk.id {
b"VP8L" => {
if let Some(((width, height), alpha)) = parse_vp8l_header(&chunk.payload) {
return Some(vp8x_payload(
width,
height,
alpha,
has_icc(chunks),
has_anim(chunks),
true,
));
}
}
b"VP8 " => {
if let Some(((width, height), _)) = parse_vp8_header(&chunk.payload) {
let alpha = false;
return Some(vp8x_payload(
width,
height,
alpha,
has_icc(chunks),
has_anim(chunks),
true,
));
}
}
_ => {}
}
}
None
}
fn has_icc(chunks: &[Chunk]) -> bool {
chunks.iter().any(|chunk| chunk.id == *b"ICCP")
}
fn has_anim(chunks: &[Chunk]) -> bool {
chunks.iter().any(|chunk| chunk.id == *b"ANIM")
}
fn vp8x_payload(
width: u32,
height: u32,
alpha: bool,
icc: bool,
anim: bool,
exif: bool,
) -> Vec<u8> {
let mut flags = 0u8;
if icc {
flags |= VP8X_FLAG_ICC;
}
if alpha {
flags |= VP8X_FLAG_ALPHA;
}
if anim {
flags |= VP8X_FLAG_ANIMATION;
}
if exif {
flags |= VP8X_FLAG_EXIF;
}
let mut payload = Vec::with_capacity(10);
payload.push(flags);
payload.extend_from_slice(&[0, 0, 0]); payload.extend_from_slice(&(width - 1).to_le_bytes()[..3]);
payload.extend_from_slice(&(height - 1).to_le_bytes()[..3]);
payload
}
fn parse_vp8l_header(payload: &[u8]) -> Option<((u32, u32), bool)> {
if payload.len() < 5 || payload[0] != 0x2f {
return None;
}
let header = u32::from_le_bytes(payload[1..5].try_into().ok()?);
let width = (header & 0x3fff) + 1;
let height = ((header >> 14) & 0x3fff) + 1;
let alpha = (header >> 28) & 1 == 1;
Some(((width, height), alpha))
}
fn parse_vp8_header(payload: &[u8]) -> Option<((u32, u32), bool)> {
if payload.len() < 10 {
return None;
}
let frame_tag =
u32::from(payload[0]) | u32::from(payload[1]) << 8 | u32::from(payload[2]) << 16;
let key_frame = frame_tag & 1 == 0;
if !key_frame || payload[3..6] != [0x9d, 0x01, 0x2a] {
return None;
}
let width = u32::from(payload[6]) | u32::from(payload[7]) << 8;
let height = u32::from(payload[8]) | u32::from(payload[9]) << 8;
let width = (width & 0x3fff) + (((width & 0xc000) >> 14) << 14);
let height = (height & 0x3fff) + (((height & 0xc000) >> 14) << 14);
Some(((width, height), true))
}
#[cfg(test)]
mod tests {
use super::*;
fn minimal_vp8l(width: u32, height: u32, alpha: bool) -> Chunk {
let header: u32 = (width - 1) | (height - 1) << 14 | u32::from(alpha) << 28;
let mut payload = vec![0x2f];
payload.extend_from_slice(&header.to_le_bytes());
payload.extend_from_slice(&[0x00]); Chunk::new(*b"VP8L", payload)
}
#[test]
fn parse_rejects_non_webp_and_accepts_simple_container() {
assert!(parse_webp(b"not a webp").is_none());
let webp = write_webp(&[minimal_vp8l(4, 2, false)]);
let chunks = parse_webp(&webp).expect("valid container");
assert_eq!(chunks.len(), 1);
assert_eq!(chunks[0].id, *b"VP8L");
}
#[test]
fn extract_finds_exif_and_strips_marker_prefix() {
let tiff = b"II*\0\x08\0\0\0\0\0".to_vec();
let mut body = EXIF_HEADER.to_vec();
body.extend_from_slice(&tiff);
let webp = write_webp(&[
Chunk::new(FCC_VP8X, vp8x_payload(4, 2, false, false, false, false)),
minimal_vp8l(4, 2, false),
Chunk::new(FCC_EXIF, body),
]);
assert_eq!(
extract_exif_payload(&webp).as_deref(),
Some(tiff.as_slice())
);
}
#[test]
fn extract_handles_prefixless_bodies_and_missing_chunks() {
let tiff = b"II*\0\x08\0\0\0\0\0";
let webp = write_webp(&[
Chunk::new(FCC_VP8X, vp8x_payload(4, 2, false, false, false, false)),
Chunk::new(FCC_EXIF, tiff.to_vec()),
]);
assert_eq!(
extract_exif_payload(&webp).as_deref(),
Some(tiff.as_slice())
);
let plain = write_webp(&[minimal_vp8l(4, 2, false)]);
assert!(extract_exif_payload(&plain).is_none());
assert!(extract_exif_payload(b"RIFF").is_none());
}
#[test]
fn mux_adds_vp8x_with_exif_flag_for_simple_containers() {
let webp = write_webp(&[minimal_vp8l(4, 2, true)]);
let tiff = b"II*\0\x08\0\0\0\0\0";
let muxed = mux_exif(&webp, tiff).expect("muxed");
let chunks = parse_webp(&muxed).expect("parses");
assert_eq!(chunks.len(), 3, "VP8X + VP8L + EXIF");
assert_eq!(chunks[0].id, *b"VP8X");
assert_eq!(chunks[0].payload[0] & VP8X_FLAG_EXIF, VP8X_FLAG_EXIF);
assert_eq!(chunks[0].payload[0] & VP8X_FLAG_ALPHA, VP8X_FLAG_ALPHA);
let w = u32::from(chunks[0].payload[4])
| u32::from(chunks[0].payload[5]) << 8
| u32::from(chunks[0].payload[6]) << 16;
assert_eq!(w + 1, 4);
assert_eq!(chunks[1].id, *b"VP8L");
assert_eq!(chunks[2].id, FCC_EXIF);
}
#[test]
fn mux_replaces_existing_exif_and_keeps_order() {
let tiff_a = b"II*\0\x08\0\0\0\0\0";
let container = mux_exif(&write_webp(&[minimal_vp8l(4, 2, false)]), tiff_a).expect("muxed");
let tiff_b = b"MM\0*\0\0\0\x10\0\0".to_vec();
let remuxed = mux_exif(&container, &tiff_b).expect("remuxed");
let chunks = parse_webp(&remuxed).expect("parses");
let exif_chunks = chunks.iter().filter(|chunk| chunk.id == FCC_EXIF).count();
assert_eq!(exif_chunks, 1, "existing EXIF chunk must be replaced");
let stored = chunks
.iter()
.find(|chunk| chunk.id == FCC_EXIF)
.expect("exif");
assert_eq!(strip_exif_header(&stored.payload), tiff_b.as_slice());
}
#[test]
fn mux_rejects_malformed_input_and_empty_payloads() {
assert!(mux_exif(b"garbage data!", b"II*\0").is_none());
let webp = write_webp(&[minimal_vp8l(4, 2, false)]);
assert!(mux_exif(&webp, &[]).is_none());
}
#[test]
fn mux_preserves_odd_sized_unknown_chunks() {
let unknown = Chunk::new(*b"XYZW", vec![0xaa]);
let webp = write_webp(&[minimal_vp8l(4, 2, false), unknown]);
let muxed = mux_exif(&webp, b"II*\0\x08\0\0\0\0\0").expect("muxed");
let chunks = parse_webp(&muxed).expect("parses");
let xyzw = chunks
.iter()
.find(|chunk| chunk.id == *b"XYZW")
.expect("kept");
assert_eq!(xyzw.payload, vec![0xaa]);
let ids: Vec<[u8; 4]> = chunks.iter().map(|chunk| chunk.id).collect();
assert_eq!(ids, vec![*b"VP8X", *b"VP8L", FCC_EXIF, *b"XYZW"]);
}
}