blitz-pdf 0.1.1 → 0.1.2

package/vendor/krilla/src/graphics/graphics_state.rs

@@ -0,0 +1,251 @@
+use std::hash::Hash;
+use std::sync::Arc;
+
+use pdf_writer::types::BlendMode;
+use pdf_writer::{Finish, Name, Ref};
+
+use crate::chunk_container::ChunkContainer;
+use crate::configure::ValidationError;
+use crate::geom::{Rect, Transform};
+use crate::graphics::mask::Mask;
+use crate::num::NormalizedF32;
+use crate::resource;
+use crate::resource::Resourceable;
+use crate::serialize::{Cacheable, SerializeContext};
+
+/// The inner representation of an external graphics state.
+#[derive(Debug, Hash, PartialEq, Eq, Default, Clone)]
+struct Repr {
+    /// The non-stroking alpha.
+    non_stroking_alpha: Option<NormalizedF32>,
+    /// The stroking alpha.
+    stroking_alpha: Option<NormalizedF32>,
+    /// The blend mode.
+    blend_mode: Option<BlendMode>,
+    /// An active mask.
+    mask: Option<Ref>,
+}
+
+/// A graphics state containing information about
+/// - The current stroking alpha.
+/// - The current non-stroking alpha.
+/// - The current blend mode.
+/// - The current mask.
+///
+/// This struct provides exposes a builder pattern for setting the various properties
+/// individually.
+///
+/// This type is cheap to clone.
+#[derive(Debug, Clone, Hash, PartialEq, Eq, Default)]
+pub(crate) struct ExtGState(Arc<Repr>);
+
+impl ExtGState {
+    /// Create a new, empty graphics state.
+    pub(crate) fn new() -> Self {
+        Self::default()
+    }
+
+    /// Create a new graphics state with a stroking alpha.
+    #[must_use]
+    pub(crate) fn stroking_alpha(mut self, stroking_alpha: NormalizedF32) -> Self {
+        Arc::make_mut(&mut self.0).stroking_alpha = Some(stroking_alpha);
+        self
+    }
+
+    /// Create a new graphics state with a non-stroking alpha.
+    #[must_use]
+    pub(crate) fn non_stroking_alpha(mut self, non_stroking_alpha: NormalizedF32) -> Self {
+        Arc::make_mut(&mut self.0).non_stroking_alpha = Some(non_stroking_alpha);
+        self
+    }
+
+    /// Create a new graphics state with a blend mode.
+    #[must_use]
+    pub(crate) fn blend_mode(mut self, blend_mode: BlendMode) -> Self {
+        Arc::make_mut(&mut self.0).blend_mode = Some(blend_mode);
+        self
+    }
+
+    /// Create a new graphics state with a mask.
+    #[must_use]
+    pub(crate) fn mask(
+        mut self,
+        mask: Mask,
+        sc: &mut SerializeContext,
+        chunk_container: &mut ChunkContainer,
+    ) -> Self {
+        let mask_ref = sc.register_cacheable(chunk_container, mask);
+        Arc::make_mut(&mut self.0).mask = Some(mask_ref);
+        self
+    }
+
+    /// Check whether the graphics state is empty.
+    pub(crate) fn empty(&self) -> bool {
+        self.0.mask.is_none()
+            && self.0.stroking_alpha.is_none()
+            && self.0.non_stroking_alpha.is_none()
+            && self.0.blend_mode.is_none()
+    }
+
+    /// Integrate another graphics state into the current one. This is done by replacing
+    /// all active properties of the other graphics state in the current graphics state, while
+    /// leaving the inactive ones unchanged.
+    pub(crate) fn combine(&mut self, other: &ExtGState) {
+        if let Some(stroking_alpha) = other.0.stroking_alpha {
+            Arc::make_mut(&mut self.0).stroking_alpha = Some(stroking_alpha);
+        }
+
+        if let Some(non_stroking_alpha) = other.0.non_stroking_alpha {
+            Arc::make_mut(&mut self.0).non_stroking_alpha = Some(non_stroking_alpha);
+        }
+
+        if let Some(blend_mode) = other.0.blend_mode {
+            Arc::make_mut(&mut self.0).blend_mode = Some(blend_mode);
+        }
+
+        if let Some(mask) = other.0.mask {
+            Arc::make_mut(&mut self.0).mask = Some(mask);
+        }
+    }
+}
+
+impl Cacheable for ExtGState {
+    fn serialize(
+        self,
+        sc: &mut SerializeContext,
+        chunk_container: &mut ChunkContainer,
+        root_ref: Ref,
+    ) {
+        let chunk = &mut chunk_container.non_stream.ext_g_states;
+
+        let mut ext_st = chunk.ext_graphics(root_ref);
+        if let Some(nsa) = self.0.non_stroking_alpha {
+            if nsa != NormalizedF32::ONE {
+                sc.register_validation_error(ValidationError::Transparency(sc.location));
+            }
+
+            ext_st.non_stroking_alpha(nsa.get());
+        }
+
+        if let Some(sa) = self.0.stroking_alpha {
+            if sa != NormalizedF32::ONE {
+                sc.register_validation_error(ValidationError::Transparency(sc.location));
+            }
+
+            ext_st.stroking_alpha(sa.get());
+        }
+
+        if let Some(bm) = self.0.blend_mode {
+            if bm != BlendMode::Normal {
+                sc.register_validation_error(ValidationError::Transparency(sc.location));
+            }
+
+            ext_st.blend_mode(bm);
+        }
+
+        if let Some(mask_ref) = self.0.mask {
+            sc.register_validation_error(ValidationError::Transparency(sc.location));
+
+            ext_st.pair(Name(b"SMask"), mask_ref);
+        }
+
+        ext_st.finish();
+    }
+}
+
+impl Resourceable for ExtGState {
+    type Resource = resource::ExtGState;
+}
+
+/// A simulation of the PDF graphics state, so that we
+/// can write our transforms/graphics state all at once
+/// when adding an image/path instead of having to
+/// use `save_state`/`restore_state` excessively.
+#[derive(Debug, PartialEq, Clone)]
+pub(crate) struct GraphicsState {
+    ext_g_state: ExtGState,
+    ctm: Transform,
+}
+impl Eq for GraphicsState {}
+
+impl Hash for GraphicsState {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.ext_g_state.hash(state);
+        self.ctm.hash(state);
+    }
+}
+
+impl Default for GraphicsState {
+    fn default() -> Self {
+        Self {
+            ext_g_state: ExtGState::new(),
+            ctm: Transform::identity(),
+        }
+    }
+}
+
+impl GraphicsState {
+    pub(crate) fn combine(&mut self, other: &ExtGState) {
+        self.ext_g_state.combine(other);
+    }
+
+    pub(crate) fn concat_transform(&mut self, transform: Transform) {
+        self.ctm = self.ctm.pre_concat(transform);
+    }
+
+    pub(crate) fn transform(&self) -> Transform {
+        self.ctm
+    }
+
+    pub(crate) fn ext_g_state(&self) -> &ExtGState {
+        &self.ext_g_state
+    }
+}
+
+/// A collection of graphics states, simulates the stack-like
+/// structure used.
+#[derive(Debug, Hash, Eq, PartialEq)]
+pub struct GraphicsStates {
+    graphics_states: Vec<GraphicsState>,
+}
+
+impl GraphicsStates {
+    pub(crate) fn new() -> Self {
+        GraphicsStates {
+            graphics_states: vec![GraphicsState::default()],
+        }
+    }
+
+    pub(crate) fn cur(&self) -> &GraphicsState {
+        self.graphics_states.last().unwrap()
+    }
+
+    pub(crate) fn cur_mut(&mut self) -> &mut GraphicsState {
+        self.graphics_states.last_mut().unwrap()
+    }
+
+    pub(crate) fn save_state(&mut self) {
+        let state = self.cur();
+        self.graphics_states.push(state.clone())
+    }
+
+    pub(crate) fn restore_state(&mut self) {
+        self.graphics_states.pop();
+    }
+
+    pub(crate) fn combine(&mut self, other: &ExtGState) {
+        self.cur_mut().combine(other);
+    }
+
+    pub(crate) fn transform(&mut self, transform: Transform) {
+        self.cur_mut().concat_transform(transform);
+    }
+
+    pub(crate) fn transform_bbox(&self, bbox: Rect) -> Rect {
+        // Important: This does not take the root transform of the
+        // corresponding ContentBuilder into account, because we
+        // want it to be in krilla coordinates, not in PDF
+        // coordinates.
+        bbox.transform(self.cur().transform()).unwrap()
+    }
+}

