mirror of
https://github.com/storytold/pdfcraft.git
synced 2026-11-05 18:19:50 +00:00
crates/render/src/raster.rs: both new tests (#2975 stencil masks, #2971 knockout groups) vendor/hayro/src/renderer.rs: set_paint returns main's PaintSetup; the PR's knockout erase early return wraps its clip in PaintSetup::Clip vendor/README.md: main's rows plus the PR's hayro-interpret patch 39 and hayro patch numbered 22 (19 is #3296's), with tests
This commit is contained in:
aiongg committed
commit
554d9105f3
5 files changed
+410
-34
No files matched your search
@@ -6338,6 +6338,152 @@ trailer << /Root 1 0 R >>
|
||||
}
|
||||
}
|
||||
|
||||
/// #2971: in a knockout transparency group (`/K true`) each element composites with the
|
||||
/// group's initial backdrop, not with the elements drawn before it in the group, over the
|
||||
/// element's shape. A blue square at 50 % opacity over a red one at 50 % shows only the blue
|
||||
/// where they overlap; without `/K` the two blend. The same holds for an image (its shape
|
||||
/// is its rectangle; a soft-masked image's shape is its mask, so its transparent part leaves
|
||||
/// what is under it) and for a nested group (its shape is the union of its elements'
|
||||
/// shapes, while its own elements still blend with each other).
|
||||
#[test]
|
||||
fn knockout_groups_replace_what_their_elements_cover() {
|
||||
let render_as = |group: &str, form: &str, preview: bool| {
|
||||
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 << /XObject << /Fm1 5 0 R >> /ExtGState << /G << /ca 0.5 >> >> >> >> endobj
|
||||
4 0 obj << /Length 39 >> stream
|
||||
/Fm1 Do /G gs 0 1 0 rg 10 10 30 30 re f
|
||||
endstream endobj
|
||||
5 0 obj << /Type /XObject /Subtype /Form /BBox [0 0 300 200] /Group << /S /Transparency {group} >> /Resources << /ExtGState << /A << /ca 0.5 >> >> /XObject << /In 6 0 R /Msk 7 0 R /Neu 8 0 R /Img 9 0 R /Sm 10 0 R /Nimg 12 0 R /Deep 13 0 R /Shg 16 0 R /Big 17 0 R >> >> /Length {} >> stream
|
||||
{form}
|
||||
endstream endobj
|
||||
6 0 obj << /Type /XObject /Subtype /Form /BBox [0 0 300 200] /Group << /S /Transparency >> /Resources << /ExtGState << /A << /ca 0.5 >> >> >> /Length 34 >> stream
|
||||
/A gs 0 0 1 rg 100 50 150 120 re f
|
||||
endstream endobj
|
||||
7 0 obj << /Type /XObject /Subtype /Image /Width 2 /Height 2 /ImageMask true /Filter /ASCIIHexDecode /Length 5 >> stream
|
||||
0000>
|
||||
endstream endobj
|
||||
8 0 obj << /Type /XObject /Subtype /Form /BBox [0 0 300 200] /Group << /S /Transparency >> /Resources << /ExtGState << /H << /ca 0.5 >> >> >> /Length 62 >> stream
|
||||
/H gs 0 1 0 rg 80 40 100 100 re f 0 0 1 rg 130 80 100 100 re f
|
||||
endstream endobj
|
||||
9 0 obj << /Type /XObject /Subtype /Image /Width 1 /Height 1 /ColorSpace /DeviceRGB /BitsPerComponent 8 /Filter /ASCIIHexDecode /Length 7 >> stream
|
||||
0000FF>
|
||||
endstream endobj
|
||||
10 0 obj << /Type /XObject /Subtype /Image /Width 2 /Height 1 /ColorSpace /DeviceRGB /BitsPerComponent 8 /SMask 11 0 R /Filter /ASCIIHexDecode /Length 13 >> stream
|
||||
0000FF0000FF>
|
||||
endstream endobj
|
||||
11 0 obj << /Type /XObject /Subtype /Image /Width 2 /Height 1 /ColorSpace /DeviceGray /BitsPerComponent 8 /Filter /ASCIIHexDecode /Length 5 >> stream
|
||||
00FF>
|
||||
endstream endobj
|
||||
12 0 obj << /Type /XObject /Subtype /Form /BBox [0 0 300 200] /Group << /S /Transparency >> /Resources << /ExtGState << /H << /ca 0.5 >> >> /XObject << /Img 9 0 R >> >> /Length 38 >> stream
|
||||
/H gs q 160 0 0 100 60 50 cm /Img Do Q
|
||||
endstream endobj
|
||||
13 0 obj << /Type /XObject /Subtype /Form /BBox [0 0 300 200] /Group << /S /Transparency >> /Resources << /ExtGState << /H << /ca 0.5 >> >> /XObject << /In3 14 0 R >> >> /Length 13 >> stream
|
||||
/H gs /In3 Do
|
||||
endstream endobj
|
||||
14 0 obj << /Type /XObject /Subtype /Form /BBox [0 0 300 200] /Group << /S /Transparency >> /Length 28 >> stream
|
||||
0 0 1 rg 100 50 150 120 re f
|
||||
endstream endobj
|
||||
15 0 obj << /PatternType 2 /Shading << /ShadingType 2 /ColorSpace /DeviceRGB /Coords [0 0 1 0] /Function << /FunctionType 2 /Domain [0 1] /C0 [0 0 1] /C1 [0 0 1] /N 1 >> /Extend [true true] /BBox [100 50 140 170] >> >> endobj
|
||||
16 0 obj << /Type /XObject /Subtype /Form /BBox [0 0 300 200] /Group << /S /Transparency >> /Resources << /Pattern << /P 15 0 R >> >> /Length 38 >> stream
|
||||
/Pattern cs /P scn 100 50 150 120 re f
|
||||
endstream endobj
|
||||
17 0 obj << /Type /XObject /Subtype /Image /Width 20000 /Height 20000 /ColorSpace /DeviceRGB /BitsPerComponent 8 /Filter /ASCIIHexDecode /Length 7 >> stream
|
||||
0000FF>
|
||||
endstream endobj
|
||||
trailer << /Root 1 0 R >>
|
||||
%%EOF",
|
||||
form.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,
|
||||
preview,
|
||||
});
|
||||
assert!(p.error.is_none(), "{group} {form}: {:?}", p.error);
|
||||
p
|
||||
};
|
||||
let render = |group: &str, form: &str| render_as(group, form, false);
|
||||
// Pixel rows run top down: PDF (x, y) is pixel (x, 200 - y).
|
||||
let px = |p: &RenderedPage, x: u32, y: u32| p.rgba[((200 - y) * p.width + x) as usize * 4..][..3].to_vec();
|
||||
let check = |p: &RenderedPage, x: u32, y: u32, want: [u8; 3], what: &str| {
|
||||
let got = px(p, x, y);
|
||||
assert!(got.iter().zip(want).all(|(a, b)| a.abs_diff(b) <= 2), "{what}: {got:?}, expected {want:?}");
|
||||
};
|
||||
let red = "/A gs 1 0 0 rg 20 20 150 150 re f ";
|
||||
let ko = "/I true /K true";
|
||||
|
||||
let squares = render(ko, &format!("{red}0 0 1 rg 100 50 150 120 re f"));
|
||||
check(&squares, 130, 100, [128, 128, 255], "knocked out");
|
||||
check(&squares, 50, 40, [255, 128, 128], "red alone");
|
||||
check(&squares, 210, 100, [128, 128, 255], "blue alone");
|
||||
check(&squares, 280, 190, [255, 255, 255], "paper");
|
||||
// Page content after the group composites normally again: green at 50 % over the red.
|
||||
check(&squares, 30, 30, [128, 191, 64], "after the group");
|
||||
let plain = render("/I true", &format!("{red}0 0 1 rg 100 50 150 120 re f"));
|
||||
check(&plain, 130, 100, [128, 64, 191], "blended without /K");
|
||||
|
||||
// An image at 50 % replaces the red under its rectangle.
|
||||
let image = render(ko, &format!("{red}q 160 0 0 100 60 50 cm /Img Do Q"));
|
||||
check(&image, 100, 100, [128, 128, 255], "image knocks out");
|
||||
check(&image, 40, 40, [255, 128, 128], "red beside the image");
|
||||
// A soft-masked image: its transparent left half leaves the red, its opaque half replaces it.
|
||||
let masked = render(ko, "1 0 0 rg 20 20 150 150 re f q 160 0 0 100 60 50 cm /Sm Do Q");
|
||||
check(&masked, 100, 100, [255, 0, 0], "under the transparent half");
|
||||
check(&masked, 155, 100, [0, 0, 255], "under the opaque half");
|
||||
|
||||
// A nested group entered at 50 % (blue at 25 % in all) replaces the red under its shape.
|
||||
let nested = render(ko, &format!("{red}/In Do"));
|
||||
check(&nested, 130, 100, [191, 191, 255], "nested group knocks out");
|
||||
check(&nested, 50, 40, [255, 128, 128], "red beside the nested group");
|
||||
// A nested group at full opacity: it knocks out the red as a whole, and its own two
|
||||
// squares at 50 % still blend with each other where they overlap.
|
||||
let neutral = render(ko, "1 0 0 rg 20 20 150 150 re f /Neu Do");
|
||||
check(&neutral, 100, 60, [128, 255, 128], "green over the knocked-out red");
|
||||
check(&neutral, 150, 110, [64, 128, 191], "the nested squares blend");
|
||||
check(&neutral, 40, 40, [255, 0, 0], "red beside the nested group");
|
||||
|
||||
// An image inside a nested group is drawn once (blue at 50 %), over the knocked-out red.
|
||||
let nested_image = render(ko, "1 0 0 rg 20 20 150 150 re f /Nimg Do");
|
||||
check(&nested_image, 100, 100, [128, 128, 255], "image in a nested group");
|
||||
// A group inside a nested group knocks out the red as well.
|
||||
let deep = render(ko, "1 0 0 rg 20 20 150 150 re f /Deep Do");
|
||||
check(&deep, 130, 100, [128, 128, 255], "group in a nested group");
|
||||
check(&deep, 40, 40, [255, 0, 0], "red beside it");
|
||||
|
||||
// A stencil mask must not erase the red beside it.
|
||||
let stencil = render(ko, &format!("{red}0 0 1 rg q 150 0 0 120 100 50 cm /Msk Do Q"));
|
||||
check(&stencil, 50, 40, [255, 128, 128], "red beside a stencil");
|
||||
// Where the stencil paints (every sample 0), its blue is drawn (review on #2974: the check
|
||||
// above alone passed even if the stencil drew nothing). A stencil composites as it did
|
||||
// before rather than knocking the red out, and its exact colour also depends on #2975 (a
|
||||
// stencil's fill opacity applied twice), so only "blue was drawn here" is pinned.
|
||||
let under = px(&stencil, 130, 100);
|
||||
assert!(under != [255, 128, 128] && under[2] >= 150 && under[0] < 230, "stencil drew nothing: {under:?}");
|
||||
|
||||
// A shading's /BBox clips it (ISO 32000-2 Table 77), so a shading fill's shape is its path
|
||||
// inside the box: the erase pass must clear only that, or the red outside the box but
|
||||
// inside the path stays erased (review on #2974).
|
||||
let shaded = render(ko, &format!("{red}/Shg Do"));
|
||||
check(&shaded, 120, 100, [128, 128, 255], "the shading inside its box");
|
||||
check(&shaded, 155, 100, [255, 128, 128], "red outside the shading's box");
|
||||
|
||||
// An image that isn't decoded (here over the renderer's pixel limit) draws nothing, so it
|
||||
// must not clear what is under its rectangle either (review on #2974).
|
||||
let undecoded = render(ko, &format!("{red}q 160 0 0 100 60 50 cm /Big Do Q"));
|
||||
check(&undecoded, 100, 100, [255, 128, 128], "red under an image that isn't drawn");
|
||||
// Nor one a preview skips for covering only a few device pixels (review on #2974): the
|
||||
// red under a 3 x 3 image stays in a preview, and a final render knocks it out.
|
||||
let tiny = format!("{red}q 3 0 0 3 100 100 cm /Img Do Q");
|
||||
check(&render_as(ko, &tiny, true), 101, 101, [255, 128, 128], "red under a preview's skipped image");
|
||||
check(&render_as(ko, &tiny, false), 101, 101, [128, 128, 255], "the tiny image in a final render");
|
||||
}
|
||||
|
||||
/// Reading colours replace *document* colours, never annotation colours (issue #1548): a
|
||||
/// highlight keeps its `/C`, so on a dark background the content under it shows through the
|
||||
/// Multiply blend in the highlight's colour instead of being darkened into invisibility.
|
||||
|
||||
Vendored
+3
-3
@@ -17,10 +17,10 @@ Other resource categories retain their existing parent-chain lookup.
|
||||
|
||||
| Crate | Version | Licence | Patches | Test |
|
||||
|---|---|---|---|---|
|
||||
| hayro-interpret | 0.7.0 | Apache-2.0 OR MIT | (1) select `/AP /N` appearance states via `/AS` (checkboxes, radios, stateful icons) and honour the NoView flag; (2) Type3 Unicode fallback to `/Encoding` glyph names, then printable ASCII; (3) `Type3Glyph::advance_width`; (4) `InterpreterSettings::ocg_overrides` for viewer layer toggles; (5) soft masks whose group lacks `/CS` were dropped (Chrome gradient text); (6) paint nesting cap `MAX_PAINT_NESTING` for tiling patterns and Type 3 glyphs (self-referencing content overflowed the stack); (7) CID width ranges in `/W` and `/W2` clamped to `MAX_CID` (a `0 4294967295 w` range hung); (8) `InterpreterSettings::hide_comments` skips markup annotations but keeps widgets and links (View ▸ Hide all comments); (9) `image_size_ok`: images and masks over 2^28 pixels are not decoded (a fuzzed `/W 4294967295` stencil mask allocated 4 GiB); (10) `MAX_NESTED_PAINTS`: nested paints (forms, Type 3 glyphs and tiling patterns inside one another) share a per-page budget of 50,000 (a glyph showing eight glyphs of its own font, sixteen deep, hung); (11) depends on skrifa 0.47 instead of 0.42 (upstream read-fonts fixed a Type 1 tokenizer that recursed through runs of numbers: a fuzzed font hung or overflowed the stack), with the one API change (`Charset::glyph_id` returns `Option`); (12) annotation appearances whose `/BBox` or `/Matrix` collapses to a line or a point are skipped (mapping them onto `/Rect` divided by zero and handed the device infinite or NaN matrices); (13) a Highlight annotation without a usable normal appearance is drawn from its `/QuadPoints`, `/C` and `/CA` with Multiply blending, as pdfcraft-annot draws highlights (it was not drawn at all); (14) simple-font `/Widths` (`read_widths`): entries only for codes 0–255 (one entry per code below `/FirstChar` was allocated: `4294967295` asked for 34 GB), an entry that isn't a number leaves its code missing instead of ending the array, and a `/LastChar` below `/FirstChar` gives no widths instead of discarding the font for a standard one; (15) the appearance box is mapped onto `/Rect` corner to corner: the translation now accounts for the scale (an appearance whose box didn't start at the origin and differed in size from `/Rect` was drawn shifted); (16) a clip set by `W`/`W*` takes effect after whichever path-painting operator ends the path (`S`, `f`, `B`, … as well as `n`; ISO 32000-2 §8.5.4): it was applied only on `n`, so `re W* S` clipped nothing and the clip stayed pending for a later, unrelated `n`; (17) `InterpreterSettings::cancelled`: once set, interpretation stops before the next content operator (a render pool sets it for every worker when dropped, after an edit or on closing, and for one worker when the watchdog gives up on its render, so renders whose answers nobody can receive stop instead of running to the end); (18) `MAX_PAGE_CONTENT`: the content a page holds at once (its contents, and the forms, tiling patterns and Type 3 glyph procedures being painted) stays within 512 MiB (`decode_content`; once it runs out, `InterpreterWarning::ContentTruncated` is reported (once per page by pdfcraft-render) so a truncated page is not a clean render; each level gives its bytes back when it finishes): forms nest fifty deep and each level kept its content while the next ran, so a form painting itself around a stream inflating to 256 MiB would have held over 12 GB; and Type 0 sampled functions take at most `MAX_SAMPLE_ENTRIES` (2^21) table points and `MAX_SAMPLE_VALUES` (2^23) samples, read no further than `/Size` asks (256 MiB of 1-bit samples asked for over 8 GB); (19) mesh shadings (types 4–7) are sampled only inside the area being drawn (`ShadingPattern::encode_within`, which the vendored hayro renderer calls with that area plus a pixel), within 8 visits per pixel of it plus 4 per triangle (`TriangleSampler`), and patches are triangulated one at a time: points far off the page were sampled over their whole bounding box, up to 65536 × 65536 entries (a fuzzed 147-byte patch stream; a synthetic page passed 6 GB in six seconds), ten thousand overlapping triangles ran for minutes, and every patch became 722 triangles before any limit; meshes hold at most `MAX_MESH_PATCHES` (2^16) patches and `MAX_MESH_TRIANGLES` (2^20) triangles, a lattice needs two to 2^19 vertices per row (`/VerticesPerRow 0` pushed empty rows for ever; one huge row read the whole stream), and a page samples at most `MAX_PAGE_MESH_TRIANGLES` (2^25) mesh triangles in all (a mesh painted a thousand times was triangulated a thousand times); each cut logs a warning; (20) PDF function construction is limited to 64 levels and 10,000 total nodes with cycle detection; calculator parsing and evaluation share procedure depth/work budgets, integer division/bitshift/rotation/index are panic-free, and fixed-size stack errors propagate; (21) a Type 0 font drawn with a substitute that isn't CID-keyed (it isn't embedded, or its program doesn't load) draws `.nLine truncated
|
||||
| hayro-interpret | 0.7.0 | Apache-2.0 OR MIT | (1) select `/AP /N` appearance states via `/AS` (checkboxes, radios, stateful icons) and honour the NoView flag; (2) Type3 Unicode fallback to `/Encoding` glyph names, then printable ASCII; (3) `Type3Glyph::advance_width`; (4) `InterpreterSettings::ocg_overrides` for viewer layer toggles; (5) soft masks whose group lacks `/CS` were dropped (Chrome gradient text); (6) paint nesting cap `MAX_PAINT_NESTING` for tiling patterns and Type 3 glyphs (self-referencing content overflowed the stack); (7) CID width ranges in `/W` and `/W2` clamped to `MAX_CID` (a `0 4294967295 w` range hung); (8) `InterpreterSettings::hide_comments` skips markup annotations but keeps widgets and links (View ▸ Hide all comments); (9) `image_size_ok`: images and masks over 2^28 pixels are not decoded (a fuzzed `/W 4294967295` stencil mask allocated 4 GiB); (10) `MAX_NESTED_PAINTS`: nested paints (forms, Type 3 glyphs and tiling patterns inside one another) share a per-page budget of 50,000 (a glyph showing eight glyphs of its own font, sixteen deep, hung); (11) depends on skrifa 0.47 instead of 0.42 (upstream read-fonts fixed a Type 1 tokenizer that recursed through runs of numbers: a fuzzed font hung or overflowed the stack), with the one API change (`Charset::glyph_id` returns `Option`); (12) annotation appearances whose `/BBox` or `/Matrix` collapses to a line or a point are skipped (mapping them onto `/Rect` divided by zero and handed the device infinite or NaN matrices); (13) a Highlight annotation without a usable normal appearance is drawn from its `/QuadPoints`, `/C` and `/CA` with Multiply blending, as pdfcraft-annot draws highlights (it was not drawn at all); (14) simple-font `/Widths` (`read_widths`): entries only for codes 0–255 (one entry per code below `/FirstChar` was allocated: `4294967295` asked for 34 GB), an entry that isn't a number leaves its code missing instead of ending the array, and a `/LastChar` below `/FirstChar` gives no widths instead of discarding the font for a standard one; (15) the appearance box is mapped onto `/Rect` corner to corner: the translation now accounts for the scale (an appearance whose box didn't start at the origin and differed in size from `/Rect` was drawn shifted); (16) a clip set by `W`/`W*` takes effect after whichever path-painting operator ends the path (`S`, `f`, `B`, … as well as `n`; ISO 32000-2 §8.5.4): it was applied only on `n`, so `re W* S` clipped nothing and the clip stayed pending for a later, unrelated `n`; (17) `InterpreterSettings::cancelled`: once set, interpretation stops before the next content operator (a render pool sets it for every worker when dropped, after an edit or on closing, and for one worker when the watchdog gives up on its render, so renders whose answers nobody can receive stop instead of running to the end); (18) `MAX_PAGE_CONTENT`: the content a page holds at once (its contents, and the forms, tiling patterns and Type 3 glyph procedures being painted) stays within 512 MiB (`decode_content`; once it runs out, `InterpreterWarning::ContentTruncated` is reported (once per page by pdfcraft-render) so a truncated page is not a clean render; each level gives its bytes back when it finishes): forms nest fifty deep and each level kept its content while the next ran, so a form painting itself around a stream inflating to 256 MiB would have held over 12 GB; and Type 0 sampled functions take at most `MAX_SAMPLE_ENTRIES` (2^21) table points and `MAX_SAMPLE_VALUES` (2^23) samples, read no further than `/Size` asks (256 MiB of 1-bit samples asked for over 8 GB); (19) mesh shadings (types 4–7) are sampled only inside the area being drawn (`ShadingPattern::encode_within`, which the vendored hayro renderer calls with that area plus a pixel), within 8 visits per pixel of it plus 4 per triangle (`TriangleSampler`), and patches are triangulated one at a time: points far off the page were sampled over their whole bounding box, up to 65536 × 65536 entries (a fuzzed 147-byte patch stream; a synthetic page passed 6 GB in six seconds), ten thousand overlapping triangles ran for minutes, and every patch became 722 triangles before any limit; meshes hold at most `MAX_MESH_PATCHES` (2^16) patches and `MAX_MESH_TRIANGLES` (2^20) triangles, a lattice needs two to 2^19 vertices per row (`/VerticesPerRow 0` pushed empty rows for ever; one huge row read the whole stream), and a page samples at most `MAX_PAGE_MESH_TRIANGLES` (2^25) mesh triangles in all (a mesh painted a thousand times was triangulated a thousand times); each cut logs a warning; (20) PDF function construction is limited to 64 levels and 10,000 total nodes with cycle detection; calculator parsing and evaluation share procedure depth/work budgets, integer division/bitshift/rotation/index are panic-free, and fixed-size stack errors propagate; (21) a Type 0 font drawn with a substitute that isn't CID-keyed (it isn't embedded, or its program doesn't load) draws `.nLine truncated
|
||||
|
||||
| hayro | 0.7.1 | Apache-2.0 OR MIT | (1) `RenderSettings::{x_offset, y_offset}` to render one tile of a large page; (2) images over `MAX_IMAGE_PIXELS` (2^28) are skipped (a fuzzed `/W 4294967295` hung in resampling); (3) `tiling_cell_scale` keeps a tiling pattern's cell pixmap within 3000 px a side whatever its `/XStep`/`/YStep` (a fuzzed step far beyond `/BBox` allocated 2 GB); (4) stroke widths clamped to 4 × (canvas width + height) device pixels (a fuzzed `/LW 9223372036854775807` allocated 10 GB in stroke expansion); (5) `usable_dash_pattern`: a stroke whose dash pattern could cut it into more than `MAX_DASHES_PER_STROKE` (250,000) pieces, counting kurbo's restart of the pattern at every subpath and `ClosePath`, is drawn solid (a fuzzed `/D [[11] 0]` on a line from x = 92234775807 allocated over 5 GB, `[0.000001] 0 d` on a 20 pt line over 10 GB); (6) a dash pattern with a negative or non-finite entry, or a period that isn't positive, is drawn solid (`[-1 -1] 0 d` looped for ever in kurbo); (7) `render_size` and `render_into`: render into a buffer the caller allocates (PdfCraft renders into pixel-aligned memory that the GUI takes over as texture data); `render` is `render_into` on a new pixmap; (8) checked image source/target/RGBA, alpha-premultiplication scratch and intermediate sizes before resampling, finite transforms and exact source/mask buffers; sources wider than u16 may shrink before backend limits, with a 2^20 source-axis cap and conservative 128 MiB filter-planning estimate; an over-limit or failed resize keeps the original image resolution and geometry when the source fits the backend, otherwise skips it, with a logged warning; staging, resampling output/scratch, RGBA conversion and padding buffers use fallible reserves; (9) `may_paint_canvas`: a fill or stroke whose control-point box, grown by how far its paint reaches past the path (half the stroke width times the larger of the miter limit and √2) plus 0.5 user units and 2 pixels, misses the canvas is not drawn, so a tile no longer strokes and fills every path of its page (item 5 of #623); `set_skip_offscreen_paths` turns this off for the regression test; (10) backport of hayro 0.8: shadings that `as_svg_gradient` can represent are painted as a `vello_cpu` linear or two-point radial gradient instead of a texture sampled pixel by pixel through the shading function (InDesign fades are luminosity soft masks of one full-page axial `sh`: 40 on a report page took 15 s at 144 dpi, now under 1 s); without upstream's half-pixel shift, which suits vello_cpu 0.3 but moves 0.0.8's gradients off pixel centres; (11) `may_paint_rect`: an image whose stream-size box, mapped to the device, misses the canvas is skipped before decoding (decoded data can only shrink against that box), so a tile of an image-heavy page no longer decodes, resamples and rasterizes every image on it; (12) preview renders (`InterpreterSettings::preview`: backdrops, thumbnails, grid cells, signature-drag backgrounds) skip images under `PREVIEW_MIN_IMAGE_AREA` device pixels, while final renders always draw them; (13) reading colours (#897): `RenderSettings::color_replacement` takes a `ColorReplacement` (text colour, background, `only_black`, `line_art`) that remaps solid text and line-art paint while rendering, glyph outlines counting as text and stencil-mask ink as line art; images, image alpha masks, soft masks and pattern cells keep their colours; `render_pdf` gains a `color_replacement: Option<ColorReplacement>` argument (pass `None` for true colours); the upstream-only `[dev-dependencies.log]` entry is removed from `Cargo.toml` (log is a normal dependency since the logging patch), so `cargo test -p hayro` runs this crate's unit tests; (14) a shrunk, interpolated, axis-aligned image is snapped to whole device pixels: shrunk once to its rounded device rectangle and drawn 1:1 at the rounded corner, instead of a ceil-sized raster resampled again at a fractional scale and offset (`snap_minified_image`; scans looked soft next to Acrobat); (15) a soft mask of another size than its image is filtered when shrunk, whatever its `/Interpolate` (#1649): such a mask carries the shape on its own (Word saves text as a tiny black image with a glyph-bitmap mask), and nearest-neighbour dropped every stroke thinner than the shrink factor; (16) under a soft mask or a blend mode, axial and radial shadings are sampled instead of drawn as native gradients (#2128): vello_cpu 0.0.8 copies an opaque gradient over fully covered tiles without the mask or blend mode, so PowerPoint's faded gradient fills came out solid; (17) the renderer keeps annotation paints out of the reading-colours mapping between `begin_annotations` and `end_annotations` (#1548); (18) the page renders as one transparency group with its background painted inside it as the initial backdrop, so a Multiply highlight blends with a dark reading-colours background instead of staying an opaque block (identity on white pages); (19) `set_paiLine truncated
|
||||
| hayro | 0.7.1 | Apache-2.0 OR MIT | (1) `RenderSettings::{x_offset, y_offset}` to render one tile of a large page; (2) images over `MAX_IMAGE_PIXELS` (2^28) are skipped (a fuzzed `/W 4294967295` hung in resampling); (3) `tiling_cell_scale` keeps a tiling pattern's cell pixmap within 3000 px a side whatever its `/XStep`/`/YStep` (a fuzzed step far beyond `/BBox` allocated 2 GB); (4) stroke widths clamped to 4 × (canvas width + height) device pixels (a fuzzed `/LW 9223372036854775807` allocated 10 GB in stroke expansion); (5) `usable_dash_pattern`: a stroke whose dash pattern could cut it into more than `MAX_DASHES_PER_STROKE` (250,000) pieces, counting kurbo's restart of the pattern at every subpath and `ClosePath`, is drawn solid (a fuzzed `/D [[11] 0]` on a line from x = 92234775807 allocated over 5 GB, `[0.000001] 0 d` on a 20 pt line over 10 GB); (6) a dash pattern with a negative or non-finite entry, or a period that isn't positive, is drawn solid (`[-1 -1] 0 d` looped for ever in kurbo); (7) `render_size` and `render_into`: render into a buffer the caller allocates (PdfCraft renders into pixel-aligned memory that the GUI takes over as texture data); `render` is `render_into` on a new pixmap; (8) checked image source/target/RGBA, alpha-premultiplication scratch and intermediate sizes before resampling, finite transforms and exact source/mask buffers; sources wider than u16 may shrink before backend limits, with a 2^20 source-axis cap and conservative 128 MiB filter-planning estimate; an over-limit or failed resize keeps the original image resolution and geometry when the source fits the backend, otherwise skips it, with a logged warning; staging, resampling output/scratch, RGBA conversion and padding buffers use fallible reserves; (9) `may_paint_canvas`: a fill or stroke whose control-point box, grown by how far its paint reaches past the path (half the stroke width times the larger of the miter limit and √2) plus 0.5 user units and 2 pixels, misses the canvas is not drawn, so a tile no longer strokes and fills every path of its page (item 5 of #623); `set_skip_offscreen_paths` turns this off for the regression test; (10) `/Interpolate` governs the pre-resize too (#624): a minified image that does not request interpolation is pre-resized with nearest-neighbour, planned without the Catmull-Rom filter limits (`image_resampling_size` takes the flag); a Type 3 glyph image is sampled bicubically only when interpolated; a minified image with a matching soft mask is nearest-sampled straight into premultiplied RGBA; (11) `may_paint_rect`: an image whose stream-size box, mapped to the device, misses the canvas is skipped before decoding (decoded data can only shrink against that box), so a tile of an image-heavy page no longer decodes, resamples and rasterizes every image on it; (12) preview renders (`InterpreterSettings::preview`: backdrops, thumbnails, grid cells, signature-drag backgrounds) skip images under `PREVIEW_MIN_IMAGE_AREA` device pixels, while final renders always draw them; (13) reading colours (#897): `RenderSettings::color_replacement` takes a `ColorReplacement` (text colour, background, `only_black`, `line_art`) that remaps solid text and line-art paint while rendering, glyph outlines counting as text and stencil-mask ink as line art; images, image alpha masks, soft masks and pattern cells keep their colours; `render_pdf` gains a `color_replacement: Option<ColorReplacement>` argument (pass `None` for true colours); the upstream-only `[dev-dependencies.log]` entry is removed from `Cargo.toml` (log is a normal dependency since the logging patch), so `cargo test -p hayro` runs this crate's unit tests; (14) a shrunk, interpolated, axis-aligned image is snapped to whole device pixels: shrunk once to its rounded device rectangle and drawn 1:1 at the rounded corner, instead of a ceil-sized raster resampled again at a fractional scale and offset (`snap_minified_image`; scans looked soft next to Acrobat); (15) a soft mask of another size than its image is filtered when shrunk, whatever its `/Interpolate` (#1649): such a mask carries the shape on its own (Word saves text as a tiny black image with a glyph-bitmap mask), and nearest-neighbour dropped every stroke thinner than the shrink factor; (16) under a soft mask or a blend mode, axial and radial shadings are sampled instead of drawn as native gradients (#2128): vello_cpu 0.0.8 copies an opaque gradient over fully covered tiles without the mask or blend mode, so PowerPoint's faded gradient fills came out solid; (17) the renderer keeps annotation paints out of the reading-colours mapping between `begin_annotations` and `end_annotations` (#1548); (18) the page renders as one transparency group with its background painted inside it as the initial backdrop, so a Multiply highlight blends with a dark reading-colours background instead of staying an opaque block (identity on white pages); (19) `set_paint` samples a mesh shading's texture over its triangLine truncated
|
||||
| hayro | 0.7.1 | Apache-2.0 OR MIT | (1) `RenderSettings::{x_offset, y_offset}` to render one tile of a large page; (2) images over `MAX_IMAGE_PIXELS` (2^28) are skipped (a fuzzed `/W 4294967295` hung in resampling); (3) `tiling_cell_scale` keeps a tiling pattern's cell pixmap within 3000 px a side whatever its `/XStep`/`/YStep` (a fuzzed step far beyond `/BBox` allocated 2 GB); (4) stroke widths clamped to 4 × (canvas width + height) device pixels (a fuzzed `/LW 9223372036854775807` allocated 10 GB in stroke expansion); (5) `usable_dash_pattern`: a stroke whose dash pattern could cut it into more than `MAX_DASHES_PER_STROKE` (250,000) pieces, counting kurbo's restart of the pattern at every subpath and `ClosePath`, is drawn solid (a fuzzed `/D [[11] 0]` on a line from x = 92234775807 allocated over 5 GB, `[0.000001] 0 d` on a 20 pt line over 10 GB); (6) a dash pattern with a negative or non-finite entry, or a period that isn't positive, is drawn solid (`[-1 -1] 0 d` looped for ever in kurbo); (7) `render_size` and `render_into`: render into a buffer the caller allocates (PdfCraft renders into pixel-aligned memory that the GUI takes over as texture data); `render` is `render_into` on a new pixmap; (8) checked image source/target/RGBA, alpha-premultiplication scratch and intermediate sizes before resampling, finite transforms and exact source/mask buffers; sources wider than u16 may shrink before backend limits, with a 2^20 source-axis cap and conservative 128 MiB filter-planning estimate; an over-limit or failed resize keeps the original image resolution and geometry when the source fits the backend, otherwise skips it, with a logged warning; staging, resampling output/scratch, RGBA conversion and padding buffers use fallible reserves; (9) `may_paint_canvas`: a fill or stroke whose control-point box, grown by how far its paint reaches past the path (half the stroke width times the larger of the miter limit and √2) plus 0.5 user units and 2 pixels, misses the canvas is not drawn, so a tile no longer strokes and fills every path of its page (item 5 of #623); `set_skip_offscreen_paths` turns this off for the regression test; (10) backport of hayro 0.8: shadings that `as_svg_gradient` can represent are painted as a `vello_cpu` linear or two-point radial gradient instead of a texture sampled pixel by pixel through the shading function (InDesign fades are luminosity soft masks of one full-page axial `sh`: 40 on a report page took 15 s at 144 dpi, now under 1 s); without upstream's half-pixel shift, which suits vello_cpu 0.3 but moves 0.0.8's gradients off pixel centres; (11) `may_paint_rect`: an image whose stream-size box, mapped to the device, misses the canvas is skipped before decoding (decoded data can only shrink against that box), so a tile of an image-heavy page no longer decodes, resamples and rasterizes every image on it; (12) preview renders (`InterpreterSettings::preview`: backdrops, thumbnails, grid cells, signature-drag backgrounds) skip images under `PREVIEW_MIN_IMAGE_AREA` device pixels, while final renders always draw them; (13) reading colours (#897): `RenderSettings::color_replacement` takes a `ColorReplacement` (text colour, background, `only_black`, `line_art`) that remaps solid text and line-art paint while rendering, glyph outlines counting as text and stencil-mask ink as line art; images, image alpha masks, soft masks and pattern cells keep their colours; `render_pdf` gains a `color_replacement: Option<ColorReplacement>` argument (pass `None` for true colours); the upstream-only `[dev-dependencies.log]` entry is removed from `Cargo.toml` (log is a normal dependency since the logging patch), so `cargo test -p hayro` runs this crate's unit tests; (14) a shrunk, interpolated, axis-aligned image is snapped to whole device pixels: shrunk once to its rounded device rectangle and drawn 1:1 at the rounded corner, instead of a ceil-sized raster resampled again at a fractional scale and offset (`snap_minified_image`; scans looked soft next to Acrobat); (15) a soft mask of another size than its image is filtered when shrunk, whatever its `/Interpolate` (#1649): such a mask carries the shape on its own (Word saves text as a tiny black image with a glyph-bitmap mask), and nearest-neighbour dropped every stroke thinner than the shrink factor; (16) under a soft mask or a blend mode, axial and radial shadings are sampled instead of drawn as native gradients (#2128): vello_cpu 0.0.8 copies an opaque gradient over fully covered tiles without the mask or blend mode, so PowerPoint's faded gradient fills came out solid; (17) the renderer keeps annotation paints out of the reading-colours mapping between `begin_annotations` and `end_annotations` (#1548); (18) the page renders as one transparency group with its background painted inside it as the initial backdrop, so a Multiply highlight blends with a dark reading-colours background instead of staying an opaque block (identity on white pages); (19) `set_paiLine truncated
|
||||
| hayro | 0.7.1 | Apache-2.0 OR MIT | (1) `RenderSettings::{x_offset, y_offset}` to render one tile of a large page; (2) images over `MAX_IMAGE_PIXELS` (2^28) are skipped (a fuzzed `/W 4294967295` hung in resampling); (3) `tiling_cell_scale` keeps a tiling pattern's cell pixmap within 3000 px a side whatever its `/XStep`/`/YStep` (a fuzzed step far beyond `/BBox` allocated 2 GB); (4) stroke widths clamped to 4 × (canvas width + height) device pixels (a fuzzed `/LW 9223372036854775807` allocated 10 GB in stroke expansion); (5) `usable_dash_pattern`: a stroke whose dash pattern could cut it into more than `MAX_DASHES_PER_STROKE` (250,000) pieces, counting kurbo's restart of the pattern at every subpath and `ClosePath`, is drawn solid (a fuzzed `/D [[11] 0]` on a line from x = 92234775807 allocated over 5 GB, `[0.000001] 0 d` on a 20 pt line over 10 GB); (6) a dash pattern with a negative or non-finite entry, or a period that isn't positive, is drawn solid (`[-1 -1] 0 d` looped for ever in kurbo); (7) `render_size` and `render_into`: render into a buffer the caller allocates (PdfCraft renders into pixel-aligned memory that the GUI takes over as texture data); `render` is `render_into` on a new pixmap; (8) checked image source/target/RGBA, alpha-premultiplication scratch and intermediate sizes before resampling, finite transforms and exact source/mask buffers; sources wider than u16 may shrink before backend limits, with a 2^20 source-axis cap and conservative 128 MiB filter-planning estimate; an over-limit or failed resize keeps the original image resolution and geometry when the source fits the backend, otherwise skips it, with a logged warning; staging, resampling output/scratch, RGBA conversion and padding buffers use fallible reserves; (9) `may_paint_canvas`: a fill or stroke whose control-point box, grown by how far its paint reaches past the path (half the stroke width times the larger of the miter limit and √2) plus 0.5 user units and 2 pixels, misses the canvas is not drawn, so a tile no longer strokes and fills every path of its page (item 5 of #623); `set_skip_offscreen_paths` turns this off for the regression test; (10) `/Interpolate` governs the pre-resize too (#624): a minified image that does not request interpolation is pre-resized with nearest-neighbour, planned without the Catmull-Rom filter limits (`image_resampling_size` takes the flag); a Type 3 glyph image is sampled bicubically only when interpolated; a minified image with a matching soft mask is nearest-sampled straight into premultiplied RGBA; (11) `may_paint_rect`: an image whose stream-size box, mapped to the device, misses the canvas is skipped before decoding (decoded data can only shrink against that box), so a tile of an image-heavy page no longer decodes, resamples and rasterizes every image on it; (12) preview renders (`InterpreterSettings::preview`: backdrops, thumbnails, grid cells, signature-drag backgrounds) skip images under `PREVIEW_MIN_IMAGE_AREA` device pixels, while final renders always draw them; (13) reading colours (#897): `RenderSettings::color_replacement` takes a `ColorReplacement` (text colour, background, `only_black`, `line_art`) that remaps solid text and line-art paint while rendering, glyph outlines counting as text and stencil-mask ink as line art; images, image alpha masks, soft masks and pattern cells keep their colours; `render_pdf` gains a `color_replacement: Option<ColorReplacement>` argument (pass `None` for true colours); the upstream-only `[dev-dependencies.log]` entry is removed from `Cargo.toml` (log is a normal dependency since the logging patch), so `cargo test -p hayro` runs this crate's unit tests; (14) a shrunk, interpolated, axis-aligned image is snapped to whole device pixels: shrunk once to its rounded device rectangle and drawn 1:1 at the rounded corner, instead of a ceil-sized raster resampled again at a fractional scale and offset (`snap_minified_image`; scans looked soft next to Acrobat); (15) a soft mask of another size than its image is filtered when shrunk, whatever its `/Interpolate` (#1649): such a mask carries the shape on its own (Word saves text as a tiny black image with a glyph-bitmap mask), and nearest-neighbour dropped every stroke thinner than the shrink factor; (16) under a soft mask or a blend mode, axial and radial shadings are sampled instead of drawn as native gradients (#2128): vello_cpu 0.0.8 copies an opaque gradient over fully covered tiles without the mask or blend mode, so PowerPoint's faded gradient fills came out solid; (17) the renderer keeps annotation paints out of the reading-colours mapping between `begin_annotations` and `end_annotations` (#1548); (18) the page renders as one transparency group with its background painted inside it as the initial backdrop, so a Multiply highlight blends with a dark reading-colours background instead of staying an opaque block (identity on white pages); (19) `set_paint` samples a mesh shading's texture over its triangLine truncated
|
||||
| hayro-jbig2 | 0.3.0 | Apache-2.0 OR MIT | (1) at most 2^28 pixels per bitmap, page bitmap, halftone grid and grayscale image (each side could be 65535: 4.3 billion pixels decoded one by one); (2) at most 2^26 symbol pixels per symbol dictionary (a fuzzed dictionary decoded for minutes); (3) a symbol dictionary's height classes are capped at one per new symbol and its export runs at `2 × symbols + 1`, each plus `EXTRA_EMPTY_STEPS` (1024): an empty height class or a zero-length export run doesn't advance, and past the end of its data the arithmetic decoder can decode them for ever (one changed byte hung the renderer) | (1) `raster::tests::jbig2_regions_of_billions_of_pixels_are_refused`; (2) the nightly `cargo xtask fuzz` finding, which now finishes in about a second; (3) `raster::tests::jbig2_symbol_dictionaries_that_never_advance_terminate` |
|
||||
| lopdf | 0.45.0 | MIT | (1) PNG predictor rows longer than the data are refused before their buffers are allocated (a fuzzed `/Columns 4294967295` allocated two 4 GiB rows), and empty frames return without row buffers; (2) predictor row widths use saturating arithmetic or reject overflow; (3) sub-byte TIFF Predictor 2 scratch is bounded by the samples present in the input instead of the declared `/Colors`, aligned with [lopdf#589](https://github.com/J-F-Liu/lopdf/pull/589) | (1) `inspect::tests::png_predictor_rows_longer_than_the_data_are_refused_before_allocating`, `inspect::tests::empty_png_predictor_frames_do_not_allocate_rows`; (2) `inspect::tests::tiff_subbyte_predictor_row_width_overflow_is_refused`; (3) `inspect::tests::tiff_subbyte_predictor_scratch_is_bounded_by_available_samples`, `inspect::tests::tiff_subbyte_predictors_keep_components_rows_and_padding` |
|
||||
| hayro-syntax | 0.7.2 | Apache-2.0 OR MIT | (1) Page-tree cycle guard in `resolve_pages` (visited set + depth cap): a `/Kids` loop among compressed objects overflowed the stack and aborted the process; (2) `ccitt_size_ok`: CCITT images wider than 2^20 columns or over 2^28 pixels are not decoded (a fuzzed `/Columns 4294967295` allocated 4 GiB); (3) Flate/LZW predictor row widths are saturating `usize`, a zero width is refused and a row longer than the data is not allocated (a fuzzed `/Columns 9223372036854775807` wrapped to a 2^61-byte allocation and aborted); (4) the inline-image end-of-data check (`EI`) doesn't nest inside its own look-ahead and examines at most 256 candidates and steps (50 images with "EI" in their data ran for over ten minutes); (5) a stream whose `/Length` is wrong is recovered only when `stream` is the next token — scanning ahead to a later object's `stream` made an indirect appearance-state dictionary (Quartz checkboxes: `/AP /N` → `<< /Yes … /Off … >>`) render as a non-form, so the widget was skipped; (6) JPX rescaling uses an exact integer sample range for 1–32-bit components (32 shifted past u32, and floating-point maxima at 25–31 bits wrapped to zero), and refuses zero-sized rows; (7) `decode_limit`: Flate (through flate2 and the fallback inflater), LZW and RunLength never write past `MAX_DECODED_STREAM` (256 MiB), or, for the last filter of an image of known size, past twice its pixel bytes (a predictor tag byte per byte), at most 1 GiB; `Stream::decoded_within` for budgeted callers; a page's `/Contents` array shares one `MAX_DECODED_STREAM` (a 2 MB page whose content stream or 8 × 8 image inflated to 2 GB took the renderer past 3 GB in under a second; naming the stream twenty times in `/Contents`, 5 GB); (8) high-precision numbers (jsPDF MediaBox coordinates with over 19 digits) parse without overflowing the u64 mantissa: fractional digits past it are dropped, integer digits past it scale the value (a real, kept finite); (9) large dictionary indexes are built on first use and shared across repeated reads within each PDF (#307); the validated-byte cache is bounded, reader contexts remain separate, repairs and inline/content dictionaries bypass sharing, and small dictionaries stay eager; (10) decoded object-stream slots publish once under contention, cold loading rejects recursive dependencies, and xref repair serializes without holding recursive read guards; this permits one parser per native render pool with private worker caches; (11) `sync.rs`: a poisoned lock is recovered instead of unwrapped (a worker panic no longer cascades into every reader of the same PDF), and xref repair takes a blocking write lock instead of asserting a non-blocking one; (12) `SegmentList` (`util.rs`) returns `None` for an out-of-range index instead of panicking; (13) a page's `/UserUnit` scales `render_dimensions` and `initial_transform`, so the page and everything on it are sized in points, as Acrobat shows them; it is read as Acrobat reads it (the page's own entry, not inherited; a number from 1 up, at most 75,000; anything else counts as 1), and a page without it keeps exactly the transform it had; (14) revision 2–4 passwords are tried as given and then in PDFDocEncoding (`legacy_passwords` in `crypto/mod.rs`, which resolves the upstream `TODO: Convert to PDFDocEncoding`): passwords arrive as UTF-8 text, so a password with characters outside ASCII (`Çok güzel`, `ılık€`) written in PDFDocEncoding, as ISO 32000-2 §7.6.4.3.2 asks and qpdf and Acrobat write it, was always wrong; (15) page content is read a piece at a time (`page::ContentReader`, `Page::content_reader`): plain streams and Flate streams without a predictor are decoded as they are read, with a budget of 64 times their compressed size and never less than `MAX_DECODED_STREAM` (a stream that expands past it is cut and reported); other streams are decoded whole, as before, and share `MAX_DECODED_STREAM`. The content tokenizer reads a window at a time (`UntypedIter::new_window`, `TypedIter::needs_more`, `TypedIter::committed`): an instruction that runs past the window is not decided until more data follows, which `Reader` records by flagging reads and `at_end` past the end of the data, including through the clones the parser makes. The Flate decoder keeps its own 32 KiB history, so it pauses at any output size. `ContentReader::new` reuses raw/decrypted stream bytes for budget accounting and piece creation, and `decoded_raw_within` applies the existing Whole-stream filters and limits to those bytes without decrypting twice; (16) revision 5–6 (AES-256) passwords are tried in their SASLprep form (RFC 4013, then UTF-8, at most 127 bytes, as ISO 32000-2 §7.6.4.3.3 Algorithm 2.A asks and pdfcraft-crypt writes them) and then, if that differs, as given (`aes256_passwords` in `crypto/mod.rs`, which resolves the upstream `TODO: Do the above.`; `stringprep`, already in the tree through pdfcraft-crypt, is an optional dependencyLine truncated
|
||||
|
||||
Vendored
+34
@@ -73,6 +73,40 @@ pub trait Device<'a> {
|
||||
fn begin_annotations(&mut self) {}
|
||||
/// PdfCraft patch (29): the page's annotations are done; what follows is page content.
|
||||
fn end_annotations(&mut self) {}
|
||||
/// PdfCraft patch (39): the transparency group just pushed is a knockout group (`/K true`):
|
||||
/// each of its elements composites with the group's initial backdrop, not with the
|
||||
/// elements drawn before it in the group (ISO 32000-2, knockout groups), until the
|
||||
/// matching `pop_transparency_group`.
|
||||
fn set_knockout(&mut self) {}
|
||||
/// PdfCraft patch (39): an element whose shape is `shape` (device space) is about to be
|
||||
/// drawn into a transparency group of its own. In a knockout group (`set_knockout`) the
|
||||
/// element replaces what the group drew under its shape, so a device clears that first;
|
||||
/// the element's layer then composites over the cleared area as usual.
|
||||
fn knockout_shape(&mut self, _shape: &BezPath) {}
|
||||
/// PdfCraft patch (39): whether `knockout_shape` would clear anything now, that is whether
|
||||
/// the innermost transparency group is a knockout group. Lets the interpreter skip work it
|
||||
/// only needs for the clear.
|
||||
fn in_knockout_group(&mut self) -> bool {
|
||||
false
|
||||
}
|
||||
/// PdfCraft patch (39): `image`, an unmasked raster image, is about to be drawn with
|
||||
/// `transform` in a knockout group. A device that will draw it (it isn't skipped and it
|
||||
/// decodes) clears what the group drew under its placement rectangle first, so the image
|
||||
/// replaces it. Decided by the device, at the size it draws the image, so the draw reuses
|
||||
/// that decode.
|
||||
fn knockout_image(&mut self, _image: &crate::RasterImage<'_>, _transform: Affine) {}
|
||||
/// PdfCraft patch (39): whether a transparency group drawn now is an element of a knockout
|
||||
/// group that the device wants cleared under the group's shape first. If so the
|
||||
/// interpreter draws the group's content once between `begin_knockout_erase` and
|
||||
/// `end_knockout_erase`, in which every paint clears what is under its shape instead of
|
||||
/// painting, and then draws the group as usual, in a layer of its own.
|
||||
fn knockout_erase_wanted(&mut self) -> bool {
|
||||
false
|
||||
}
|
||||
/// PdfCraft patch (39): see `knockout_erase_wanted`.
|
||||
fn begin_knockout_erase(&mut self) {}
|
||||
/// PdfCraft patch (39): see `knockout_erase_wanted`.
|
||||
fn end_knockout_erase(&mut self) {}
|
||||
}
|
||||
|
||||
/// A device that discards all drawing operations.
|
||||
|
||||
+47
-1
@@ -162,7 +162,38 @@ pub(crate) fn draw_form_xobject<'a, 'b>(
|
||||
&& state.soft_mask.is_none()
|
||||
&& state.blend_mode == BlendMode::Normal
|
||||
};
|
||||
let own_layer = x_object.is_transparency_group && !neutral;
|
||||
// PdfCraft patch (39): a group drawn as an element of a knockout group replaces what that
|
||||
// group drew under its shape, the union of its own elements' shapes (#2971). The shape is
|
||||
// cleared by drawing the group's content once in the device's erase mode; the group then
|
||||
// composites over the cleared area in a layer of its own (also when it would otherwise be
|
||||
// drawn straight onto its parent, where its elements would knock each other out).
|
||||
let knockout_element = x_object.is_transparency_group && device.knockout_erase_wanted();
|
||||
if knockout_element {
|
||||
context.save_state();
|
||||
device.begin_knockout_erase();
|
||||
device.push_clip_path(&ClipPath {
|
||||
path: context.get().ctm
|
||||
* Rect::new(
|
||||
x_object.bbox[0] as f64,
|
||||
x_object.bbox[1] as f64,
|
||||
x_object.bbox[2] as f64,
|
||||
x_object.bbox[3] as f64,
|
||||
)
|
||||
.to_path(0.1),
|
||||
fill: FillRule::NonZero,
|
||||
});
|
||||
interpret(
|
||||
TypedIter::new(x_object.decoded.as_ref()),
|
||||
&Resources::from_parent(x_object.resources.clone(), resources.clone()),
|
||||
context,
|
||||
device,
|
||||
);
|
||||
device.pop_clip_path();
|
||||
device.end_knockout_erase();
|
||||
context.restore_state(device);
|
||||
context.path_mut().truncate(0);
|
||||
}
|
||||
let own_layer = x_object.is_transparency_group && (!neutral || knockout_element);
|
||||
|
||||
if own_layer {
|
||||
device.push_transparency_group(
|
||||
@@ -173,6 +204,10 @@ pub(crate) fn draw_form_xobject<'a, 'b>(
|
||||
|
||||
context.get_mut().graphics_state.non_stroke_alpha = 1.0;
|
||||
context.get_mut().graphics_state.stroke_alpha = 1.0;
|
||||
// PdfCraft patch (39): its elements knock each other out (#2971).
|
||||
if x_object.is_knockout {
|
||||
device.set_knockout();
|
||||
}
|
||||
}
|
||||
|
||||
device.set_soft_mask(context.get().graphics_state.soft_mask.clone());
|
||||
@@ -254,6 +289,17 @@ pub(crate) fn draw_image_xobject<'a, 'b>(
|
||||
soft_mask = None;
|
||||
}
|
||||
|
||||
// PdfCraft patch (39): an image without a mask covers its whole placement rectangle, so in
|
||||
// a knockout group it replaces what the group drew there (#2971). A stencil's or a masked
|
||||
// image's shape is its mask; those composite as before (exact where the mask is opaque or
|
||||
// transparent, which is what masks mostly are). Only an image the device draws clears: one
|
||||
// that doesn't decode (over `MAX_IMAGE_PIXELS`, damaged data) or that it skips (a preview's
|
||||
// tiny image) replaces nothing. The device decides, at its own draw size (review on #2974:
|
||||
// a full-size decode here cost a second decode of every downscaled image).
|
||||
if !x_object.is_mask && !has_alpha && device.in_knockout_group() {
|
||||
device.knockout_image(&RasterImage(x_object.clone()), transform);
|
||||
}
|
||||
|
||||
device.push_transparency_group(
|
||||
context.get().graphics_state.non_stroke_alpha,
|
||||
std::mem::take(&mut soft_mask),
|
||||
|
||||
Vendored
+180
-30
@@ -444,6 +444,13 @@ pub(crate) struct Renderer {
|
||||
/// PdfCraft patch (17): while the page's annotations are being drawn, paints keep their
|
||||
/// colours — reading colours replace document colours, never annotation colours.
|
||||
in_annotations: bool,
|
||||
/// PdfCraft patch (19): one entry per transparency group pushed, whether it is a knockout
|
||||
/// group (`Device::set_knockout`).
|
||||
knockout: Vec<bool>,
|
||||
/// PdfCraft patch (19): inside a knockout erase pass (`Device::begin_knockout_erase`), and
|
||||
/// how many transparency groups were skipped in it (nothing is layered while erasing).
|
||||
erasing: bool,
|
||||
erase_groups: usize,
|
||||
pub(crate) inside_pattern: bool,
|
||||
/// Soft masks drawn during this render. PdfCraft note: it belongs to one `Renderer` (one
|
||||
/// render, every nested renderer starting empty) and so to one `preview` setting: a mask
|
||||
@@ -467,6 +474,11 @@ enum ImagePixelFormat {
|
||||
}
|
||||
|
||||
impl Renderer {
|
||||
/// PdfCraft patch (19): whether the innermost transparency group is a knockout group.
|
||||
fn in_knockout(&self) -> bool {
|
||||
self.knockout.last().copied().unwrap_or(false)
|
||||
}
|
||||
|
||||
pub(crate) fn new(
|
||||
width: u16,
|
||||
height: u16,
|
||||
@@ -479,6 +491,9 @@ impl Renderer {
|
||||
ctx: RenderContext::new_with(width, height, settings),
|
||||
color_replacement,
|
||||
in_annotations: false,
|
||||
knockout: Vec::new(),
|
||||
erasing: false,
|
||||
erase_groups: 0,
|
||||
inside_pattern: false,
|
||||
soft_mask_cache: HashMap::default(),
|
||||
outline_cache: cache.outline_cache.clone(),
|
||||
@@ -580,6 +595,9 @@ impl Renderer {
|
||||
// original values, so it is never remapped by the reading-colours setting.
|
||||
color_replacement: None,
|
||||
in_annotations: false,
|
||||
knockout: Vec::new(),
|
||||
erasing: false,
|
||||
erase_groups: 0,
|
||||
inside_pattern: false,
|
||||
soft_mask_cache: HashMap::default(),
|
||||
outline_cache: self.outline_cache.clone(),
|
||||
@@ -744,6 +762,40 @@ impl Renderer {
|
||||
}
|
||||
}
|
||||
|
||||
/// The size an image of `width` x `height` samples is decoded at to be drawn with
|
||||
/// `transform`, or `None` if `draw_image` skips it: off the canvas (PdfCraft patch: see
|
||||
/// `may_paint_rect`; checked before decoding, so a tile no longer decodes every image on its
|
||||
/// page), or, in a preview, covering only a few device pixels (PdfCraft patch; final renders
|
||||
/// always draw them). The tiny-image test measures axis lengths: the size returned maps a
|
||||
/// point, so it includes the translation and only suits the decode hint.
|
||||
fn image_draw_size(&self, width: u32, height: u32, transform: Affine) -> Option<(u32, u32)> {
|
||||
if !may_paint_rect(
|
||||
Rect::new(0.0, 0.0, f64::from(width), f64::from(height)),
|
||||
transform,
|
||||
self.ctx.width(),
|
||||
self.ctx.height(),
|
||||
) {
|
||||
return None;
|
||||
}
|
||||
let target_width = (transform * Point::new(width as f64, 0.0))
|
||||
.to_vec2()
|
||||
.length()
|
||||
.ceil() as u32;
|
||||
let target_height = (transform * Point::new(0.0, height as f64))
|
||||
.to_vec2()
|
||||
.length()
|
||||
.ceil() as u32;
|
||||
if self.preview {
|
||||
let c = transform.as_coeffs();
|
||||
let tiny_w = (f64::from(width) * (c[0] * c[0] + c[1] * c[1]).sqrt()).ceil() as u32;
|
||||
let tiny_h = (f64::from(height) * (c[2] * c[2] + c[3] * c[3]).sqrt()).ceil() as u32;
|
||||
if tiny_w.saturating_mul(tiny_h) < PREVIEW_MIN_IMAGE_AREA {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
Some((target_width, target_height))
|
||||
}
|
||||
|
||||
fn draw_image(&mut self, image_data: ImageData, alpha_data: Option<LumaData>) {
|
||||
let cur_transform = *self.ctx.transform();
|
||||
let (x_scale, y_scale) = {
|
||||
@@ -1049,6 +1101,20 @@ impl Renderer {
|
||||
|
||||
#[must_use]
|
||||
fn set_paint(&mut self, paint: &Paint<'_>, path: &BezPath, is_stroke: bool) -> PaintSetup {
|
||||
// PdfCraft patch (19): in a knockout erase pass every paint clears what is under its
|
||||
// shape (a transparent fill with `Compose::Copy`, weighted by coverage).
|
||||
if self.erasing {
|
||||
self.ctx.set_blend_mode(knockout_blend_mode());
|
||||
self.ctx.set_paint(AlphaColor::<Srgb>::new([0.0, 0.0, 0.0, 0.0]));
|
||||
// A shading's `/BBox` clips what it paints, so it clips what it clears too.
|
||||
return PaintSetup::Clip(match paint {
|
||||
Paint::Pattern(p) => match p.as_ref() {
|
||||
Pattern::Shading(s) => s.shading.clip_path.clone(),
|
||||
_ => None,
|
||||
},
|
||||
_ => None,
|
||||
});
|
||||
}
|
||||
let mut paint_transform = Affine::IDENTITY;
|
||||
let mut clip_path = None;
|
||||
// PdfCraft patch (19): `Extend::Repeat` tiles the texture over the path; a mesh texture
|
||||
@@ -1197,6 +1263,9 @@ impl Renderer {
|
||||
),
|
||||
color_replacement: None,
|
||||
in_annotations: false,
|
||||
knockout: Vec::new(),
|
||||
erasing: false,
|
||||
erase_groups: 0,
|
||||
cur_mask: None,
|
||||
inside_pattern: true,
|
||||
soft_mask_cache: HashMap::default(),
|
||||
@@ -1251,6 +1320,9 @@ impl Renderer {
|
||||
// content is never remapped by the reading-colours setting.
|
||||
color_replacement: None,
|
||||
in_annotations: false,
|
||||
knockout: Vec::new(),
|
||||
erasing: false,
|
||||
erase_groups: 0,
|
||||
cur_mask: None,
|
||||
inside_pattern: true,
|
||||
soft_mask_cache: HashMap::default(),
|
||||
@@ -1444,40 +1516,19 @@ impl Renderer {
|
||||
|
||||
impl<'a> Device<'a> for Renderer {
|
||||
fn draw_image(&mut self, image: hayro_interpret::Image<'a, '_>, mut transform: Affine) {
|
||||
// PdfCraft patch: see `may_paint_rect`. Checked before decoding: off-canvas images
|
||||
// cost nothing, so a tile no longer decodes every image on its page.
|
||||
if !may_paint_rect(
|
||||
Rect::new(0.0, 0.0, f64::from(image.width()), f64::from(image.height())),
|
||||
transform,
|
||||
self.ctx.width(),
|
||||
self.ctx.height(),
|
||||
) {
|
||||
// PdfCraft patch (19): an erase pass paints nothing; an unmasked image's rectangle was
|
||||
// cleared by `knockout_shape`, and a masked image's shape is left alone.
|
||||
if self.erasing {
|
||||
return;
|
||||
}
|
||||
let Some((target_width, target_height)) =
|
||||
self.image_draw_size(image.width(), image.height(), transform)
|
||||
else {
|
||||
return;
|
||||
};
|
||||
self.ctx.set_paint_transform(Affine::IDENTITY);
|
||||
self.ctx.set_aliasing_threshold(Some(1));
|
||||
|
||||
let target_width = (transform * Point::new(image.width() as f64, 0.0))
|
||||
.to_vec2()
|
||||
.length()
|
||||
.ceil() as u32;
|
||||
let target_height = (transform * Point::new(0.0, image.height() as f64))
|
||||
.to_vec2()
|
||||
.length()
|
||||
.ceil() as u32;
|
||||
|
||||
// PdfCraft patch: previews skip images that would cover only a few device pixels.
|
||||
// Final renders always draw them. (Measured as axis lengths: the `target_*` above
|
||||
// map a point, so they include the translation and only suit the decode hint.)
|
||||
if self.preview {
|
||||
let c = transform.as_coeffs();
|
||||
let tiny_w = (f64::from(image.width()) * (c[0] * c[0] + c[1] * c[1]).sqrt()).ceil() as u32;
|
||||
let tiny_h = (f64::from(image.height()) * (c[2] * c[2] + c[3] * c[3]).sqrt()).ceil() as u32;
|
||||
if tiny_w.saturating_mul(tiny_h) < PREVIEW_MIN_IMAGE_AREA {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
match image {
|
||||
hayro_interpret::Image::Stencil(s) => {
|
||||
s.with_stencil(
|
||||
@@ -1567,6 +1618,9 @@ impl<'a> Device<'a> for Renderer {
|
||||
// the reading-colours setting.
|
||||
color_replacement: None,
|
||||
in_annotations: false,
|
||||
knockout: Vec::new(),
|
||||
erasing: false,
|
||||
erase_groups: 0,
|
||||
inside_pattern: false,
|
||||
soft_mask_cache: HashMap::default(),
|
||||
outline_cache: self.outline_cache.clone(),
|
||||
@@ -1644,6 +1698,11 @@ impl<'a> Device<'a> for Renderer {
|
||||
mask: Option<SoftMask<'_>>,
|
||||
blend_mode: BlendMode,
|
||||
) {
|
||||
// PdfCraft patch (19): nothing is layered in a knockout erase pass.
|
||||
if self.erasing {
|
||||
self.erase_groups += 1;
|
||||
return;
|
||||
}
|
||||
let settings = *self.ctx.render_settings();
|
||||
let force_images_may_have_transparency = mask.is_some()
|
||||
|| blend_mode != BlendMode::Normal
|
||||
@@ -1670,6 +1729,7 @@ impl<'a> Device<'a> for Renderer {
|
||||
);
|
||||
self.image_transparency_stack
|
||||
.push(force_images_may_have_transparency);
|
||||
self.knockout.push(false);
|
||||
}
|
||||
|
||||
fn pop_clip_path(&mut self) {
|
||||
@@ -1677,10 +1737,86 @@ impl<'a> Device<'a> for Renderer {
|
||||
}
|
||||
|
||||
fn pop_transparency_group(&mut self) {
|
||||
if self.erasing && self.erase_groups > 0 {
|
||||
self.erase_groups -= 1;
|
||||
return;
|
||||
}
|
||||
self.image_transparency_stack.pop();
|
||||
self.knockout.pop();
|
||||
self.ctx.pop_layer();
|
||||
}
|
||||
|
||||
/// PdfCraft patch (19): the group just pushed is a knockout group. Its elements are drawn
|
||||
/// with `Compose::Copy`, which (weighted by coverage) replaces what earlier elements drew
|
||||
/// where the element's shape is, so each element composites with the group's initial
|
||||
/// backdrop (transparent: an isolated group, and the non-isolated approximation every
|
||||
/// group layer here already makes) instead of with the elements before it. Against a
|
||||
/// transparent backdrop the element's own blend mode has nothing to blend with, so the
|
||||
/// mix is Normal. This covers paths, strokes, glyph outlines and shadings. Images and
|
||||
/// nested groups are drawn into a layer of their own, which can't be copied (it covers the
|
||||
/// whole canvas, transparent where nothing was drawn): what is under their shape is cleared
|
||||
/// first (`knockout_shape`, the knockout erase pass) and the layer composites over it.
|
||||
fn set_knockout(&mut self) {
|
||||
if let Some(top) = self.knockout.last_mut() {
|
||||
*top = true;
|
||||
self.ctx.set_blend_mode(knockout_blend_mode());
|
||||
}
|
||||
}
|
||||
|
||||
/// PdfCraft patch (19): in a knockout group, clear what the group drew under `shape` (a
|
||||
/// transparent fill with `Compose::Copy`, weighted by coverage) before an element drawn into
|
||||
/// a layer of its own composites there, so the element replaces it.
|
||||
fn knockout_erase_wanted(&mut self) -> bool {
|
||||
self.in_knockout() && !self.erasing
|
||||
}
|
||||
|
||||
fn begin_knockout_erase(&mut self) {
|
||||
self.erasing = true;
|
||||
self.erase_groups = 0;
|
||||
}
|
||||
|
||||
fn end_knockout_erase(&mut self) {
|
||||
self.erasing = false;
|
||||
self.erase_groups = 0;
|
||||
self.ctx.set_blend_mode(knockout_blend_mode());
|
||||
}
|
||||
|
||||
fn in_knockout_group(&mut self) -> bool {
|
||||
self.in_knockout()
|
||||
}
|
||||
|
||||
fn knockout_image(&mut self, image: &hayro_interpret::RasterImage<'_>, transform: Affine) {
|
||||
if !self.in_knockout() {
|
||||
return;
|
||||
}
|
||||
// Only an image `draw_image` will draw, decoded at the size it draws it (the same
|
||||
// decode, so a cached decode serves both).
|
||||
let Some(size) = self.image_draw_size(image.width(), image.height(), transform) else {
|
||||
return;
|
||||
};
|
||||
let mut decodes = false;
|
||||
image.with_rgba(|_, _| decodes = true, Some(size));
|
||||
if decodes {
|
||||
let rect = Rect::new(0.0, 0.0, f64::from(image.width()), f64::from(image.height()));
|
||||
self.knockout_shape(&(transform * rect.to_path(0.1)));
|
||||
}
|
||||
}
|
||||
|
||||
fn knockout_shape(&mut self, shape: &BezPath) {
|
||||
if !self.in_knockout() {
|
||||
return;
|
||||
}
|
||||
let old_transform = *self.ctx.transform();
|
||||
let old_rule = *self.ctx.fill_rule();
|
||||
self.ctx.set_transform(Affine::IDENTITY);
|
||||
self.ctx.set_fill_rule(Fill::NonZero);
|
||||
self.ctx.set_blend_mode(knockout_blend_mode());
|
||||
self.ctx.set_paint(AlphaColor::<Srgb>::new([0.0, 0.0, 0.0, 0.0]));
|
||||
self.ctx.fill_path(shape);
|
||||
self.ctx.set_fill_rule(old_rule);
|
||||
self.ctx.set_transform(old_transform);
|
||||
}
|
||||
|
||||
fn set_soft_mask(&mut self, mask: Option<SoftMask<'_>>) {
|
||||
let settings = *self.ctx.render_settings();
|
||||
self.cur_mask = mask.map(|m| {
|
||||
@@ -1784,7 +1920,13 @@ impl<'a> Device<'a> for Renderer {
|
||||
}
|
||||
|
||||
fn set_blend_mode(&mut self, blend_mode: BlendMode) {
|
||||
self.ctx.set_blend_mode(convert_blend_mode(blend_mode));
|
||||
// PdfCraft patch (19): inside a knockout group every element replaces what it covers.
|
||||
let mode = if self.in_knockout() {
|
||||
knockout_blend_mode()
|
||||
} else {
|
||||
convert_blend_mode(blend_mode)
|
||||
};
|
||||
self.ctx.set_blend_mode(mode);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1868,6 +2010,9 @@ fn draw_soft_mask(mask: &SoftMask<'_>, settings: RenderSettings, width: u16, hei
|
||||
// content is never remapped by the reading-colours setting.
|
||||
color_replacement: None,
|
||||
in_annotations: false,
|
||||
knockout: Vec::new(),
|
||||
erasing: false,
|
||||
erase_groups: 0,
|
||||
inside_pattern: false,
|
||||
cur_mask: None,
|
||||
soft_mask_cache: HashMap::default(),
|
||||
@@ -1962,6 +2107,11 @@ fn convert_fill_rule(fill_rule: FillRule) -> Fill {
|
||||
}
|
||||
}
|
||||
|
||||
/// PdfCraft patch (19): how an element of a knockout group is drawn (see `set_knockout`).
|
||||
fn knockout_blend_mode() -> peniko::BlendMode {
|
||||
peniko::BlendMode::new(Mix::Normal, Compose::Copy)
|
||||
}
|
||||
|
||||
fn convert_blend_mode(blend_mode: BlendMode) -> peniko::BlendMode {
|
||||
let mix = match blend_mode {
|
||||
BlendMode::Normal => Mix::Normal,
|
||||
|
||||
Reference in new issue
Block a user