fix(render): pattern-filled stencil masks take the fill paint at the opacity once (#2975)

Review follow-up. A pattern paint keeps the fill or stroke opacity it was
set with (`scn`), so resetting the graphics state's fill alpha did not stop
a pattern-filled stencil mask from being drawn at the opacity squared:
`Pattern::without_opacity` now drops it for the mask's paint (patch 35).
The renderer also painted a pattern-filled stencil mask with the stroke
paint, so an uncoloured tiling pattern drew in its stroke colour (black by
default); it now uses the fill paint.

The stencil test covers a colour fill, an uncoloured tiling pattern and a
shading pattern at ca 1, 0.5 and 0.25; each of the three changes, removed,
makes it fail. Rebased onto main; the vendored hayro-interpret patch is now
number 35 (36 was taken on main).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RUNQSPVXx3dDBabRZHAnjz

crates/render/src/raster.rs

@@ -5825,38 +5825,50 @@ trailer << /Root 1 0 R >>
     /// #2975: a stencil mask (`/ImageMask true`) is painted in the fill colour at the fill
     /// opacity, once: at `ca 0.5` it is as opaque as a rectangle filled at `ca 0.5` beside it
     /// (it was a quarter as opaque, the opacity applied by both the image's group and its paint).
+    /// The same holds when the fill is a pattern, whose paint keeps the opacity in force when it
+    /// was set with `scn`: an uncoloured tiling pattern and a shading pattern.
     #[test]
     fn stencil_masks_are_drawn_at_the_fill_opacity_once() {
         let px = |p: &RenderedPage, x: u32, y: u32| p.rgba[((y * p.width + x) * 4) as usize..][..3].to_vec();
-        for alpha in ["1", "0.5", "0.25"] {
-            let content = "/A gs 0 0 1 rg q 100 0 0 100 20 50 cm /Msk Do Q 160 50 100 100 re f";
-            let pdf = format!(
-                "%PDF-1.7
+        let fills = [("colour", "0 0 1 rg"), ("uncoloured tiling pattern", "/CsP cs 0 0 1 /Tp scn"), ("shading pattern", "/Pattern cs /Sp scn")];
+        for (fill_name, fill) in fills {
+            for alpha in ["1", "0.5", "0.25"] {
+                let content = format!("/A gs {fill} q 100 0 0 100 20 50 cm /Msk Do Q 160 50 100 100 re f");
+                let tile = "0 0 10 10 re f";
+                let pdf = format!(
+                    "%PDF-1.7
 1 0 obj << /Type /Catalog /Pages 2 0 R >> endobj
 2 0 obj << /Type /Pages /Kids [3 0 R] /Count 1 >> endobj
-3 0 obj << /Type /Page /Parent 2 0 R /MediaBox [0 0 300 200] /Contents 4 0 R /Resources << /ExtGState << /A << /ca {alpha} >> >> /XObject << /Msk 5 0 R >> >> >> endobj
+3 0 obj << /Type /Page /Parent 2 0 R /MediaBox [0 0 300 200] /Contents 4 0 R /Resources << /ExtGState << /A << /ca {alpha} >> >> /XObject << /Msk 5 0 R >> /ColorSpace << /CsP [/Pattern /DeviceRGB] >> /Pattern << /Tp 6 0 R /Sp 7 0 R >> >> >> endobj
 4 0 obj << /Length {} >> stream
 {content}
 endstream endobj
 5 0 obj << /Type /XObject /Subtype /Image /Width 2 /Height 2 /ImageMask true /Length 2 >> stream
-
+\0\0
 endstream endobj
+6 0 obj << /Type /Pattern /PatternType 1 /PaintType 2 /TilingType 1 /BBox [0 0 10 10] /XStep 10 /YStep 10 /Resources << >> /Length {} >> stream
+{tile}
+endstream endobj
+7 0 obj << /Type /Pattern /PatternType 2 /Shading << /ShadingType 2 /ColorSpace /DeviceRGB /Coords [0 0 300 0] /Extend [true true] /Function << /FunctionType 2 /Domain [0 1] /C0 [0 0 1] /C1 [0 0 1] /N 1 >> >> >> endobj
 trailer << /Root 1 0 R >>
 %%EOF",
-                content.len()
-            );
-            let p = PageRenderer::new(Arc::new(pdf.into_bytes()), RenderConfig::default()).render(RenderRequest {
-                page: 0,
-                kind: RequestKind::Pixels,
-                tile: None,
-                scale: 1.0,
-                tag: 0,
-                ..Default::default()
-            });
-            assert!(p.error.is_none(), "ca {alpha}: {:?}", p.error);
-            // Pixel rows run top down: PDF (70, 100) is in the mask, (210, 100) in the rectangle.
-            let (mask, rect) = (px(&p, 70, 100), px(&p, 210, 100));
-            assert!(mask.iter().zip(&rect).all(|(m, r)| m.abs_diff(*r) <= 1), "ca {alpha}: mask {mask:?}, rectangle {rect:?}");
+                    content.len(),
+                    tile.len()
+                );
+                let p = PageRenderer::new(Arc::new(pdf.into_bytes()), RenderConfig::default()).render(RenderRequest {
+                    page: 0,
+                    kind: RequestKind::Pixels,
+                    tile: None,
+                    scale: 1.0,
+                    tag: 0,
+                    ..Default::default()
+                });
+                assert!(p.error.is_none(), "{fill_name}, ca {alpha}: {:?}", p.error);
+                // Pixel rows run top down: PDF (70, 100) is in the mask, (210, 100) in the rectangle.
+                let (mask, rect) = (px(&p, 70, 100), px(&p, 210, 100));
+                assert!(rect != [255, 255, 255], "{fill_name}, ca {alpha}: the rectangle is painted");
+                assert!(mask.iter().zip(&rect).all(|(m, r)| m.abs_diff(*r) <= 1), "{fill_name}, ca {alpha}: mask {mask:?}, rectangle {rect:?}");
+            }
         }
     }
 

vendor/hayro-interpret/src/color.rs

@@ -1121,6 +1121,12 @@ pub struct Color {
 }
 
 impl Color {
+    /// PdfCraft patch (35): the same colour, fully opaque (see `Pattern::without_opacity`).
+    pub(crate) fn opaque(mut self) -> Self {
+        self.opacity = 1.0;
+        self
+    }
+
     pub(crate) fn new(color_space: ColorSpace, components: ColorComponents, opacity: f32) -> Self {
         Self {
             color_space,

vendor/hayro-interpret/src/pattern.rs

@@ -63,6 +63,20 @@ impl<'a> Pattern<'a> {
         }
     }
 
+    /// PdfCraft patch (35): the pattern without the fill or stroke opacity it captured when it was
+    /// set (`scn`). A stencil mask's transparency group applies the opacity in force when the mask
+    /// is drawn, so a pattern paint carrying it too drew the mask at the opacity squared (#2975).
+    pub(crate) fn without_opacity(mut self) -> Self {
+        match &mut self {
+            Self::Shading(p) => p.opacity = 1.0,
+            Self::Tiling(p) => {
+                p.non_stroking_paint = p.non_stroking_paint.clone().opaque();
+                p.stroke_paint = p.stroke_paint.clone().opaque();
+            }
+        }
+        self
+    }
+
     pub(crate) fn set_transfer_function(&mut self, tf: ActiveTransferFunction) {
         if let Self::Shading(p) = self {
             p.transfer_function = Some(tf);

vendor/hayro-interpret/src/x_object.rs

@@ -5,7 +5,7 @@ use crate::device::Device;
 use crate::function::{Function, interpolate};
 use crate::interpret::path::get_paint;
 use crate::interpret::state::ActiveTransferFunction;
-use crate::{BlendMode, CacheKey, ClipPath, Image, RasterImage, StencilImage};
+use crate::{BlendMode, CacheKey, ClipPath, Image, Paint, RasterImage, StencilImage};
 use crate::{FillRule, InterpreterWarning, WarningSinkFn, interpret};
 use crate::{ImageData, LumaData, RgbData};
 use hayro_syntax::bit_reader::BitReader;
@@ -266,7 +266,11 @@ pub(crate) fn draw_image_xobject<'a, 'b>(
 
     let image = if x_object.is_mask {
         Image::Stencil(StencilImage {
-            paint: get_paint(context, false),
+            // A pattern paint keeps the opacity it was set with: drop it too (patch 35).
+            paint: match get_paint(context, false) {
+                Paint::Pattern(pattern) => Paint::Pattern(Box::new(pattern.without_opacity())),
+                paint => paint,
+            },
             image_xobject: x_object.clone(),
         })
     } else {

vendor/hayro/src/renderer.rs

@@ -1510,8 +1510,11 @@ impl<'a> Device<'a> for Renderer {
                                 );
                                 self.ctx.set_transform(transform);
 
+                                // PdfCraft patch: a stencil mask is painted with the fill
+                                // (non-stroking) paint; `true` drew an uncoloured tiling pattern
+                                // in its stroke colour (black by default) (#2975).
                                 let clip_path =
-                                    self.set_paint(paint, &stencil_rect.to_path(0.1), true);
+                                    self.set_paint(paint, &stencil_rect.to_path(0.1), false);
                                 if let Some(clip_path) = clip_path.as_ref() {
                                     self.push_clip_path_inner(clip_path, FillRule::NonZero);
                                 }