package/vendor/krilla/src/graphics/icc.rs

@@ -0,0 +1,218 @@
+//! Using ICC profiles.
+
+use std::ops::Deref;
+use std::ops::DerefMut;
+use std::sync::Arc;
+
+use pdf_writer::{Finish, Name, Ref};
+
+use crate::chunk_container::ChunkContainer;
+use crate::resource;
+use crate::resource::Resourceable;
+use crate::serialize::{Cacheable, SerializeContext};
+use crate::stream::{deflate_encode, FilterStreamBuilder};
+use crate::util::Prehashed;
+
+/// An ICC profile.
+#[derive(Debug, Eq, PartialEq, Hash, Clone)]
+pub struct ICCProfile<const C: u8>(Arc<Prehashed<Repr>>);
+
+impl<const C: u8> ICCProfile<C> {
+    /// Create a new ICC profile.
+    ///
+    /// Returns `None` if the metadata of the profile couldn't be read or if the
+    /// number of channels of the underlying data does not correspond to the one
+    /// indicated in the constant parameter.
+    pub fn new(data: &[u8]) -> Option<Self> {
+        let metadata = ICCMetadata::from_data(data)?;
+
+        if metadata.color_space.num_components() != C {
+            return None;
+        }
+
+        Some(Self(Arc::new(Prehashed::new(Repr {
+            data: deflate_encode(data),
+            metadata,
+        }))))
+    }
+
+    pub(crate) fn metadata(&self) -> &ICCMetadata {
+        &self.0.metadata
+    }
+}
+
+impl<const C: u8> Cacheable for ICCProfile<C> {
+    fn serialize(
+        self,
+        sc: &mut SerializeContext,
+        chunk_container: &mut ChunkContainer,
+        root_ref: Ref,
+    ) {
+        let mut chunk = sc.new_chunk();
+        let icc_stream = FilterStreamBuilder::new_from_deflated(&self.0.deref().data)
+            .finish(&sc.serialize_settings());
+
+        let mut icc_profile = chunk.icc_profile(root_ref, icc_stream.encoded_data());
+        icc_profile.n(C as i32).range([0.0, 1.0].repeat(C as usize));
+        icc_stream.write_filters(icc_profile.deref_mut().deref_mut());
+        icc_profile.finish();
+        chunk_container.streams.icc_profiles.push(chunk);
+    }
+}
+
+#[cfg(feature = "raster-images")]
+#[derive(Debug, Eq, PartialEq, Hash, Clone)]
+pub(crate) enum GenericICCProfile {
+    Luma(ICCProfile<1>),
+    Rgb(ICCProfile<3>),
+    Cmyk(ICCProfile<4>),
+}
+
+#[cfg(feature = "raster-images")]
+impl GenericICCProfile {
+    pub(crate) fn metadata(&self) -> &ICCMetadata {
+        match self {
+            GenericICCProfile::Luma(l) => l.metadata(),
+            GenericICCProfile::Rgb(r) => r.metadata(),
+            GenericICCProfile::Cmyk(c) => c.metadata(),
+        }
+    }
+}
+
+#[cfg(feature = "raster-images")]
+impl Cacheable for GenericICCProfile {
+    fn serialize(
+        self,
+        sc: &mut SerializeContext,
+        chunk_container: &mut ChunkContainer,
+        root_ref: Ref,
+    ) {
+        match self {
+            GenericICCProfile::Luma(l) => l.serialize(sc, chunk_container, root_ref),
+            GenericICCProfile::Rgb(r) => r.serialize(sc, chunk_container, root_ref),
+            GenericICCProfile::Cmyk(c) => c.serialize(sc, chunk_container, root_ref),
+        }
+    }
+}
+
+#[derive(Debug, Eq, PartialEq, Hash, Clone)]
+pub(crate) struct ICCBasedColorSpace<const C: u8>(pub(crate) ICCProfile<C>);
+
+impl<const C: u8> Cacheable for ICCBasedColorSpace<C> {
+    fn serialize(
+        self,
+        sc: &mut SerializeContext,
+        chunk_container: &mut ChunkContainer,
+        root_ref: Ref,
+    ) {
+        let icc_ref = sc.register_cacheable(chunk_container, self.0.clone());
+
+        let chunk = &mut chunk_container.non_stream.color_spaces;
+
+        let mut array = chunk.indirect(root_ref).array();
+        array.item(Name(b"ICCBased"));
+        array.item(icc_ref);
+        array.finish();
+    }
+}
+
+impl<const C: u8> Resourceable for ICCBasedColorSpace<C> {
+    type Resource = resource::ColorSpace;
+}
+
+#[derive(Clone, Hash, Debug, Eq, PartialEq)]
+pub(crate) enum ICCColorSpace {
+    Xyz,
+    Lab,
+    Luv,
+    Ycbr,
+    Yxy,
+    Lms,
+    Rgb,
+    Gray,
+    Hsv,
+    Hls,
+    Cmyk,
+    Cmy,
+    OneClr,
+    ThreeClr,
+    FourClr,
+    // There are more, but those should be the most important
+    // ones.
+}
+
+impl ICCColorSpace {
+    pub(crate) fn num_components(&self) -> u8 {
+        match self {
+            ICCColorSpace::Xyz => 3,
+            ICCColorSpace::Lab => 3,
+            ICCColorSpace::Luv => 3,
+            ICCColorSpace::Ycbr => 3,
+            ICCColorSpace::Yxy => 3,
+            ICCColorSpace::Lms => 3,
+            ICCColorSpace::Rgb => 3,
+            ICCColorSpace::Gray => 1,
+            ICCColorSpace::Hsv => 3,
+            ICCColorSpace::Hls => 3,
+            ICCColorSpace::Cmyk => 4,
+            ICCColorSpace::Cmy => 3,
+            ICCColorSpace::OneClr => 1,
+            ICCColorSpace::ThreeClr => 3,
+            ICCColorSpace::FourClr => 4,
+        }
+    }
+}
+
+impl TryFrom<u32> for ICCColorSpace {
+    type Error = ();
+
+    fn try_from(value: u32) -> Result<Self, Self::Error> {
+        match value {
+            0x58595A20 => Ok(ICCColorSpace::Xyz),
+            0x4C616220 => Ok(ICCColorSpace::Lab),
+            0x4C757620 => Ok(ICCColorSpace::Luv),
+            0x59436272 => Ok(ICCColorSpace::Ycbr),
+            0x59787920 => Ok(ICCColorSpace::Yxy),
+            0x4C4D5320 => Ok(ICCColorSpace::Lms),
+            0x52474220 => Ok(ICCColorSpace::Rgb),
+            0x47524159 => Ok(ICCColorSpace::Gray),
+            0x48535620 => Ok(ICCColorSpace::Hsv),
+            0x484C5320 => Ok(ICCColorSpace::Hls),
+            0x434D594B => Ok(ICCColorSpace::Cmyk),
+            0x434D5920 => Ok(ICCColorSpace::Cmy),
+            0x31434C52 => Ok(ICCColorSpace::OneClr),
+            0x33434C52 => Ok(ICCColorSpace::ThreeClr),
+            0x34434C52 => Ok(ICCColorSpace::FourClr),
+            _ => Err(()),
+        }
+    }
+}
+
+#[derive(Clone, Hash, Debug, Eq, PartialEq)]
+pub(crate) struct ICCMetadata {
+    pub(crate) major: u8,
+    pub(crate) minor: u8,
+    pub(crate) color_space: ICCColorSpace,
+}
+
+impl ICCMetadata {
+    pub(crate) fn from_data(data: &[u8]) -> Option<Self> {
+        let major = *data.get(8)?;
+        let minor = *data.get(9)? >> 4;
+        let color_space = {
+            let marker = u32::from_be_bytes(data.get(16..20)?.try_into().ok()?);
+            ICCColorSpace::try_from(marker).ok()?
+        };
+        Some(Self {
+            major,
+            minor,
+            color_space,
+        })
+    }
+}
+
+#[derive(Clone, Hash, Debug)]
+struct Repr {
+    data: Vec<u8>,
+    metadata: ICCMetadata,
+}