Skip to content

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

6.9 KB
Raw Blame
//! Shared bounded, cancellable sRGB PNG row encoder for CPU image integrators.
use super::{CancelToken, ErrorCode, JobError, Result};
use std::io::Write;
use std::sync::{Arc, Mutex};

struct BufferWriter {
    bytes: Arc<Mutex<Vec<u8>>>,
    limit: usize,
    cancel: CancelToken,
}

impl Write for BufferWriter {
    fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
        if self.cancel.is_cancelled() {
            return Err(std::io::Error::other("render cancelled"));
        }
        let mut out = self.bytes.lock().map_err(|_| std::io::Error::other("PNG output lock poisoned"))?;
        if out.len().checked_add(bytes.len()).is_none_or(|n| n > self.limit) {
            return Err(std::io::Error::other("PNG output exceeds its byte budget"));
        }
        out.try_reserve_exact(bytes.len()).map_err(|_| std::io::Error::other("PNG allocation failed"))?;
        out.extend_from_slice(bytes);
        Ok(bytes.len())
    }
    fn flush(&mut self) -> std::io::Result<()> {
        if self.cancel.is_cancelled() { Err(std::io::Error::other("render cancelled")) } else { Ok(()) }
    }
}

pub(crate) struct PngEncoding {
    bytes: Arc<Mutex<Vec<u8>>>,
    writer: Option<png::StreamWriter<'static, BufferWriter>>,
    width: usize,
    height: usize,
    row: usize,
    cancel: CancelToken,
}

impl PngEncoding {
    pub(crate) fn new(width: u32, height: u32, limit: u64, cancel: CancelToken) -> Result<Self> {
        cancel.check()?;
        let limit = usize::try_from(limit).map_err(|_| JobError::new(ErrorCode::LimitExceeded, "PNG byte budget exceeds addressable memory"))?;
        let bytes = Arc::new(Mutex::new(Vec::new()));
        let writer = BufferWriter { bytes: bytes.clone(), limit, cancel: cancel.clone() };
        let mut encoder = png::Encoder::new(writer, width, height);
        encoder.set_color(png::ColorType::Rgba);
        encoder.set_depth(png::BitDepth::Eight);
        encoder.set_source_srgb(png::SrgbRenderingIntent::Perceptual);
        let writer =
            encoder.write_header().and_then(|w| w.into_stream_writer()).map_err(|e| JobError::new(ErrorCode::EncodingFailed, e.to_string()))?;
        Ok(Self { bytes, writer: Some(writer), width: width as usize, height: height as usize, row: 0, cancel })
    }

    /// Adopt a caller-admitted output capacity without duplicating codec setup.
    /// Tiny header storage overlaps transiently with output within codec overhead.
    pub(crate) fn with_output(width: u32, height: u32, limit: u64, cancel: CancelToken, mut output: Vec<u8>) -> Result<Self> {
        let admitted = usize::try_from(limit).map_err(|_| JobError::new(ErrorCode::LimitExceeded, "PNG limit exceeds address space"))?;
        if !output.is_empty() || output.capacity() != admitted {
            return Err(JobError::new(ErrorCode::LimitExceeded, "PNG output capacity differs from admission"));
        }
        let encoder = Self::new(width, height, limit, cancel)?;
        {
            let mut bytes = encoder.bytes.lock().map_err(|_| JobError::new(ErrorCode::Internal, "PNG output lock poisoned"))?;
            if bytes.len() > output.capacity() {
                return Err(JobError::new(ErrorCode::LimitExceeded, "PNG header exceeds output admission"));
            }
            output.extend_from_slice(&bytes);
            *bytes = output;
        }
        Ok(encoder)
    }

    pub(crate) fn row(&self) -> usize {
        self.row
    }

    /// Writes at most one row; callers retain the four-row-per-quantum limit.
    pub(crate) fn step(&mut self, rgba: &[u8]) -> Result<Option<Vec<u8>>> {
        self.cancel.check()?;
        if self.row < self.height {
            let length = self.width.checked_mul(4).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "PNG row overflow"))?;
            let start = self.row.checked_mul(length).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "PNG row offset overflow"))?;
            let end = start.checked_add(length).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "PNG row end overflow"))?;
            let row = rgba.get(start..end).ok_or_else(|| JobError::new(ErrorCode::InvalidScene, "missing PNG row"))?;
            self.writer
                .as_mut()
                .ok_or_else(|| JobError::new(ErrorCode::Internal, "missing PNG writer"))?
                .write_all(row)
                .map_err(|e| JobError::new(ErrorCode::EncodingFailed, e.to_string()))?;
            self.row += 1;
            return Ok(None);
        }
        self.writer
            .take()
            .ok_or_else(|| JobError::new(ErrorCode::Internal, "missing PNG writer"))?
            .finish()
            .map_err(|e| JobError::new(ErrorCode::EncodingFailed, e.to_string()))?;
        self.cancel.check()?;
        let mut bytes = self.bytes.lock().map_err(|_| JobError::new(ErrorCode::Internal, "PNG output lock poisoned"))?;
        let png = std::mem::take(&mut *bytes);
        if !png.starts_with(b"\x89PNG\r\n\x1a\n") {
            return Err(JobError::new(ErrorCode::EncodingFailed, "invalid PNG output"));
        }
        Ok(Some(png))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn rows_roundtrip_and_cancel_before_finish_never_returns_png() {
        let rgba = [20, 40, 60, 255, 80, 100, 120, 255];
        let cancel = CancelToken::default();
        let mut encoder = PngEncoding::new(1, 2, 65536, cancel.clone()).unwrap();
        assert!(encoder.step(&rgba).unwrap().is_none());
        assert_eq!(encoder.row(), 1);
        assert!(encoder.step(&rgba).unwrap().is_none());
        assert_eq!(encoder.row(), 2);
        cancel.cancel();
        assert_eq!(encoder.step(&rgba).unwrap_err().code, ErrorCode::Cancelled);

        let mut encoder = PngEncoding::new(1, 2, 65536, CancelToken::default()).unwrap();
        assert!(encoder.step(&rgba).unwrap().is_none());
        assert!(encoder.step(&rgba).unwrap().is_none());
        let png = encoder.step(&rgba).unwrap().unwrap();
        let decoded = image::load_from_memory(&png).unwrap().to_rgba8();
        assert_eq!(decoded.dimensions(), (1, 2));
        assert_eq!(decoded.as_raw(), &rgba);
    }

    #[test]
    fn encoded_byte_budget_and_missing_rows_are_errors() {
        assert!(PngEncoding::new(1, 1, 1, CancelToken::default()).is_err());
        let mut encoder = PngEncoding::new(1, 1, 65536, CancelToken::default()).unwrap();
        assert_eq!(encoder.step(&[]).unwrap_err().code, ErrorCode::InvalidScene);
    }
    #[test]
    fn png_output_budget_and_cancellation_fail_without_partial_publication() {
        let bytes = Arc::new(Mutex::new(Vec::new()));
        let cancel = CancelToken::default();
        let mut writer = BufferWriter { bytes: bytes.clone(), limit: 4, cancel: cancel.clone() };
        writer.write_all(b"PNG").unwrap();
        assert!(writer.write_all(b"too large").is_err());
        assert_eq!(*bytes.lock().unwrap(), b"PNG");
        cancel.cancel();
        assert!(writer.write_all(b"x").is_err());
        assert!(writer.flush().is_err());
        assert_eq!(*bytes.lock().unwrap(), b"PNG");
    }
}