Skip to content

PdfCraft: An open-source PDF reader and editor written by scratch in pure Rust

fix(edit): preserve graphics state chronology and mask identity

FredApps8669aa48aacc
diff --git a/crates/edit/src/images.rs b/crates/edit/src/images.rs
index 4b8f619b4..5df9ebeb7 100644
--- a/crates/edit/src/images.rs
+++ b/crates/edit/src/images.rs
@@ -12,14 +12,18 @@ use crate::EditError;
use crate::text::content_streams;
/// The identity of a soft mask (`/SMask`) in the PDF graphics state.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) enum MaskIdentity {
- /// Indirect reference to a mask dictionary or stream.
- Ref(u32, u16),
- /// Indirect reference to the transparency group (`/G`) in a mask dictionary.
- Group(u32, u16),
- /// Explicit named mask or resource name.
- Named(Vec<u8>),
+#[derive(Clone, Debug)]
+pub(crate) struct MaskIdentity {
+ // Share the owning ExtGState instead of copying an arbitrarily large inline mask on q/Q.
+ // Its complete SMask value retains S, TR, BC and every other mask parameter, not just G.
+ definition: Arc<Object>,
+ ctm: Matrix,
+}
+
+impl PartialEq for MaskIdentity {
+ fn eq(&self, other: &Self) -> bool {
+ self.ctm == other.ctm && self.definition.as_dict().and_then(|d| d.get(b"SMask")) == other.definition.as_dict().and_then(|d| d.get(b"SMask"))
+ }
}
/// An image drawn on a page.
@@ -664,9 +668,13 @@ impl EffectiveGState {
|| self.print_params != other.print_params
}
- /// Merge the `gs_name` ExtGState `dict`. An inline soft mask with no group of its own is
- /// known by the name of the ExtGState that sets it.
- pub(crate) fn merge_dict(&mut self, dict: &Dict, doc: &Document, gs_name: &[u8]) {
+ #[cfg(test)]
+ pub(crate) fn merge_dict(&mut self, dict: &Dict, doc: &Document, ctm: Matrix) {
+ self.merge_shared(&Arc::new(Object::Dict(dict.clone())), doc, ctm);
+ }
+
+ fn merge_shared(&mut self, definition: &Arc<Object>, doc: &Document, ctm: Matrix) {
+ let Some(dict) = definition.as_dict() else { return };
for key in [b"TR".as_slice(), b"TR2", b"OP", b"op", b"OPM", b"BG", b"BG2", b"UCR", b"UCR2", b"HT"] {
if let Some(value) = dict.get(key) {
self.print_params.insert(key.to_vec(), std::rc::Rc::new(value.clone()));
@@ -691,26 +699,8 @@ impl EffectiveGState {
}
}
if let Some(raw_smask) = dict.get(b"SMask") {
- let resolved = doc.resolve(raw_smask);
- if let Some(name) = resolved.as_name() {
- if name == b"None" {
- self.smask = None;
- } else {
- self.smask = Some(MaskIdentity::Named(name.to_vec()));
- }
- } else if let Some(mask_dict) = resolved.as_dict() {
- if let Some(gr) = mask_dict.get(b"G").and_then(|g| g.as_ref()) {
- self.smask = Some(MaskIdentity::Group(gr.num, gr.generation));
- } else if let Some(r) = raw_smask.as_ref() {
- self.smask = Some(MaskIdentity::Ref(r.num, r.generation));
- } else if let Some(name) = mask_dict.get(b"Name").map(|n| doc.resolve(n)).and_then(|n| n.as_name().map(|s| s.to_vec())) {
- self.smask = Some(MaskIdentity::Named(name));
- } else {
- self.smask = Some(MaskIdentity::Named(gs_name.to_vec()));
- }
- } else if let Some(r) = raw_smask.as_ref() {
- self.smask = Some(MaskIdentity::Ref(r.num, r.generation));
- }
+ let disabled = raw_smask.as_name() == Some(b"None") || raw_smask.as_ref().is_some_and(|r| doc.get(r).as_name() == Some(b"None"));
+ self.smask = (!disabled).then(|| MaskIdentity { definition: Arc::clone(definition), ctm });
}
}
}
@@ -725,6 +715,7 @@ struct ExtendedGStateTracker {
stack: Vec<(EffectiveGState, ActiveGsOps)>,
current_state: EffectiveGState,
active_gs_ops: ActiveGsOps,
+ definitions: std::collections::HashMap<Vec<u8>, Arc<Object>>,
}
impl ExtendedGStateTracker {
@@ -744,17 +735,22 @@ impl ExtendedGStateTracker {
}
}
b"gs" => {
- let valid_gs = op
- .name(0)
- .and_then(|name| ext_gstates.get(name).map(|v| doc.resolve(v)).and_then(|v| v.as_dict().cloned()).map(|dict| (name, dict)));
- if let Some((name, dict)) = valid_gs {
- self.current_state.merge_dict(&dict, doc, name);
+ let valid_gs = op.name(0).and_then(|name| {
+ let definition = self.definitions.get(name).cloned().or_else(|| {
+ let definition = doc.resolve(ext_gstates.get(name)?);
+ definition.as_dict()?;
+ self.definitions.insert(name.to_vec(), Arc::clone(&definition));
+ Some(definition)
+ })?;
+ Some((name, definition))
+ });
+ if let Some((name, definition)) = valid_gs {
+ self.current_state.merge_shared(&definition, doc, ctm);
let mut next = (*self.active_gs_ops).clone();
if let Some(pos) = next.iter().position(|(k, _, _)| k.as_slice() == name) {
- if let Some(entry) = next.get_mut(pos) {
- *entry = (name.to_vec(), op.clone(), ctm);
- }
- } else if next.len() < MAX_ACTIVE_GS_OPS {
+ next.remove(pos);
+ }
+ if next.len() < MAX_ACTIVE_GS_OPS {
next.push((name.to_vec(), op.clone(), ctm));
}
self.active_gs_ops = std::rc::Rc::new(next);
@@ -1378,11 +1374,11 @@ fn arrange_image(
}
let mut reconstructed_state = dest_effective_state.clone();
- for (op, _) in &source_gs_ops {
+ for (op, ctm) in &source_gs_ops {
if let Some(name) = op.name(0)
- && let Some(dict) = ext_gstates.get(name).map(|v| doc.resolve(v)).and_then(|v| v.as_dict().cloned())
+ && let Some(definition) = tracker.definitions.get(name)
{
- reconstructed_state.merge_dict(&dict, doc, name);
+ reconstructed_state.merge_shared(definition, doc, *ctm);
}
}
@@ -1980,4 +1976,18 @@ mod allocation_tests {
}
assert_eq!(tracker.current, saved, "changing shared operands must preserve the saved state");
}
+
+ #[test]
+ fn review_soft_mask_identity_includes_establishment_matrix() {
+ let doc = Document::new_empty();
+ let mask = Dict::from_iter([(b"S".to_vec(), Object::name("Alpha")), (b"G".to_vec(), Object::Ref(ObjRef::new(8, 0)))]);
+ let definition = Dict::from_iter([(b"SMask".to_vec(), Object::Dict(mask))]);
+ let states = Dict::from_iter([(b"A".to_vec(), Object::Dict(definition))]);
+ let mut tracker = ExtendedGStateTracker::default();
+ let op = Op::new("gs", vec![Object::name("A")]);
+ tracker.step(&op, &states, &doc, Matrix::IDENTITY).unwrap();
+ let before = tracker.current_state.clone();
+ tracker.step(&op, &states, &doc, Matrix::translate(50.0, 0.0)).unwrap();
+ assert!(before.visually_differs(&tracker.current_state), "the same mask established under a different CTM is a different effective mask");
+ }
}
diff --git a/crates/edit/src/tests.rs b/crates/edit/src/tests.rs
index 2e4b8ebbd..72e7ec88b 100644
--- a/crates/edit/src/tests.rs
+++ b/crates/edit/src/tests.rs
@@ -9789,10 +9789,10 @@ fn different_inline_soft_masks_have_distinct_identities() {
dict2.set(b"SMask".to_vec(), Object::Dict(mask2));
let mut state1 = images::EffectiveGState::default();
- state1.merge_dict(&dict1, &doc, b"GS1");
+ state1.merge_dict(&dict1, &doc, pdfcraft_content::Matrix::IDENTITY);
let mut state2 = images::EffectiveGState::default();
- state2.merge_dict(&dict2, &doc, b"GS2");
+ state2.merge_dict(&dict2, &doc, pdfcraft_content::Matrix::IDENTITY);
assert!(state1.visually_differs(&state2), "two different inline soft masks must visually differ");
}
@@ -10169,3 +10169,89 @@ fn editor_crop_group_move_keeps_an_outer_author_clip_fixed() {
assert!(String::from_utf8_lossy(&bytes).starts_with("0 0 220 300 re W n"));
assert_eq!(text::text_lines(&doc, 0).unwrap()[0].text, "Caption");
}
+
+fn review_state_raster(doc: &Document) -> Vec<u8> {
+ let bytes = write_full(doc, &SaveOptions::default()).unwrap();
+ let mut renderer = pdfcraft_render::PageRenderer::new(Arc::new(bytes), Default::default());
+ renderer.render(pdfcraft_render::RenderRequest { page: 0, scale: 1.0, ..Default::default() }).rgba.to_vec()
+}
+
+fn review_shared_mask_page(states: &str, luminosity_b: bool, mask_paint: &str) -> Document {
+ let content = format!("q {states} q 100 0 0 100 20 20 cm /Im0 Do Q Q q 0 0 1 rg 200 200 5 5 re f Q");
+ let stream = format!("<< /Length {} >>\nstream\n{content}\nendstream", content.len());
+ let subtype = if luminosity_b { "Luminosity" } else { "Alpha" };
+ let mask_b = format!("<< /Type /ExtGState /SMask << /S /{subtype} /G 8 0 R >> >>");
+ let group = format!(
+ "<< /Type /XObject /Subtype /Form /BBox [0 0 300 300] /Group << /S /Transparency /I true /CS /DeviceGray >> /Length {} >>\nstream\n{mask_paint}\nendstream",
+ mask_paint.len()
+ );
+ build(&[
+ "<< /Type /Catalog /Pages 2 0 R >>",
+ "<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
+ "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 300 300] /Contents 4 0 R /Resources << /XObject << /Im0 5 0 R >> /ExtGState << /A 6 0 R /B 7 0 R >> >> >>",
+ &stream,
+ "<< /Type /XObject /Subtype /Image /Width 2 /Height 2 /ColorSpace /DeviceGray /BitsPerComponent 8 /Length 4 >>\nstream\n\0\0\0\0\nendstream",
+ "<< /Type /ExtGState /SMask << /S /Alpha /G 8 0 R >> >>",
+ &mask_b,
+ &group,
+ ])
+}
+
+#[test]
+fn review_repeated_gs_keeps_alpha_vs_luminosity_mask_chronology() {
+ for states in ["/A gs", "/A gs /B gs", "/A gs /B gs /A gs"] {
+ let mut doc = review_shared_mask_page(states, true, "0.25 g 0 0 300 300 re f");
+ let before = review_state_raster(&reopen(&doc));
+ assert!(before.as_chunks::<4>().0.iter().any(|p| p[0] == p[1] && p[1] == p[2] && p[0] < 230), "the masked image is visible");
+ arrange(&mut doc, 0, 0, images::ArrangeOrder::BringToFront).unwrap();
+ assert_eq!(review_state_raster(&reopen(&doc)), before, "mask application order must survive: {states}");
+ }
+}
+
+#[test]
+fn review_repeated_gs_keeps_last_mask_establishment_ctm() {
+ for states in [
+ "1 0 0 1 50 0 cm /A gs 1 0 0 1 -50 0 cm",
+ "/A gs 1 0 0 1 50 0 cm /B gs 1 0 0 1 -50 0 cm",
+ "/A gs 1 0 0 1 50 0 cm /B gs 1 0 0 1 -50 0 cm /A gs",
+ ] {
+ let mut doc = review_shared_mask_page(states, false, "0.25 g 0 0 60 300 re f");
+ let before = review_state_raster(&reopen(&doc));
+ arrange(&mut doc, 0, 0, images::ArrangeOrder::BringToFront).unwrap();
+ assert_eq!(review_state_raster(&reopen(&doc)), before, "mask CTM must survive: {states}");
+ }
+}
+
+#[test]
+fn review_soft_masks_sharing_a_group_keep_distinct_configurations() {
+ let doc = Document::new_empty();
+ let mask = |subtype: &str| {
+ Dict::from_iter([(
+ b"SMask".to_vec(),
+ Object::Dict(Dict::from_iter([(b"S".to_vec(), Object::name(subtype)), (b"G".to_vec(), Object::Ref(pdfcraft_cos::ObjRef::new(8, 0)))])),
+ )])
+ };
+ let mut alpha = images::EffectiveGState::default();
+ let mut luminosity = images::EffectiveGState::default();
+ alpha.merge_dict(&mask("Alpha"), &doc, pdfcraft_content::Matrix::IDENTITY);
+ luminosity.merge_dict(&mask("Luminosity"), &doc, pdfcraft_content::Matrix::IDENTITY);
+ assert!(alpha.visually_differs(&luminosity), "a shared group does not make Alpha and Luminosity the same mask");
+ for (key, value) in [
+ (b"BC".to_vec(), Object::Array(vec![Object::Real(0.5)])),
+ (
+ b"TR".to_vec(),
+ Object::Dict(Dict::from_iter([
+ (b"FunctionType".to_vec(), Object::Int(2)),
+ (b"Domain".to_vec(), Object::Array(vec![Object::Int(0), Object::Int(1)])),
+ (b"N".to_vec(), Object::Int(2)),
+ ])),
+ ),
+ ] {
+ let mut changed = mask("Luminosity");
+ let Object::Dict(definition) = changed.get_mut(b"SMask").unwrap() else { panic!("mask dictionary") };
+ definition.set(key, value);
+ let mut state = images::EffectiveGState::default();
+ state.merge_dict(&changed, &doc, pdfcraft_content::Matrix::IDENTITY);
+ assert!(state.visually_differs(&luminosity), "mask backdrop and transfer function belong to its definition");
+ }
+}