Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

6.2 KB
Raw Blame
//! Decoder for the exact retained native-master profile, not arbitrary external
//! EXR import. Dimensions, header, offsets, row sizes and every sample are checked.
use super::{CancelToken, ErrorCode, JobError, Result};

fn invalid(message: &str) -> JobError {
    JobError::new(ErrorCode::InvalidRequest, message)
}

pub(super) struct Decoder {
    width: usize,
    height: usize,
    row: usize,
    table: usize,
    first: usize,
    pixels: Vec<[f32; 4]>,
}
impl Decoder {
    pub(super) fn new(bytes: &[u8], width: u32, height: u32, cancel: &CancelToken) -> Result<Self> {
        cancel.check()?;
        let limit = super::linear_exr::encoded_limit(width, height)?;
        let expected = super::linear_exr::native_header(bytes, width, height)?;
        if bytes.len() as u64 > limit {
            return Err(invalid("master is not the retained native FLOAT32 linear-sRGB/D65 profile"));
        }
        let first = expected.len() + height as usize * 8;
        let length = first + height as usize * (width as usize * 16 + 8);
        if bytes.len() != length {
            return Err(invalid("native master has missing or trailing scanline bytes"));
        }
        let count = width as usize * height as usize;
        let mut pixels = Vec::new();
        pixels.try_reserve_exact(count).map_err(|_| JobError::new(ErrorCode::AllocationFailed, "master decoding allocation failed"))?;
        if pixels.capacity() != count {
            return Err(invalid("master decoding exceeded admitted capacity"));
        }
        Ok(Self { width: width as usize, height: height as usize, row: 0, table: expected.len(), first, pixels })
    }
    pub(super) fn step(&mut self, bytes: &[u8], cancel: &CancelToken) -> Result<bool> {
        cancel.check()?;
        for _ in 0..4 {
            if self.row == self.height {
                break;
            }
            let row_bytes = self.width * 16;
            let offset = self.first + self.row * (row_bytes + 8);
            let table = self.table + self.row * 8;
            let stored = bytes.get(table..table + 8).and_then(|s| s.try_into().ok()).map(u64::from_le_bytes);
            let y = word(bytes, offset)?;
            let length = word(bytes, offset + 4)?;
            if stored != Some(offset as u64) || y != self.row as u32 || length as usize != row_bytes {
                return Err(invalid("native master scanline offset, index or length differs"));
            }
            for x in 0..self.width {
                if x % 4096 == 0 {
                    cancel.check()?;
                }
                let mut pixel = [0.0; 4];
                for (plane, channel) in [3, 2, 1, 0].into_iter().enumerate() {
                    pixel[channel] = f32::from_bits(word(bytes, offset + 8 + plane * self.width * 4 + x * 4)?);
                }
                if pixel.iter().any(|value| !value.is_finite() || *value < 0.0) || pixel[3] > 1.0 {
                    return Err(invalid("native master has invalid radiance or coverage"));
                }
                self.pixels.push(pixel);
            }
            self.row += 1;
        }
        cancel.check()?;
        Ok(self.row == self.height)
    }
    pub(super) fn rows(&self) -> u64 {
        self.row as u64
    }
    pub(super) fn finish(self) -> Result<Vec<[f32; 4]>> {
        if self.row != self.height {
            return Err(invalid("native master decoding is incomplete"));
        }
        Ok(self.pixels)
    }
}
fn word(bytes: &[u8], offset: usize) -> Result<u32> {
    bytes.get(offset..offset + 4).and_then(|s| s.try_into().ok()).map(u32::from_le_bytes).ok_or_else(|| invalid("truncated native master word"))
}

#[cfg(test)]
mod tests {
    use super::*;
    fn source() -> (Vec<u8>, Vec<[f32; 4]>) {
        let pixels = vec![[8.0, 0.1, 2.0, 0.5], [0.0, -0.0, 0.000001, 0.0]];
        let mut task = super::super::linear_exr::ExrTask::new(2, 1, pixels.clone(), CancelToken::default()).unwrap();
        assert!(task.step(1).unwrap());
        (task.finish().unwrap().0, pixels)
    }
    #[test]
    fn exact_native_profile_roundtrips_bits_and_rejects_wrong_layout_or_partial_decode() {
        let (bytes, pixels) = source();
        let cancel = CancelToken::default();
        let mut decoder = Decoder::new(&bytes, 2, 1, &cancel).unwrap();
        assert!(decoder.step(&bytes, &cancel).unwrap());
        assert_eq!(
            decoder.finish().unwrap().iter().map(|p| p.map(f32::to_bits)).collect::<Vec<_>>(),
            pixels.iter().map(|p| p.map(f32::to_bits)).collect::<Vec<_>>()
        );
        assert!(Decoder::new(&bytes, 1, 2, &cancel).is_err());
        assert!(Decoder::new(&bytes[..bytes.len() - 1], 2, 1, &cancel).is_err());
        assert!(Decoder::new(&bytes, 2, 1, &cancel).unwrap().finish().is_err());
        let mut corrupt = bytes.clone();
        let table = super::super::linear_exr::header(2, 1).unwrap().len();
        corrupt[table] ^= 1;
        assert!(Decoder::new(&corrupt, 2, 1, &cancel).unwrap().step(&corrupt, &cancel).is_err());
        let mut corrupt = bytes.clone();
        let last = corrupt.len() - 4;
        corrupt[last..].copy_from_slice(&f32::NAN.to_le_bytes());
        assert!(Decoder::new(&corrupt, 2, 1, &cancel).unwrap().step(&corrupt, &cancel).is_err());
        let mut decoder = Decoder::new(&bytes, 2, 1, &cancel).unwrap();
        cancel.cancel();
        assert!(decoder.step(&bytes, &cancel).is_err());
        assert_eq!(decoder.rows(), 0);
    }
    #[cfg(feature = "raytrace-cpu")]
    #[test]
    fn cpu_native_master_roundtrips_without_accepting_arbitrary_software_headers() {
        let pixels = vec![[8.0, 0.25, 0.5, 0.75], [0.0, 0.0, 0.0, 0.0]];
        let mut task = super::super::linear_exr::ExrTask::new_cpu(2, 1, pixels.clone(), CancelToken::default()).unwrap();
        assert!(task.step(1).unwrap());
        let (bytes, _) = task.finish().unwrap();
        let mut decoder = Decoder::new(&bytes, 2, 1, &CancelToken::default()).unwrap();
        assert!(decoder.step(&bytes, &CancelToken::default()).unwrap());
        assert_eq!(decoder.finish().unwrap(), pixels);
        let mut foreign = bytes;
        let at = foreign.windows(b"SolidCraft native CPU raytrace".len()).position(|w| w == b"SolidCraft native CPU raytrace").unwrap();
        foreign[at] ^= 1;
        assert!(Decoder::new(&foreign, 2, 1, &CancelToken::default()).is_err());
    }
}