summaryrefslogtreecommitdiff
path: root/src/pdf.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-06 06:24:42 -0300
committerGabriel Schneider <[email protected]>2026-11-06 11:19:44 -0300
commitc1917b949b9580de8bf0977874a210f0266812da (patch)
tree447dd2235ea00634f662cd3becf4bceb8a895f41 /src/pdf.zig
parent76c55b5bce0f181b0b15b16596c900397dfef544 (diff)
downloadpardes-c1917b949b9580de8bf0977874a210f0266812da.tar.gz
pardes-c1917b949b9580de8bf0977874a210f0266812da.zip
kinds #14, the core's PDF code gone: pdf.zig and pdf_view.zig leave and every pdf_enabled branch with them; look, Jump, Recent, dumps (one from before the addon opens as its pane), the watch, mouse, keys, the rail and the tag go through Kind for any kind's pane; test/pdf.zig's behaviours are T1 cases over 9P (addons_pdf.zig) and pane cases (a Shadow over a replica, a file changed under it), the harnesses load pdf.so by path
Co-Authored-By: Claude Fable 5.1 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge
Diffstat (limited to 'src/pdf.zig')
-rw-r--r--src/pdf.zig1904
1 files changed, 0 insertions, 1904 deletions
diff --git a/src/pdf.zig b/src/pdf.zig
deleted file mode 100644
index 7cfb86d5..00000000
--- a/src/pdf.zig
+++ /dev/null
@@ -1,1904 +0,0 @@
-//! Exception-safe MuPDF runtime wrapper. MuPDF's public API throws with
-//! setjmp/longjmp; pdf_bridge.c catches every such throw before control returns
-//! to Zig. This module is present in native builds unless `-Dmupdf=false`.
-const std = @import("std");
-const c_heap = @import("c_heap");
-
-const c = @import("pdf_c"); // src/pdf_bridge.h, translated by build.zig
-
-/// What MuPDF allocates from, itself and the libraries it bundles (they all
-/// allocate through its context): `start`'s allocator, through the shared C
-/// heap. MuPDF's allocator functions carry a user pointer the heap does not
-/// need.
-var bridge_allocator: std.mem.Allocator = undefined;
-const bridge_heap = c_heap.Heap(&bridge_allocator);
-var bridge_started = false;
-
-fn bridgeAlloc(_: ?*anyopaque, size: usize) callconv(.c) ?*anyopaque {
- return bridge_heap.malloc(size);
-}
-
-fn bridgeRealloc(_: ?*anyopaque, block: ?*anyopaque, size: usize) callconv(.c) ?*anyopaque {
- return bridge_heap.realloc(block, size);
-}
-
-fn bridgeFree(_: ?*anyopaque, block: ?*anyopaque) callconv(.c) void {
- bridge_heap.free(block);
-}
-
-/// Installs the allocator used by all subsequently opened PDF documents and
-/// by MuPDF itself. Call once before opening any documents.
-pub fn start(allocator: std.mem.Allocator) void {
- if (bridge_started) @panic("PDF allocator is already started");
- bridge_allocator = allocator;
- const descriptor = c.pardes_pdf_allocator{
- .user = null,
- .alloc = bridgeAlloc,
- .realloc = bridgeRealloc,
- .free = bridgeFree,
- };
- if (c.pardes_pdf_set_allocator(&descriptor) != c.PARDES_PDF_OK)
- @panic("cannot start PDF allocator while documents are live");
- bridge_started = true;
-}
-
-/// Restores libc and MuPDF's default allocator. Every Document must have been
-/// destroyed first so no allocation can outlive its allocator domain.
-pub fn stop() void {
- if (!bridge_started) @panic("PDF allocator is not started");
- if (c.pardes_pdf_set_allocator(null) != c.PARDES_PDF_OK)
- @panic("cannot stop PDF allocator while documents are live");
- bridge_started = false;
- bridge_allocator = undefined;
-}
-
-test "custom allocator owns a complete PDF document lifecycle" {
- start(std.testing.allocator);
- defer stop();
-
- var document = try openTestFile("docs/design.pdf");
- defer document.deinit();
- const raster = try document.render(std.testing.allocator, 0, .{}, &.{});
- defer std.testing.allocator.free(raster.rgba);
- try std.testing.expect(raster.rgba.len > 0);
-}
-
-test "two lanes render two pages of one document at once, each as the base renders it, and a cookie aborts" {
- const gpa = std.testing.allocator;
- var base = try openTestFile("docs/design.pdf");
- defer base.deinit();
- try std.testing.expect(base.pages >= 2);
- const Lane = struct {
- doc: Document,
- page: usize,
- out: ?Render = null,
- fn run(lane: *@This()) void {
- lane.doc.laneOpen() catch return;
- lane.out = lane.doc.render(std.testing.allocator, lane.page, .{}, &.{}) catch null;
- }
- };
- // Cloned on the base's thread; each lane's document opened on its own.
- var lanes = [2]Lane{ .{ .doc = try base.laneClone(), .page = 0 }, .{ .doc = try base.laneClone(), .page = 1 } };
- defer for (&lanes) |*lane| {
- if (lane.out) |r| gpa.free(r.rgba);
- lane.doc.deinit();
- };
- var threads: [2]std.Thread = undefined;
- for (&threads, &lanes) |*t, *lane| t.* = try std.Thread.spawn(.{}, Lane.run, .{lane});
- for (threads) |t| t.join();
- for (lanes) |lane| {
- const want = try base.render(gpa, lane.page, .{}, &.{});
- defer gpa.free(want.rgba);
- try std.testing.expect(std.mem.eql(u8, want.rgba, lane.out.?.rgba));
- }
- // An abort set before the run stops it at its first operator.
- var cookie = std.mem.zeroes(Cookie);
- cookie.abort = 1;
- lanes[0].doc.setCookie(&cookie);
- try std.testing.expectError(error.Aborted, lanes[0].doc.render(gpa, 1, .{}, &.{}));
- lanes[0].doc.setCookie(null);
-}
-
-/// One raster-quality request. `minimum_*` asks MuPDF for enough source pixels
-/// to avoid backend upscaling; `max_dimension` caps a raster row always, and
-/// the page's height unless that would draw it below `display_*`, the size
-/// the page is shown at (0: no floor). A page taller than that is never one
-/// allocation: its owner renders bands of it (`Raster.band`).
-pub const RenderRequest = struct {
- dpi: u16 = 144,
- minimum_width: u32 = 0,
- minimum_height: u32 = 0,
- max_dimension: u16 = 1600,
- display_width: u32 = 0,
- display_height: u32 = 0,
-
- pub fn eql(a: RenderRequest, b: RenderRequest) bool {
- return std.meta.eql(a, b);
- }
-};
-
-pub const absolute_max_render_dimension: u16 = 4096;
-/// The most one render buffer holds: a whole page, or one band of a page
-/// taller than this.
-pub const max_owned_raster_bytes: usize = @as(usize, absolute_max_render_dimension) *
- absolute_max_render_dimension * 4;
-/// Maximum native outline rows accepted atomically from one document.
-pub const max_outline_items: usize = c.PARDES_PDF_MAX_OUTLINE_ITEMS;
-
-/// Page-space geometry is normalized to the page bounds, not a render. It
-/// therefore survives DPI changes and can be shared by Kitty and SDL.
-pub const Cookie = c.pardes_pdf_cookie;
-pub const Point = c.pardes_pdf_point;
-pub const Quad = c.pardes_pdf_quad;
-
-pub const HighlightKind = enum(c_int) {
- custom = c.PARDES_PDF_HIGHLIGHT_CUSTOM,
- search = c.PARDES_PDF_HIGHLIGHT_SEARCH,
- selection = c.PARDES_PDF_HIGHLIGHT_SELECTION,
-};
-
-/// RGBA is straight (not premultiplied). `kind` remains available to the UI as
-/// semantic metadata; the caller-supplied RGBA is authoritative for rendering.
-pub const Highlight = extern struct {
- quad: Quad,
- rgba: [4]u8,
- kind: HighlightKind,
-
- pub fn init(quad: Quad, rgba: [4]u8, kind: HighlightKind) Highlight {
- return .{ .quad = quad, .rgba = rgba, .kind = kind };
- }
-};
-
-comptime {
- if (@sizeOf(Highlight) != @sizeOf(c.pardes_pdf_highlight) or
- @alignOf(Highlight) != @alignOf(c.pardes_pdf_highlight) or
- @offsetOf(Highlight, "quad") != @offsetOf(c.pardes_pdf_highlight, "quad") or
- @offsetOf(Highlight, "rgba") != @offsetOf(c.pardes_pdf_highlight, "rgba") or
- @offsetOf(Highlight, "kind") != @offsetOf(c.pardes_pdf_highlight, "kind"))
- @compileError("Highlight must match pardes_pdf_highlight's C ABI");
-}
-
-pub const Render = struct {
- rgba: []u8,
- width: usize,
- height: usize,
-};
-
-/// Pane-local PDF color treatment. The core owns when this changes; keeping
-/// the pixel transform here lets the renderer benchmark and any future PDF
-/// consumer exercise exactly the same fixed-point rule.
-pub const TintMode = enum {
- disabled,
- filtered,
- full,
-
- pub fn next(mode: TintMode) TintMode {
- return switch (mode) {
- .disabled => .filtered,
- .filtered => .full,
- .full => .disabled,
- };
- }
-};
-
-pub const TintColors = struct {
- background: [3]u8,
- foreground: [3]u8,
-};
-
-fn tintTargets(colors: TintColors) [256][3]u8 {
- var targets: [256][3]u8 = undefined;
- for (&targets, 0..) |*target, luminance| {
- inline for (0..3) |channel| {
- target[channel] = @intCast(
- (@as(u32, colors.foreground[channel]) * @as(u32, @intCast(255 - luminance)) +
- @as(u32, colors.background[channel]) * @as(u32, @intCast(luminance)) + 127) / 255,
- );
- }
- }
- return targets;
-}
-
-const tint_chroma_residuals: [511]i16 = table: {
- var values: [511]i16 = undefined;
- for (&values, 0..) |*value, index| {
- const residual: i16 = @as(i16, @intCast(index)) - 255;
- value.* = @divTrunc(residual * 3, 4);
- }
- break :table values;
-};
-
-const tint_clamped_sums: [638]u8 = table: {
- @setEvalBranchQuota(2000);
- var values: [638]u8 = undefined;
- for (&values, 0..) |*value, index| {
- const sum: i16 = @as(i16, @intCast(index)) - 191;
- value.* = @intCast(std.math.clamp(sum, 0, 255));
- }
- break :table values;
-};
-
-inline fn filteredTintChannel(target: u8, source: u8, residual_base: i16) u8 {
- const chroma = tint_chroma_residuals[@intCast(residual_base + source)];
- return tint_clamped_sums[@intCast(@as(i16, target) + chroma + 191)];
-}
-
-/// Rewrite packed straight-alpha RGBA in place without allocating.
-///
-/// Source luminance is Rec. 601's 77/150/29 integer approximation. `full`
-/// linearly maps source black to theme foreground and source white to theme
-/// background. `filtered` starts with that same themed target, then adds 3/4
-/// of each source channel's signed distance from source luminance, clamped to
-/// a byte. Thus grayscale is identical in both modes while filtered color
-/// retains the source hue/chroma. Alpha is never touched.
-pub fn tintRgba(rgba: []u8, mode: TintMode, colors: TintColors) !void {
- if (rgba.len % 4 != 0) return error.InvalidRgbaLength;
- if (mode == .disabled) return;
-
- const targets = tintTargets(colors);
- const pixels = std.mem.bytesAsSlice([4]u8, rgba);
- switch (mode) {
- .disabled => unreachable,
- .full => tintPixels(pixels, .full, &targets),
- .filtered => tintPixels(pixels, .filtered, &targets),
- }
-}
-
-/// The whole rule for ONE pixel, and the reason the memo below is exact: the
-/// transform reads nothing but this packed word, and alpha rides through
-/// untouched, so the word is a complete cache key.
-inline fn tintPixel(word: u32, comptime mode: TintMode, targets: *const [256][3]u8) u32 {
- var pixel: [4]u8 = @bitCast(word);
- const red = pixel[0];
- const green = pixel[1];
- const blue = pixel[2];
- const luminance: u8 = @intCast((@as(u32, red) * 77 +
- @as(u32, green) * 150 +
- @as(u32, blue) * 29 + 128) >> 8);
- const target = targets[luminance];
- switch (mode) {
- .disabled => comptime unreachable,
- .full => {
- pixel[0] = target[0];
- pixel[1] = target[1];
- pixel[2] = target[2];
- },
- .filtered => {
- const residual_base: i16 = 255 - @as(i16, luminance);
- pixel[0] = filteredTintChannel(target[0], red, residual_base);
- pixel[1] = filteredTintChannel(target[1], green, residual_base);
- pixel[2] = filteredTintChannel(target[2], blue, residual_base);
- },
- }
- return @bitCast(pixel);
-}
-
-/// Alpha-less packed tint for every grayscale level. See tintWord: this one
-/// table serves BOTH modes, which is why it takes no mode.
-fn grayTintTable(targets: *const [256][3]u8) [256]u32 {
- var table: [256]u32 = undefined;
- for (&table, targets) |*word, target|
- word.* = @bitCast([4]u8{ target[0], target[1], target[2], 0 });
- return table;
-}
-
-const tint_alpha_mask: u32 = @bitCast([4]u8{ 0, 0, 0, 0xff });
-
-/// One pixel, with the two shortcuts that make a full-page tint affordable.
-///
-/// Rec. 601's integer weights sum to exactly 256, so for r == g == b the
-/// luminance dot product is the channel value itself, and `filtered`'s chroma
-/// residual is then exactly zero — both modes collapse to the themed target
-/// for that level. A text page's raster is overwhelmingly grayscale, so this
-/// arm carries almost every pixel at one table load. Colour falls through to
-/// the general rule, unchanged.
-inline fn tintWord(
- word: u32,
- comptime mode: TintMode,
- targets: *const [256][3]u8,
- gray: *const [256]u32,
-) u32 {
- const pixel: [4]u8 = @bitCast(word);
- if (pixel[0] == pixel[1] and pixel[1] == pixel[2])
- return gray[pixel[0]] | (word & tint_alpha_mask);
- return tintPixel(word, mode, targets);
-}
-
-/// Pixels per run test. Sixteen is four SSE2 registers: one branch says
-/// "this whole span repeats the previous pixel", which is the shape of the
-/// paper margins and of any flat fill.
-const tint_run_pixels = 16;
-
-/// A rasterized page is mostly flat — paper, then runs of one ink value — and
-/// the transform reads nothing but the packed word, so a one-entry memo tested
-/// a span at a time turns those runs into one comparison and one store. That,
-/// plus the grayscale collapse above, is what lets a fling afford to tint a
-/// whole freshly rasterized page inside a single frame. Colour-photographic
-/// content pays the span comparison and nothing else; the arithmetic is
-/// byte-for-byte the scalar rule in every arm.
-fn tintPixels(pixels: [][4]u8, comptime mode: TintMode, targets: *const [256][3]u8) void {
- const gray = grayTintTable(targets);
- const Run = @Vector(tint_run_pixels, u32);
- var memo_key: u32 = undefined;
- var memo_value: u32 = undefined;
- var memo_valid = false;
- var at: usize = 0;
- while (at + tint_run_pixels <= pixels.len) : (at += tint_run_pixels) {
- const span = pixels[at..][0..tint_run_pixels];
- if (memo_valid) {
- const words: Run = @bitCast(span.*);
- if (@reduce(.And, words == @as(Run, @splat(memo_key)))) {
- span.* = @bitCast(@as(Run, @splat(memo_value)));
- continue;
- }
- }
- for (span) |*pixel| {
- memo_key = @bitCast(pixel.*);
- memo_value = tintWord(memo_key, mode, targets, &gray);
- pixel.* = @bitCast(memo_value);
- }
- memo_valid = true;
- }
- while (at < pixels.len) : (at += 1) {
- const pixel = &pixels[at];
- const word: u32 = @bitCast(pixel.*);
- pixel.* = @bitCast(tintWord(word, mode, targets, &gray));
- }
-}
-
-fn tintRgbaReference(rgba: []u8, mode: TintMode, colors: TintColors) !void {
- if (rgba.len % 4 != 0) return error.InvalidRgbaLength;
- if (mode == .disabled) return;
- var at: usize = 0;
- while (at < rgba.len) : (at += 4) {
- const source = rgba[at..][0..3];
- const luminance: u8 = @intCast((@as(u32, source[0]) * 77 +
- @as(u32, source[1]) * 150 +
- @as(u32, source[2]) * 29 + 128) >> 8);
- for (0..3) |channel| {
- const target: i32 = @intCast((@as(u32, colors.foreground[channel]) * (255 - @as(u32, luminance)) +
- @as(u32, colors.background[channel]) * @as(u32, luminance) + 127) / 255);
- const chroma = if (mode == .filtered)
- @divTrunc(
- (@as(i32, source[channel]) - @as(i32, luminance)) * 3,
- 4,
- )
- else
- 0;
- rgba[at + channel] = @intCast(std.math.clamp(target + chroma, 0, 255));
- }
- }
-}
-
-fn tintTestByte(state: *u64) u8 {
- state.* = state.* *% 6364136223846793005 +% 1442695040888963407;
- return @truncate(state.* >> 32);
-}
-
-test "PDF tint lookup tables are exact over every signed chroma residual" {
- for (tint_chroma_residuals, 0..) |actual, index| {
- const residual: i16 = @as(i16, @intCast(index)) - 255;
- try std.testing.expectEqual(@divTrunc(residual * 3, 4), actual);
- }
- for (tint_clamped_sums, 0..) |actual, index| {
- const sum: i16 = @as(i16, @intCast(index)) - 191;
- try std.testing.expectEqual(
- @as(u8, @intCast(std.math.clamp(sum, 0, 255))),
- actual,
- );
- }
-}
-
-test "optimized PDF tint matches scalar rule for every endpoint combination" {
- const modes = [_]TintMode{ .full, .filtered };
- for (0..8) |background_mask| {
- for (0..8) |foreground_mask| {
- const colors: TintColors = .{
- .background = .{
- if (background_mask & 1 == 0) 0 else 255,
- if (background_mask & 2 == 0) 0 else 255,
- if (background_mask & 4 == 0) 0 else 255,
- },
- .foreground = .{
- if (foreground_mask & 1 == 0) 0 else 255,
- if (foreground_mask & 2 == 0) 0 else 255,
- if (foreground_mask & 4 == 0) 0 else 255,
- },
- };
- var source: [8 * 2 * 4]u8 = undefined;
- var at: usize = 0;
- for (0..8) |source_mask| {
- for ([_]u8{ 0, 255 }) |alpha| {
- source[at..][0..4].* = .{
- if (source_mask & 1 == 0) 0 else 255,
- if (source_mask & 2 == 0) 0 else 255,
- if (source_mask & 4 == 0) 0 else 255,
- alpha,
- };
- at += 4;
- }
- }
- for (modes) |mode| {
- var expected = source;
- var actual = source;
- try tintRgbaReference(&expected, mode, colors);
- try tintRgba(&actual, mode, colors);
- try std.testing.expectEqualSlices(u8, &expected, &actual);
- }
- }
- }
-}
-
-test "optimized PDF tint matches scalar rule across deterministic broad samples" {
- const modes = [_]TintMode{ .full, .filtered };
- var state: u64 = 0x7061_7264_6573_5449;
- for (0..64) |_| {
- const colors: TintColors = .{
- .background = .{ tintTestByte(&state), tintTestByte(&state), tintTestByte(&state) },
- .foreground = .{ tintTestByte(&state), tintTestByte(&state), tintTestByte(&state) },
- };
- var source: [512 * 4]u8 = undefined;
- for (&source) |*byte| byte.* = tintTestByte(&state);
- for (modes) |mode| {
- var expected = source;
- var actual = source;
- try tintRgbaReference(&expected, mode, colors);
- try tintRgba(&actual, mode, colors);
- try std.testing.expectEqualSlices(u8, &expected, &actual);
- }
- }
-}
-
-// The memo, its tint_run_pixels span test, and the grayscale collapse only
-// engage on repeated or achromatic pixels, and the span loop leaves a tail on
-// any pixel count that is not a multiple of tint_run_pixels. None of that is
-// visible to the random corpus above, so drive flat runs, run boundaries, and
-// every remainder against the reference rule directly.
-test "optimized PDF tint matches scalar rule across runs, boundaries, and every tail" {
- const modes = [_]TintMode{ .full, .filtered };
- const colors: TintColors = .{
- .background = .{ 0x08, 0x12, 0x2a },
- .foreground = .{ 0xbd, 0xa4, 0x71 },
- };
- // Paper, ink, antialiased edge, saturated colour, and a transparent pixel
- // that shares its RGB with an opaque one — the memo key must include alpha
- // or that pair would tint from one cached word.
- const palette = [_][4]u8{
- .{ 0xff, 0xff, 0xff, 0xff },
- .{ 0x00, 0x00, 0x00, 0xff },
- .{ 0x7f, 0x80, 0x81, 0xff },
- .{ 0xff, 0x00, 0x00, 0xff },
- .{ 0xff, 0xff, 0xff, 0x00 },
- };
- var state: u64 = 0x7061_7264_6573_5254;
- var pixels: [37][4]u8 = undefined;
- for (0..96) |round| {
- // Alternate long flat runs against pixel-by-pixel churn so the block
- // fast path, the per-pixel memo, and the miss path all run.
- var run_left: usize = 0;
- var current: [4]u8 = palette[round % palette.len];
- for (&pixels) |*pixel| {
- if (run_left == 0) {
- run_left = 1 + (tintTestByte(&state) % 9);
- current = if (tintTestByte(&state) & 3 == 0)
- .{ tintTestByte(&state), tintTestByte(&state), tintTestByte(&state), tintTestByte(&state) }
- else
- palette[tintTestByte(&state) % palette.len];
- }
- run_left -= 1;
- pixel.* = current;
- }
- for (0..pixels.len + 1) |count| {
- const source = std.mem.sliceAsBytes(pixels[0..count]);
- for (modes) |mode| {
- var expected: [pixels.len * 4]u8 = undefined;
- var actual: [pixels.len * 4]u8 = undefined;
- @memcpy(expected[0..source.len], source);
- @memcpy(actual[0..source.len], source);
- try tintRgbaReference(expected[0..source.len], mode, colors);
- try tintRgba(actual[0..source.len], mode, colors);
- try std.testing.expectEqualSlices(u8, expected[0..source.len], actual[0..source.len]);
- }
- }
- }
-}
-
-test "PDF tint mode cycle is exact" {
- try std.testing.expectEqual(TintMode.filtered, TintMode.disabled.next());
- try std.testing.expectEqual(TintMode.full, TintMode.filtered.next());
- try std.testing.expectEqual(TintMode.disabled, TintMode.full.next());
-}
-
-test "full PDF tint maps black and white to dark and light theme endpoints" {
- const dark: TintColors = .{
- .background = .{ 0x12, 0x12, 0x12 },
- .foreground = .{ 0x94, 0x94, 0x94 },
- };
- var dark_pixels = [_]u8{ 0, 0, 0, 17, 255, 255, 255, 231 };
- try tintRgba(&dark_pixels, .full, dark);
- try std.testing.expectEqualSlices(u8, &.{ 0x94, 0x94, 0x94, 17 }, dark_pixels[0..4]);
- try std.testing.expectEqualSlices(u8, &.{ 0x12, 0x12, 0x12, 231 }, dark_pixels[4..8]);
-
- const light: TintColors = .{
- .background = .{ 0xea, 0xff, 0xff },
- .foreground = .{ 0x00, 0x00, 0x00 },
- };
- var light_pixels = [_]u8{ 0, 0, 0, 0, 255, 255, 255, 255 };
- try tintRgba(&light_pixels, .full, light);
- try std.testing.expectEqualSlices(u8, &.{ 0x00, 0x00, 0x00, 0 }, light_pixels[0..4]);
- try std.testing.expectEqualSlices(u8, &.{ 0xea, 0xff, 0xff, 255 }, light_pixels[4..8]);
-}
-
-test "filtered PDF tint preserves fixed-point source chroma and alpha" {
- const colors: TintColors = .{
- .background = .{ 20, 40, 60 },
- .foreground = .{ 220, 200, 180 },
- };
- var full = [_]u8{ 255, 0, 0, 37 };
- var filtered = full;
- try tintRgba(&full, .full, colors);
- try tintRgba(&filtered, .filtered, colors);
- // Red has integer luma 77. The themed target is {160,152,144}; adding
- // 3/4 of its {178,-77,-77} chroma residual yields this clamped result.
- try std.testing.expectEqualSlices(u8, &.{ 160, 152, 144, 37 }, &full);
- try std.testing.expectEqualSlices(u8, &.{ 255, 95, 87, 37 }, &filtered);
-
- var gray_full = [_]u8{ 128, 128, 128, 91 };
- var gray_filtered = gray_full;
- try tintRgba(&gray_full, .full, colors);
- try tintRgba(&gray_filtered, .filtered, colors);
- try std.testing.expectEqualSlices(u8, &gray_full, &gray_filtered);
- try std.testing.expectEqual(@as(u8, 91), gray_filtered[3]);
-}
-
-test "disabled PDF tint is byte-identical and malformed RGBA is rejected unchanged" {
- const colors: TintColors = .{
- .background = .{ 1, 2, 3 },
- .foreground = .{ 4, 5, 6 },
- };
- var pixels = [_]u8{ 9, 80, 170, 0, 250, 33, 71, 199 };
- const before = pixels;
- try tintRgba(&pixels, .disabled, colors);
- try std.testing.expectEqualSlices(u8, &before, &pixels);
-
- var malformed = [_]u8{ 11, 22, 33 };
- const malformed_before = malformed;
- try std.testing.expectError(error.InvalidRgbaLength, tintRgba(&malformed, .full, colors));
- try std.testing.expectEqualSlices(u8, &malformed_before, &malformed);
-}
-
-pub const PageSize = struct {
- width: f32,
- height: f32,
-};
-
-pub const SearchQuad = struct {
- quad: Quad,
- /// Zero-based logical hit. One hit may have several oriented quads.
- hit: usize,
-};
-
-pub const SearchResults = struct {
- quads: []SearchQuad,
- hit_count: usize,
-
- pub fn deinit(results: *SearchResults, gpa: std.mem.Allocator) void {
- gpa.free(results.quads);
- results.* = undefined;
- }
-};
-
-pub const Selection = struct {
- quads: []Quad,
- /// Word-snapped endpoints; pass these to `Document.copySelection`.
- start: Point,
- end: Point,
-
- /// Hit-test without flattening oriented text quads to axis-aligned boxes.
- /// The bridge delegates to MuPDF's geometry predicate and cannot throw.
- pub fn contains(selection: *const Selection, point: Point) bool {
- if (!validPoint(point)) return false;
- for (selection.quads) |quad| {
- if (c.pardes_pdf_point_inside_quad(point, quad) != 0) return true;
- }
- return false;
- }
-
- pub fn deinit(selection: *Selection, gpa: std.mem.Allocator) void {
- gpa.free(selection.quads);
- selection.* = undefined;
- }
-};
-
-pub const OutlineInternalDestination = struct {
- /// Zero-based document page number.
- page: usize,
- /// MuPDF page-space viewing coordinates; null when the PDF destination
- /// omits that axis (for example, a Fit destination omits both).
- x: ?f32,
- y: ?f32,
-};
-
-pub const OutlineDestination = union(enum) {
- none,
- internal: OutlineInternalDestination,
- external: []const u8,
-};
-
-pub const Link = struct {
- page: usize,
- quad: Quad,
- /// Owned independently of the document's current-page cache. External
- /// destination slices point into this same allocation.
- uri: []u8,
- destination: OutlineDestination,
-
- pub fn deinit(link: *Link, gpa: std.mem.Allocator) void {
- gpa.free(link.uri);
- link.* = undefined;
- }
-};
-
-pub const OutlineEntry = struct {
- /// Zero for a root row; rows are in stable pre-order depth-first order.
- depth: u8,
- /// Null preserves a missing /Title; a present empty title is "".
- title: ?[]const u8,
- destination: OutlineDestination,
-};
-
-/// All title and external-URI slices point into `bytes`. This fixed two-allocation
-/// representation avoids one allocation per row while keeping deinit deterministic.
-pub const Outline = struct {
- entries: []OutlineEntry,
- bytes: []u8,
-
- pub fn deinit(outline: *Outline, gpa: std.mem.Allocator) void {
- gpa.free(outline.entries);
- gpa.free(outline.bytes);
- outline.* = undefined;
- }
-};
-
-test "oriented selection containment delegates to MuPDF quad geometry" {
- const quads = [_]Quad{.{
- .ul = .{ .x = 0.10, .y = 0.10 },
- .ur = .{ .x = 0.70, .y = 0.20 },
- .ll = .{ .x = 0.20, .y = 0.80 },
- .lr = .{ .x = 0.80, .y = 0.90 },
- }};
- const selection = Selection{
- .quads = @constCast(quads[0..]),
- .start = quads[0].ul,
- .end = quads[0].lr,
- };
- try std.testing.expect(selection.contains(.{ .x = 0.45, .y = 0.50 }));
- try std.testing.expect(!selection.contains(.{ .x = 0.05, .y = 0.85 }));
- try std.testing.expect(!selection.contains(.{ .x = -0.1, .y = 0.5 }));
-}
-
-pub const Document = struct {
- /// None in a document loaded from a dump until its PDF is opened again
- /// (pdf_view.reopen).
- handle: ?*c.pardes_pdf_document = null,
- pages: usize,
-
- /// The open document is MuPDF's, made from the file's bytes (src/walk.zig).
- pub const replica = .{ .derived = .{"handle"} };
-
- pub fn deinit(document: *Document) void {
- c.pardes_pdf_close(document.handle);
- document.* = undefined;
- }
-
- pub fn openBytes(bytes: []const u8) !Document {
- var page_count: c_int = 0;
- const handle = c.pardes_pdf_open_memory(bytes.ptr, bytes.len, &page_count) orelse
- return error.OpenFailed;
- return .{ .handle = handle, .pages = @intCast(page_count) };
- }
-
- /// A render lane of this document (`pardes_pdf_lane_clone`): its own
- /// cloned context, its own document opened (`laneOpen`) on the thread
- /// that renders with it. Deinit every lane before `base`.
- pub fn laneClone(base: *Document) !Document {
- const handle = c.pardes_pdf_lane_clone(base.handle) orelse return error.OpenFailed;
- return .{ .handle = handle, .pages = base.pages };
- }
-
- pub fn laneOpen(lane: *Document) !void {
- if (c.pardes_pdf_lane_open(lane.handle) != c.PARDES_PDF_OK) return error.OpenFailed;
- }
-
- /// The cookie this document's renders run under until set again: set
- /// its `abort` from any thread and a render stops at its next operator
- /// (`error.Aborted`).
- pub fn setCookie(document: *Document, cookie: ?*Cookie) void {
- c.pardes_pdf_set_cookie(document.handle, cookie);
- }
-
- /// Link annotations are loaded only for the pointed page, separately from
- /// text/raster work. Returned URIs survive cache eviction and page changes.
- pub fn linkAt(document: *Document, gpa: std.mem.Allocator, page: usize, point: Point) !?Link {
- const page_number = try document.checkedPage(page);
- if (!validPoint(point)) return null;
- var raw: c.pardes_pdf_link = std.mem.zeroes(c.pardes_pdf_link);
- if (c.pardes_pdf_link_at(document.handle, page_number, point, &raw) != c.PARDES_PDF_OK)
- return error.LinkFailed;
- if (raw.uri == null or raw.uri_len == 0) return null;
- if (raw.uri_len > c.PARDES_PDF_MAX_LINK_URI_BYTES or !validQuad(raw.quad)) return error.BadLink;
- const borrowed: [*]const u8 = @ptrCast(raw.uri);
- const text = borrowed[0..raw.uri_len];
- if (!std.unicode.utf8ValidateSlice(text) or std.mem.trim(u8, text, " ").len == 0 or
- std.ascii.eqlIgnoreCase(text, "file://")) return null;
- for (text) |byte| if (byte < ' ') return null;
- const uri = try gpa.dupe(u8, text);
- errdefer gpa.free(uri);
- const destination: OutlineDestination = switch (raw.destination_kind) {
- c.PARDES_PDF_OUTLINE_DESTINATION_INTERNAL => blk: {
- if (raw.page < 0 or @as(usize, @intCast(raw.page)) >= document.pages or
- raw.has_x > 1 or raw.has_y > 1 or
- (raw.has_x != 0 and !std.math.isFinite(raw.x)) or
- (raw.has_y != 0 and !std.math.isFinite(raw.y))) return error.BadLink;
- break :blk .{ .internal = .{
- .page = @intCast(raw.page),
- .x = if (raw.has_x != 0) raw.x else null,
- .y = if (raw.has_y != 0) raw.y else null,
- } };
- },
- c.PARDES_PDF_OUTLINE_DESTINATION_EXTERNAL => .{ .external = uri },
- else => return error.BadLink,
- };
- return .{ .page = page, .quad = raw.quad, .uri = uri, .destination = destination };
- }
-
- pub fn copyRectangle(document: *Document, gpa: std.mem.Allocator, page: usize, quad: Quad) ![]u8 {
- const page_number = try document.checkedPage(page);
- if (!validQuad(quad)) return error.InvalidPoint;
- var text: c.pardes_pdf_owned_text = std.mem.zeroes(c.pardes_pdf_owned_text);
- if (c.pardes_pdf_copy_rectangle(document.handle, page_number, quad, &text) != c.PARDES_PDF_OK)
- return error.SelectionFailed;
- defer c.pardes_pdf_drop_owned_text(document.handle, text.handle);
- if (text.len == 0) return &.{};
- if (text.data == null) return error.BadText;
- const source: [*]const u8 = @ptrCast(text.data);
- return gpa.dupe(u8, source[0..text.len]);
- }
-
- /// Load and flatten the PDF-native outline/bookmarks. MuPDF's temporary
- /// tree and the bridge's flat view are both dropped before this returns.
- pub fn outline(
- document: *Document,
- gpa: std.mem.Allocator,
- ) !Outline {
- var raw: c.pardes_pdf_outline_result =
- std.mem.zeroes(c.pardes_pdf_outline_result);
- const status = c.pardes_pdf_load_outline(document.handle, &raw);
- if (status == c.PARDES_PDF_LIMIT_EXCEEDED)
- return error.OutlineLimitExceeded;
- if (status != c.PARDES_PDF_OK)
- return error.OutlineFailed;
- defer c.pardes_pdf_drop_outline_result(document.handle, raw.handle);
-
- if (raw.item_count > c.PARDES_PDF_MAX_OUTLINE_ITEMS or
- raw.bytes_len > c.PARDES_PDF_MAX_OUTLINE_BYTES or
- (raw.item_count != 0 and raw.items == null) or
- (raw.bytes_len != 0 and raw.bytes == null))
- return error.BadOutline;
-
- const bytes = try gpa.alloc(u8, raw.bytes_len);
- errdefer gpa.free(bytes);
- if (raw.bytes_len != 0) {
- const source: [*]const u8 = @ptrCast(raw.bytes);
- @memcpy(bytes, source[0..raw.bytes_len]);
- }
-
- const entries = try gpa.alloc(OutlineEntry, raw.item_count);
- errdefer gpa.free(entries);
- if (raw.item_count != 0) {
- const source: [*]const c.pardes_pdf_outline_item =
- @ptrCast(raw.items);
- var previous_depth: u8 = 0;
- for (entries, source[0..raw.item_count], 0..) |*entry, item, index| {
- if (item.depth >= c.PARDES_PDF_MAX_OUTLINE_DEPTH or
- item.depth > std.math.maxInt(u8) or
- item.title_present > 1 or item.has_x > 1 or
- item.has_y > 1)
- return error.BadOutline;
- const depth: u8 = @intCast(item.depth);
- if ((index == 0 and depth != 0) or
- (index != 0 and depth > previous_depth + 1))
- return error.BadOutline;
- previous_depth = depth;
-
- const title = if (item.title_present != 0) title: {
- const value = try outlineBytes(bytes, item.title_offset, item.title_len);
- if (!std.unicode.utf8ValidateSlice(value))
- return error.BadOutline;
- break :title value;
- } else title: {
- if (item.title_offset != 0 or item.title_len != 0)
- return error.BadOutline;
- break :title null;
- };
-
- const destination: OutlineDestination = switch (item.destination_kind) {
- c.PARDES_PDF_OUTLINE_DESTINATION_NONE => .none,
- c.PARDES_PDF_OUTLINE_DESTINATION_INTERNAL => internal: {
- if (item.page < 0 or
- @as(usize, @intCast(item.page)) >= document.pages or
- (item.has_x != 0 and !std.math.isFinite(item.x)) or
- (item.has_y != 0 and !std.math.isFinite(item.y)))
- return error.BadOutline;
- break :internal .{ .internal = .{
- .page = @intCast(item.page),
- .x = if (item.has_x != 0) item.x else null,
- .y = if (item.has_y != 0) item.y else null,
- } };
- },
- c.PARDES_PDF_OUTLINE_DESTINATION_EXTERNAL => external: {
- const uri = try outlineBytes(bytes, item.uri_offset, item.uri_len);
- if (!std.unicode.utf8ValidateSlice(uri))
- return error.BadOutline;
- break :external .{ .external = uri };
- },
- else => return error.BadOutline,
- };
- entry.* = .{ .depth = depth, .title = title, .destination = destination };
- }
- }
- return .{ .entries = entries, .bytes = bytes };
- }
-
- /// Return crop/rotation-aware page dimensions without allocating pixels.
- pub fn pageSize(document: *Document, page: usize) !PageSize {
- const page_number = try document.checkedPage(page);
- var size: c.pardes_pdf_page_size = std.mem.zeroes(c.pardes_pdf_page_size);
- if (c.pardes_pdf_get_page_size(document.handle, page_number, &size) != c.PARDES_PDF_OK or
- !std.math.isFinite(size.width) or !std.math.isFinite(size.height) or
- size.width <= 0 or size.height <= 0)
- return error.BadPageSize;
- return .{ .width = size.width, .height = size.height };
- }
-
- /// Render one zero-based page whole into allocator-owned packed RGBA,
- /// baking `highlights` in: the tests' and benches' render. The view
- /// renders bands into buffers it owns (`renderIntoAtWithPaper`).
- pub fn render(
- document: *Document,
- gpa: std.mem.Allocator,
- page: usize,
- request: RenderRequest,
- highlights: []const Highlight,
- ) !Render {
- const raster = try document.measureRenderAt(page, request);
- if (raster.len > max_owned_raster_bytes) return error.PixmapTooLarge;
- const rgba = try gpa.alloc(u8, raster.len);
- errdefer gpa.free(rgba);
- try document.renderIntoAtWithPaper(page, request, raster, raster.wholePage(), highlights, rgba, false);
- return .{ .rgba = rgba, .width = raster.width, .height = raster.height };
- }
-
- /// Exactly the raster this request will produce, without producing it.
- /// Split out of the render so a caller holding a retired buffer of the
- /// same length can hand it straight back instead of making the allocator
- /// fetch (and later return) fresh pages for every page it flies past.
- pub fn measureRenderAt(
- document: *Document,
- page: usize,
- request: RenderRequest,
- ) !Raster {
- const bounded = try boundedRequest(document, page, request);
- var raw_layout: c.pardes_pdf_raster_layout = std.mem.zeroes(c.pardes_pdf_raster_layout);
- if (c.pardes_pdf_measure_render(
- document.handle,
- @intCast(page),
- &bounded,
- &raw_layout,
- ) != c.PARDES_PDF_OK) return error.RenderFailed;
- // The page's shape, not an allocation: a page taller than
- // `max_owned_raster_bytes` allows is rendered a band at a time.
- return checkedRasterLayout(raw_layout);
- }
-
- /// Rasterize `band` of a page into `rgba`, which MUST be exactly
- /// `band.len` bytes for a `band` taken from the same `measureRenderAt`
- /// shape and request. On any failure the buffer's contents are unspecified
- /// and it still belongs to the caller. `transparent_paper` preserves the
- /// PDF's content coverage when the host paints paper separately.
- pub fn renderIntoAtWithPaper(
- document: *Document,
- page: usize,
- request: RenderRequest,
- raster: Raster,
- band: Raster.Band,
- highlights: []const Highlight,
- rgba: []u8,
- transparent_paper: bool,
- ) !void {
- if (rgba.len != band.len) return error.BadPixmap;
- if (band.height == 0 or band.y + band.height > raster.height)
- return error.BadPixmap;
- if (band.len > max_owned_raster_bytes) return error.PixmapTooLarge;
- const bounded = try boundedRequest(document, page, request);
- if (highlights.len > c.PARDES_PDF_MAX_RESULT_QUADS) return error.RenderFailed;
- const highlight_ptr: ?[*]const c.pardes_pdf_highlight =
- if (highlights.len == 0) null else @ptrCast(highlights.ptr);
- const status = c.pardes_pdf_render_into(
- document.handle,
- @intCast(page),
- &bounded,
- highlight_ptr,
- highlights.len,
- rgba.ptr,
- rgba.len,
- @intCast(raster.width),
- @intCast(raster.height),
- @intCast(raster.stride),
- @intCast(band.y),
- @intCast(band.height),
- @intFromBool(transparent_paper),
- );
- if (status == c.PARDES_PDF_ABORTED) return error.Aborted;
- if (status != c.PARDES_PDF_OK) return error.RenderFailed;
- }
-
- /// Only the highlight pass of `renderIntoAtWithPaper`, over `rgba`, which
- /// holds `band` of this page as that render left it before highlighting
- /// (opaque paper). Rendering with highlights equals rendering without and
- /// then this, row for row: the render draws highlights over the finished
- /// page, and so does this.
- pub fn paintHighlightsAt(
- document: *Document,
- page: usize,
- request: RenderRequest,
- raster: Raster,
- band: Raster.Band,
- highlights: []const Highlight,
- rgba: []u8,
- ) !void {
- if (rgba.len != band.len) return error.BadPixmap;
- if (band.height == 0 or band.y + band.height > raster.height)
- return error.BadPixmap;
- const bounded = try boundedRequest(document, page, request);
- if (highlights.len > c.PARDES_PDF_MAX_RESULT_QUADS) return error.RenderFailed;
- if (c.pardes_pdf_paint_highlights(
- document.handle,
- @intCast(page),
- &bounded,
- if (highlights.len == 0) null else @ptrCast(highlights.ptr),
- highlights.len,
- rgba.ptr,
- rgba.len,
- @intCast(raster.width),
- @intCast(raster.height),
- @intCast(raster.stride),
- @intCast(band.y),
- @intCast(band.height),
- ) != c.PARDES_PDF_OK) return error.RenderFailed;
- }
-
- pub const Rows = struct { start: usize, end: usize };
-
- /// The rows of `request`'s raster that painting `highlights` can touch,
- /// by the transform the render itself uses (rotation included). Empty
- /// when nothing would paint.
- pub fn highlightRows(
- document: *Document,
- page: usize,
- request: RenderRequest,
- highlights: []const Highlight,
- ) !Rows {
- const bounded = try boundedRequest(document, page, request);
- var row_start: c_int = 0;
- var row_end: c_int = 0;
- if (c.pardes_pdf_highlight_rows(
- document.handle,
- @intCast(page),
- &bounded,
- if (highlights.len == 0) null else @ptrCast(highlights.ptr),
- highlights.len,
- &row_start,
- &row_end,
- ) != c.PARDES_PDF_OK) return error.RenderFailed;
- return .{ .start = @intCast(row_start), .end = @intCast(row_end) };
- }
-
- /// `request` as the bridge takes it, refused when the page or a size is
- /// out of range.
- fn boundedRequest(
- document: *Document,
- page: usize,
- request: RenderRequest,
- ) !c.pardes_pdf_request {
- _ = try document.checkedPage(page);
- if (request.dpi == 0 or request.max_dimension == 0 or
- request.max_dimension > absolute_max_render_dimension)
- return error.InvalidRenderRequest;
- return .{
- .dpi = request.dpi,
- .minimum_width = clampInt(request.minimum_width),
- .minimum_height = clampInt(request.minimum_height),
- .max_dimension = request.max_dimension,
- .display_width = clampInt(request.display_width),
- .display_height = clampInt(request.display_height),
- };
- }
-
- fn clampInt(value: u32) c_int {
- return @intCast(@min(value, @as(u32, @intCast(std.math.maxInt(c_int)))));
- }
-
- /// Plain UTF-8-ish text projection for one zero-based page. MuPDF owns the
- /// temporary buffer; callers receive an allocator-owned copy.
- pub fn pageText(document: *Document, gpa: std.mem.Allocator, page: usize) ![]u8 {
- const page_number = try document.checkedPage(page);
- var text: c.pardes_pdf_text = std.mem.zeroes(c.pardes_pdf_text);
- if (c.pardes_pdf_page_text(document.handle, page_number, &text) != 0)
- return error.TextFailed;
- defer c.pardes_pdf_drop_text(document.handle, text.handle);
- if (text.len == 0) return gpa.dupe(u8, "");
- if (text.data == null) return error.BadText;
- const bytes: [*]const u8 = @ptrCast(text.data);
- return gpa.dupe(u8, bytes[0..text.len]);
- }
-
- /// Case-insensitive single-page search. MuPDF's iterative search owns a
- /// retained reference to the cached structured-text page while running;
- /// this wrapper copies every borrowed oriented quad before dropping it.
- /// The C bridge doubles capacity up to 65,536 aggregate quads and returns
- /// TooManyResults atomically rather than silently truncating beyond it.
- pub fn search(
- document: *Document,
- gpa: std.mem.Allocator,
- page: usize,
- needle: []const u8,
- ) !SearchResults {
- const page_number = try document.checkedPage(page);
- if (std.mem.indexOfScalar(u8, needle, 0) != null)
- return error.InvalidNeedle;
- const needle_z = try gpa.dupeSentinel(u8, needle, 0);
- defer gpa.free(needle_z);
-
- var found: c.pardes_pdf_search_result =
- std.mem.zeroes(c.pardes_pdf_search_result);
- const status = c.pardes_pdf_search_page(document.handle, page_number, needle_z.ptr, &found);
- if (status == c.PARDES_PDF_LIMIT_EXCEEDED)
- return error.TooManyResults;
- if (status != c.PARDES_PDF_OK)
- return error.SearchFailed;
- defer c.pardes_pdf_drop_search_result(document.handle, found.handle);
-
- if (found.quad_count != 0 and found.quads == null)
- return error.BadGeometry;
- const quads = try gpa.alloc(SearchQuad, found.quad_count);
- errdefer gpa.free(quads);
- if (found.quad_count != 0) {
- const source: [*]const c.pardes_pdf_search_quad = @ptrCast(found.quads);
- for (quads, source[0..found.quad_count]) |*dest, item| {
- if (item.hit >= found.hit_count or !validQuad(item.quad))
- return error.BadGeometry;
- dest.* = .{ .quad = item.quad, .hit = item.hit };
- }
- }
- return .{ .quads = quads, .hit_count = found.hit_count };
- }
-
- /// Word-snap two normalized page points and return allocator-owned,
- /// orientation-preserving highlight geometry.
- pub fn select(
- document: *Document,
- gpa: std.mem.Allocator,
- page: usize,
- selection_start: Point,
- selection_end: Point,
- ) !Selection {
- const page_number = try document.checkedPage(page);
- if (!validPoint(selection_start) or !validPoint(selection_end))
- return error.InvalidPoint;
-
- var selected: c.pardes_pdf_selection =
- std.mem.zeroes(c.pardes_pdf_selection);
- const status = c.pardes_pdf_select(
- document.handle,
- page_number,
- selection_start,
- selection_end,
- &selected,
- );
- if (status == c.PARDES_PDF_LIMIT_EXCEEDED)
- return error.TooManyResults;
- if (status != c.PARDES_PDF_OK)
- return error.SelectionFailed;
- defer c.pardes_pdf_drop_selection(document.handle, selected.handle);
-
- if (selected.quad_count != 0 and selected.quads == null)
- return error.BadGeometry;
- if (!validPoint(selected.start) or !validPoint(selected.end))
- return error.BadGeometry;
- const quads = try gpa.alloc(Quad, selected.quad_count);
- errdefer gpa.free(quads);
- if (selected.quad_count != 0) {
- const source: [*]const Quad = @ptrCast(selected.quads);
- for (quads, source[0..selected.quad_count]) |*dest, item| {
- if (!validQuad(item)) return error.BadGeometry;
- dest.* = item;
- }
- }
- return .{
- .quads = quads,
- .start = selected.start,
- .end = selected.end,
- };
- }
-
- /// Copy UTF-8 text between normalized page points. For word selection,
- /// pass the snapped endpoints returned by `select`. MuPDF's temporary
- /// fz_malloc string is always freed after making the allocator-owned copy.
- pub fn copySelection(
- document: *Document,
- gpa: std.mem.Allocator,
- page: usize,
- selection_start: Point,
- selection_end: Point,
- ) ![]u8 {
- const page_number = try document.checkedPage(page);
- if (!validPoint(selection_start) or !validPoint(selection_end))
- return error.InvalidPoint;
-
- var text: c.pardes_pdf_owned_text =
- std.mem.zeroes(c.pardes_pdf_owned_text);
- if (c.pardes_pdf_copy_selection(
- document.handle,
- page_number,
- selection_start,
- selection_end,
- &text,
- ) != c.PARDES_PDF_OK) return error.TextFailed;
- defer c.pardes_pdf_drop_owned_text(document.handle, text.handle);
- if (text.len == 0) return gpa.dupe(u8, "");
- if (text.data == null) return error.BadText;
- const bytes: [*]const u8 = @ptrCast(text.data);
- return gpa.dupe(u8, bytes[0..text.len]);
- }
-
- fn checkedPage(document: *const Document, page: usize) !c_int {
- if (page >= document.pages or page > std.math.maxInt(c_int))
- return error.PageOutOfRange;
- return @intCast(page);
- }
-};
-
-fn outlineBytes(bytes: []const u8, offset: usize, len: usize) ![]const u8 {
- if (offset > bytes.len or len > bytes.len - offset)
- return error.BadOutline;
- return bytes[offset .. offset + len];
-}
-
-fn validPoint(point: Point) bool {
- return std.math.isFinite(point.x) and std.math.isFinite(point.y) and
- point.x >= 0 and point.x <= 1 and point.y >= 0 and point.y <= 1;
-}
-
-fn validQuad(quad: Quad) bool {
- return validPoint(quad.ul) and validPoint(quad.ur) and
- validPoint(quad.ll) and validPoint(quad.lr);
-}
-
-/// The exact shape of the raster a render request produces. `len` is the
-/// packed RGBA byte count a FULL-page `renderIntoAtWithPaper` demands, so a caller can
-/// match a retired buffer against it before deciding to allocate.
-pub const Raster = struct {
- width: usize,
- height: usize,
- stride: usize,
- len: usize,
-
- /// The rows a reader can actually see are usually a fraction of a page:
- /// flinging through a manual, a page is on screen for one frame showing a
- /// couple of hundred of its twelve hundred rows. `Band` is that fraction,
- /// and rendering one is the same rendering clipped — see the bridge's
- /// comment and the test that proves the rows are identical.
- pub const Band = struct {
- y: usize,
- height: usize,
- /// bytes of a `y`/`height` band at this raster's stride
- len: usize,
- };
-
- /// The whole page as a band, which is what a reader at rest gets.
- pub fn wholePage(raster: Raster) Band {
- return .{ .y = 0, .height = raster.height, .len = raster.len };
- }
-
- /// Clamp a wanted row range to the page and return it as a band. A range
- /// that misses the page entirely comes back as its nearest single row
- /// rather than as an error: the caller is describing a viewport, and a
- /// viewport that has just left a page is not a malformed request.
- pub fn band(raster: Raster, first_row: usize, rows: usize) Band {
- const y = @min(first_row, raster.height - 1);
- const height = @min(@max(rows, 1), raster.height - y);
- return .{ .y = y, .height = height, .len = raster.stride * height };
- }
-};
-
-fn checkedRasterLayout(raw: c.pardes_pdf_raster_layout) !Raster {
- if (raw.width < 1 or raw.height < 1 or raw.stride < 1)
- return error.BadPixmap;
- const width: usize = @intCast(raw.width);
- const height: usize = @intCast(raw.height);
- const stride: usize = @intCast(raw.stride);
- const expected_stride = std.math.mul(usize, width, 4) catch
- return error.BadPixmap;
- if (stride != expected_stride) return error.BadPixmap;
- const len = std.math.mul(usize, stride, height) catch
- return error.BadPixmap;
- if (raw.samples_len != len) return error.BadPixmap;
- return .{ .width = width, .height = height, .stride = stride, .len = len };
-}
-
-fn expectOpaque(rgba: []const u8) !void {
- if (rgba.len % 4 != 0) return error.BadPixmap;
- var alpha: usize = 3;
- while (alpha < rgba.len) : (alpha += 4)
- try std.testing.expectEqual(@as(u8, 0xff), rgba[alpha]);
-}
-
-/// TEST-ONLY: a PDF file read whole and opened from memory, as the view
-/// opens one.
-fn openTestFile(path: []const u8) !Document {
- const bytes = try std.Io.Dir.cwd().readFileAlloc(std.testing.io, path, std.testing.allocator, .unlimited);
- defer std.testing.allocator.free(bytes);
- return Document.openBytes(bytes);
-}
-
-/// TEST-ONLY (here and in the core's tests, which run in the repository's
-/// root): one of test/pdf-fixtures' PDFs, whole. `outline.pdf`, an outline
-/// of every kind (a branch with neither title nor destination over a UTF-16
-/// child, an empty title, an external link); `offset-rotated.pdf`, one page
-/// with an offset CropBox and /Rotate 90 and no outline; `links.pdf`,
-/// external, internal, same-URI and link-only annotations; `tall.pdf`, one
-/// `tall_test_page` labelled every 100 pt; `rotated-link*.pdf`, a link on
-/// the rotated page by URI, empty URI, JavaScript, a missing destination.
-pub fn testFixture(gpa: std.mem.Allocator, comptime name: []const u8) ![]u8 {
- return std.Io.Dir.cwd().readFileAlloc(std.testing.io, "test/pdf-fixtures/" ++ name, gpa, .unlimited);
-}
-
-fn allocateGeneratedPdf(
- gpa: std.mem.Allocator,
- offsets: []usize,
- context: anytype,
- comptime emit: anytype,
-) ![]u8 {
- @memset(offsets, 0);
- var bytes: std.Io.Writer.Allocating = .init(gpa);
- defer bytes.deinit();
- try emit(&bytes.writer, offsets, context);
- return bytes.toOwnedSlice();
-}
-
-fn beginPdfObject(bytes: *std.Io.Writer, offsets: []usize, number: usize) !void {
- offsets[number] = bytes.end;
- try bytes.print("{d} 0 obj\n", .{number});
-}
-
-fn finishGeneratedPdf(bytes: *std.Io.Writer, offsets: []const usize) !void {
- const xref = bytes.end;
- try bytes.print("xref\n0 {d}\n0000000000 65535 f \n", .{offsets.len});
- for (offsets[1..]) |offset|
- try bytes.print("{d:0>10} 00000 n \n", .{offset});
- try bytes.print(
- "trailer\n<< /Size {d} /Root 1 0 R >>\nstartxref\n{d}\n%%EOF\n",
- .{ offsets.len, xref },
- );
-}
-
-/// The tall test page: 600 x 9000 pt, fifteen A4 pages' height on one.
-pub const tall_test_page: PageSize = .{ .width = 600, .height = 9000 };
-
-test "a tall page rasterizes at the size it is shown, however many max_dimensions tall" {
- var document = try openTestFile("test/pdf-fixtures/tall.pdf");
- defer document.deinit();
- const size = try document.pageSize(0);
- try std.testing.expectEqual(tall_test_page.width, size.width);
- try std.testing.expectEqual(tall_test_page.height, size.height);
-
- // Shown 960 px wide (fit width): 960 px a row, 14400 rows, though that is
- // far past max_dimension. The old clamp of the longest side made this
- // 273 x 4096, drawn 3.5 times too large.
- const shown: RenderRequest = .{ .dpi = 192, .minimum_width = 960, .minimum_height = 600, .max_dimension = 4096, .display_width = 960 };
- const tall = try document.measureRenderAt(0, shown);
- try std.testing.expectEqual(@as(usize, 960), tall.width);
- try std.testing.expectEqual(@as(usize, 14400), tall.height);
- // Kitty's 96 dpi, as any page has it, not 1200 rows' worth.
- const kitty = try document.measureRenderAt(0, .{ .dpi = 96, .max_dimension = 1200, .display_width = 944 });
- try std.testing.expectEqual(@as(usize, 800), kitty.width);
- try std.testing.expectEqual(@as(usize, 12000), kitty.height);
- // The dpi never takes it past what is shown: that would be bands of
- // pixels nobody sees.
- const small = try document.measureRenderAt(0, .{ .dpi = 192, .max_dimension = 4096, .display_width = 300 });
- try std.testing.expectEqual(@as(usize, 300), small.width);
- // Shown whole (fit height), the height cap holds: the page is 600 px
- // tall on screen and 4096 rows is already more.
- const whole = try document.measureRenderAt(0, .{ .dpi = 192, .minimum_width = 960, .minimum_height = 600, .max_dimension = 4096, .display_height = 600 });
- try std.testing.expectEqual(@as(usize, 4096), whole.height);
- // Without a display size, the old budget.
- const blind = try document.measureRenderAt(0, .{ .dpi = 192, .minimum_width = 960, .max_dimension = 4096 });
- try std.testing.expectEqual(@as(usize, 4096), blind.height);
- // A row is never longer than max_dimension, whatever is shown.
- const wide = try document.measureRenderAt(0, .{ .dpi = 192, .minimum_width = 10_000, .max_dimension = 4096, .display_width = 10_000 });
- try std.testing.expectEqual(@as(usize, 4096), wide.width);
- // One buffer is bounded even when the page is not: a whole render of a
- // page past it is refused, a band of it is not.
- const poster: RenderRequest = .{ .dpi = 72, .minimum_width = 4096, .max_dimension = 4096, .display_width = 4096 };
- const huge = try document.measureRenderAt(0, poster);
- try std.testing.expect(huge.len > max_owned_raster_bytes);
- try std.testing.expectError(error.PixmapTooLarge, document.render(std.testing.allocator, 0, poster, &.{}));
- const band = huge.band(huge.height - 100, 100);
- const rows = try std.testing.allocator.alloc(u8, band.len);
- defer std.testing.allocator.free(rows);
- try document.renderIntoAtWithPaper(0, poster, huge, band, &.{}, rows, false);
- try expectOpaque(rows);
-}
-
-test "PDF links own URIs across page eviction and preserve internal coordinates" {
- const gpa = std.testing.allocator;
- start(gpa);
- defer stop();
- var document = try openTestFile("test/pdf-fixtures/links.pdf");
- defer document.deinit();
- var external = (try document.linkAt(gpa, 0, .{ .x = 0.3, .y = 0.18 })) orelse return error.NoLink;
- defer external.deinit(gpa);
- try std.testing.expectEqualStrings("https://example.com/embedded", external.uri);
- try std.testing.expectEqualStrings(external.uri, external.destination.external);
- try std.testing.expectApproxEqAbs(@as(f32, 0.1), external.quad.ul.x, 0.0001);
- try std.testing.expectApproxEqAbs(@as(f32, 40.0 / 300.0), external.quad.ul.y, 0.0001);
- try std.testing.expectApproxEqAbs(@as(f32, 0.6), external.quad.lr.x, 0.0001);
- const label = try document.copyRectangle(gpa, 0, external.quad);
- defer gpa.free(label);
- try std.testing.expectEqualStrings("target.txt", std.mem.trim(u8, label, "\r\n "));
- var internal = (try document.linkAt(gpa, 0, .{ .x = 0.3, .y = 0.38 })) orelse return error.NoLink;
- defer internal.deinit(gpa);
- try std.testing.expectEqual(@as(usize, 1), internal.destination.internal.page);
- try std.testing.expectApproxEqAbs(@as(f32, 12), internal.destination.internal.x.?, 0.001);
- try std.testing.expectApproxEqAbs(@as(f32, 266), internal.destination.internal.y.?, 0.001);
- const blank = try document.copyRectangle(gpa, 0, internal.quad);
- defer gpa.free(blank);
- try std.testing.expectEqualStrings("", blank);
- try std.testing.expect(try document.linkAt(gpa, 1, .{ .x = 0.3, .y = 0.18 }) == null);
- try std.testing.expectEqualStrings("https://example.com/embedded", external.uri);
- var again = (try document.linkAt(gpa, 0, .{ .x = 0.3, .y = 0.18 })) orelse return error.NoLink;
- defer again.deinit(gpa);
- try std.testing.expectEqualStrings(external.uri, again.uri);
- var failing = std.testing.FailingAllocator.init(gpa, .{ .fail_index = 0 });
- try std.testing.expectError(error.OutOfMemory, document.linkAt(failing.allocator(), 0, .{ .x = 0.3, .y = 0.18 }));
- try std.testing.expectError(error.PageOutOfRange, document.linkAt(gpa, 2, .{ .x = 0.3, .y = 0.18 }));
- for ([_]Point{ .{ .x = -0.1, .y = 0.18 }, .{ .x = 0.3, .y = 1.1 }, .{ .x = std.math.nan(f32), .y = 0.18 } }) |point|
- try std.testing.expect(try document.linkAt(gpa, 0, point) == null);
- try std.testing.expect(try document.linkAt(gpa, 0, .{ .x = 0.99, .y = 0.99 }) == null);
-}
-
-test "PDF links normalize cropped rotated annotations and ignore unsupported actions" {
- const gpa = std.testing.allocator;
- start(gpa);
- defer stop();
- // The page's link's action: a URI, an empty URI, JavaScript, a
- // destination that is not there.
- const fixtures = [_][]const u8{ "rotated-link.pdf", "rotated-link-empty-uri.pdf", "rotated-link-javascript.pdf", "rotated-link-missing-dest.pdf" };
- for (fixtures, 0..) |name, index| {
- var path: [64]u8 = undefined;
- var document = try openTestFile(try std.fmt.bufPrint(&path, "test/pdf-fixtures/{s}", .{name}));
- defer document.deinit();
- var found = try document.linkAt(gpa, 0, .{ .x = 0.1, .y = 0.1 });
- defer if (found) |*item| item.deinit(gpa);
- if (index != 0) {
- try std.testing.expect(found == null);
- continue;
- }
- const link = found orelse return error.NoRotatedLink;
- try std.testing.expectApproxEqAbs(@as(f32, 0), link.quad.ul.x, 0.0001);
- try std.testing.expectApproxEqAbs(@as(f32, 0), link.quad.ul.y, 0.0001);
- try std.testing.expectApproxEqAbs(@as(f32, 50.0 / 150.0), link.quad.lr.x, 0.0001);
- try std.testing.expectApproxEqAbs(@as(f32, 40.0 / 160.0), link.quad.lr.y, 0.0001);
- try std.testing.expect(try document.linkAt(gpa, 0, .{ .x = 0.7, .y = 0.7 }) == null);
- }
-}
-
-fn emitTooDeepOutlinePdf(bytes: *std.Io.Writer, offsets: []usize, levels: usize) !void {
- const first_outline_item = 5;
- try bytes.writeAll("%PDF-1.7\n%\xE2\xE3\xCF\xD3\n");
- try beginPdfObject(bytes, offsets, 1);
- try bytes.writeAll("<< /Type /Catalog /Pages 2 0 R /Outlines 4 0 R >>\nendobj\n");
- try beginPdfObject(bytes, offsets, 2);
- try bytes.writeAll("<< /Type /Pages /Count 1 /Kids [3 0 R] >>\nendobj\n");
- try beginPdfObject(bytes, offsets, 3);
- try bytes.writeAll("<< /Type /Page /Parent 2 0 R /MediaBox [0 0 100 100] /Resources << >> >>\nendobj\n");
- try beginPdfObject(bytes, offsets, 4);
- try bytes.print("<< /Type /Outlines /First 5 0 R /Last 5 0 R /Count {d} >>\nendobj\n", .{levels});
-
- for (0..levels) |level| {
- const number = first_outline_item + level;
- try beginPdfObject(bytes, offsets, number);
- try bytes.print("<< /Title (Level {d}) /Parent {d} 0 R", .{
- level,
- if (level == 0) 4 else number - 1,
- });
- if (level + 1 < levels) {
- try bytes.print(" /First {d} 0 R /Last {d} 0 R /Count {d}", .{
- number + 1,
- number + 1,
- levels - level - 1,
- });
- }
- try bytes.writeAll(" >>\nendobj\n");
- }
- try finishGeneratedPdf(bytes, offsets);
-}
-
-fn makeTooDeepOutlinePdf(gpa: std.mem.Allocator) ![]u8 {
- const levels: usize = c.PARDES_PDF_MAX_OUTLINE_DEPTH + 1;
- const object_count = 5 + levels;
- const offsets = try gpa.alloc(usize, object_count);
- defer gpa.free(offsets);
- return allocateGeneratedPdf(gpa, offsets, levels, emitTooDeepOutlinePdf);
-}
-
-fn emitWideOutlinePdf(bytes: *std.Io.Writer, offsets: []usize, items: usize) !void {
- const first_outline_item = 5;
- try bytes.writeAll("%PDF-1.7\n%\xE2\xE3\xCF\xD3\n");
- try beginPdfObject(bytes, offsets, 1);
- try bytes.writeAll("<< /Type /Catalog /Pages 2 0 R /Outlines 4 0 R >>\nendobj\n");
- try beginPdfObject(bytes, offsets, 2);
- try bytes.writeAll("<< /Type /Pages /Count 1 /Kids [3 0 R] >>\nendobj\n");
- try beginPdfObject(bytes, offsets, 3);
- try bytes.writeAll("<< /Type /Page /Parent 2 0 R /MediaBox [0 0 100 100] /Resources << >> >>\nendobj\n");
- try beginPdfObject(bytes, offsets, 4);
- try bytes.print("<< /Type /Outlines /First 5 0 R /Last {d} 0 R /Count {d} >>\nendobj\n", .{
- first_outline_item + items - 1,
- items,
- });
-
- for (0..items) |ordinal| {
- const number = first_outline_item + ordinal;
- try beginPdfObject(bytes, offsets, number);
- try bytes.print("<< /Title (Section {d}) /Parent 4 0 R /Dest [3 0 R /Fit]", .{ordinal});
- if (ordinal != 0)
- try bytes.print(" /Prev {d} 0 R", .{number - 1});
- if (ordinal + 1 < items)
- try bytes.print(" /Next {d} 0 R", .{number + 1});
- try bytes.writeAll(" >>\nendobj\n");
- }
- try finishGeneratedPdf(bytes, offsets);
-}
-
-fn makeWideOutlinePdf(gpa: std.mem.Allocator, items: usize) ![]u8 {
- if (items == 0) return error.EmptyOutlineFixture;
- const object_count = try std.math.add(usize, 5, items);
- const offsets = try gpa.alloc(usize, object_count);
- defer gpa.free(offsets);
- return allocateGeneratedPdf(gpa, offsets, items, emitWideOutlinePdf);
-}
-
-test "PDF outline is a stable owned DFS view with native destinations" {
- var document = try openTestFile("test/pdf-fixtures/outline.pdf");
- defer document.deinit();
- try std.testing.expectEqual(@as(usize, 3), document.pages);
- for (0..2) |fail_index| {
- var failing = std.testing.FailingAllocator.init(std.testing.allocator, .{
- .fail_index = fail_index,
- });
- try std.testing.expectError(
- error.OutOfMemory,
- document.outline(failing.allocator()),
- );
- }
- for (0..2) |_| {
- var outline = try document.outline(std.testing.allocator);
- defer outline.deinit(std.testing.allocator);
- try std.testing.expectEqual(@as(usize, 4), outline.entries.len);
- try std.testing.expectEqualSlices(u8, &.{ 0, 1, 0, 0 }, &.{
- outline.entries[0].depth,
- outline.entries[1].depth,
- outline.entries[2].depth,
- outline.entries[3].depth,
- });
-
- try std.testing.expect(outline.entries[0].title == null);
- try std.testing.expect(outline.entries[0].destination == .none);
- try std.testing.expectEqualStrings("Café 子", outline.entries[1].title.?);
- const child = outline.entries[1].destination.internal;
- try std.testing.expectEqual(@as(usize, 1), child.page);
- try std.testing.expect(child.x != null and child.y != null);
- try std.testing.expectApproxEqAbs(@as(f32, 12), child.x.?, 0.01);
-
- try std.testing.expectEqualStrings("", outline.entries[2].title.?);
- const fitted = outline.entries[2].destination.internal;
- try std.testing.expectEqual(@as(usize, 2), fitted.page);
- try std.testing.expect(fitted.x == null);
- try std.testing.expect(fitted.y != null);
-
- try std.testing.expectEqualStrings("External", outline.entries[3].title.?);
- try std.testing.expectEqualStrings(
- "https://example.com/manual",
- outline.entries[3].destination.external,
- );
- }
-}
-
-test "PDF outline accepts manual-sized trees and rejects item overflow atomically" {
- const manual_items = 4105;
- try std.testing.expect(max_outline_items >= manual_items);
-
- const manual_fixture = try makeWideOutlinePdf(std.testing.allocator, manual_items);
- defer std.testing.allocator.free(manual_fixture);
- var manual_document = try Document.openBytes(manual_fixture);
- defer manual_document.deinit();
- var outline = try manual_document.outline(std.testing.allocator);
- defer outline.deinit(std.testing.allocator);
- try std.testing.expectEqual(@as(usize, manual_items), outline.entries.len);
- try std.testing.expectEqualStrings("Section 0", outline.entries[0].title.?);
- try std.testing.expectEqualStrings("Section 4104", outline.entries[manual_items - 1].title.?);
- try std.testing.expectEqual(@as(usize, 0), outline.entries[manual_items - 1].destination.internal.page);
-
- const overflow_fixture = try makeWideOutlinePdf(std.testing.allocator, max_outline_items + 1);
- defer std.testing.allocator.free(overflow_fixture);
- var overflow_document = try Document.openBytes(overflow_fixture);
- defer overflow_document.deinit();
- var raw: c.pardes_pdf_outline_result = undefined;
- @memset(std.mem.asBytes(&raw), 0xa5);
- try std.testing.expectEqual(
- c.PARDES_PDF_LIMIT_EXCEEDED,
- c.pardes_pdf_load_outline(overflow_document.handle, &raw),
- );
- try std.testing.expect(raw.handle == null);
- try std.testing.expect(raw.items == null);
- try std.testing.expectEqual(@as(usize, 0), raw.item_count);
- try std.testing.expect(raw.bytes == null);
- try std.testing.expectEqual(@as(usize, 0), raw.bytes_len);
-}
-
-test "PDF outline absence and hostile depth are atomic and repeatable" {
- var plain_document = try openTestFile("test/pdf-fixtures/offset-rotated.pdf");
- defer plain_document.deinit();
- var absent = try plain_document.outline(std.testing.allocator);
- defer absent.deinit(std.testing.allocator);
- try std.testing.expectEqual(@as(usize, 0), absent.entries.len);
- try std.testing.expectEqual(@as(usize, 0), absent.bytes.len);
-
- const deep_fixture = try makeTooDeepOutlinePdf(std.testing.allocator);
- defer std.testing.allocator.free(deep_fixture);
- var deep_document = try Document.openBytes(deep_fixture);
- defer deep_document.deinit();
- var raw: c.pardes_pdf_outline_result = undefined;
- @memset(std.mem.asBytes(&raw), 0xa5);
- try std.testing.expectEqual(
- c.PARDES_PDF_LIMIT_EXCEEDED,
- c.pardes_pdf_load_outline(deep_document.handle, &raw),
- );
- try std.testing.expect(raw.handle == null);
- try std.testing.expect(raw.items == null);
- try std.testing.expectEqual(@as(usize, 0), raw.item_count);
- try std.testing.expect(raw.bytes == null);
- try std.testing.expectEqual(@as(usize, 0), raw.bytes_len);
- for (0..2) |_|
- try std.testing.expectError(
- error.OutlineLimitExceeded,
- deep_document.outline(std.testing.allocator),
- );
- const size = try deep_document.pageSize(0);
- try std.testing.expectEqual(@as(f32, 100), size.width);
- try std.testing.expectEqual(@as(f32, 100), size.height);
-}
-
-test "caller-owned RGBA layout is packed and overflow checked" {
- const layout = try checkedRasterLayout(.{
- .width = 2,
- .height = 3,
- .stride = 8,
- .samples_len = 24,
- });
- try std.testing.expectEqual(@as(usize, 2), layout.width);
- try std.testing.expectEqual(@as(usize, 3), layout.height);
- try std.testing.expectEqual(@as(usize, 8), layout.stride);
- try std.testing.expectEqual(@as(usize, 24), layout.len);
- try std.testing.expectError(error.BadPixmap, checkedRasterLayout(.{
- .width = 2,
- .height = 3,
- .stride = 7,
- .samples_len = 21,
- }));
-}
-
-test "RGBA allocation and buffer-validation failures leave the document renderable" {
- var document = try openTestFile("docs/design.pdf");
- defer document.deinit();
-
- var failing = std.testing.FailingAllocator.init(std.testing.allocator, .{
- .fail_index = 0,
- });
- try std.testing.expectError(
- error.OutOfMemory,
- document.render(failing.allocator(), 0, .{}, &.{}),
- );
-
- const request = try document.boundedRequest(0, .{});
- var raw_layout: c.pardes_pdf_raster_layout = std.mem.zeroes(c.pardes_pdf_raster_layout);
- try std.testing.expectEqual(c.PARDES_PDF_OK, c.pardes_pdf_measure_render(document.handle, 0, &request, &raw_layout));
- const layout = try checkedRasterLayout(raw_layout);
- {
- const scratch = try std.testing.allocator.alloc(u8, layout.len);
- defer std.testing.allocator.free(scratch);
- @memset(scratch, 0xa5);
- try std.testing.expectEqual(c.PARDES_PDF_ERROR, c.pardes_pdf_render_into(
- document.handle,
- 0,
- &request,
- null,
- 0,
- scratch.ptr,
- scratch.len - 1,
- raw_layout.width,
- raw_layout.height,
- raw_layout.stride,
- 0,
- raw_layout.height,
- 0,
- ));
- for (scratch) |byte|
- try std.testing.expectEqual(@as(u8, 0xa5), byte);
- }
-
- const after = try document.render(std.testing.allocator, 0, .{}, &.{});
- defer std.testing.allocator.free(after.rgba);
- const repeated = try document.render(std.testing.allocator, 0, .{}, &.{});
- defer std.testing.allocator.free(repeated.rgba);
- try std.testing.expectEqualSlices(u8, after.rgba, repeated.rgba);
- try expectOpaque(after.rgba);
- try expectOpaque(repeated.rgba);
-}
-
-test "a band's rows are the full page's rows, and highlights land in them" {
- // THE claim the fast-scroll path rests on: rendering rows [y, y+h) of a
- // page is the same rendering, clipped — not a different one. If MuPDF ever
- // let the pixmap's bbox change antialiasing, hinting or subpixel placement,
- // a fling would show pixels a reader could tell apart from a rested view,
- // and this test is what refuses to let that happen quietly.
- var document = try openTestFile("docs/design.pdf");
- defer document.deinit();
-
- const request: RenderRequest = .{ .dpi = 96, .max_dimension = 1200 };
- const raster = try document.measureRenderAt(0, request);
- const whole = try std.testing.allocator.alloc(u8, raster.len);
- defer std.testing.allocator.free(whole);
- try document.renderIntoAtWithPaper(0, request, raster, raster.wholePage(), &.{}, whole, false);
-
- // Odd offsets and an odd height on purpose: a band that starts on a row
- // MuPDF would never choose itself is exactly where an off-by-one in the
- // bbox arithmetic would show up.
- const cases = [_]struct { y: usize, h: usize }{
- .{ .y = 0, .h = 1 },
- .{ .y = 1, .h = 37 },
- .{ .y = raster.height / 3, .h = 101 },
- .{ .y = raster.height / 2, .h = raster.height / 2 },
- .{ .y = raster.height - 1, .h = 1 },
- };
- for (cases) |case| {
- const band = raster.band(case.y, case.h);
- const rows = try std.testing.allocator.alloc(u8, band.len);
- defer std.testing.allocator.free(rows);
- try document.renderIntoAtWithPaper(0, request, raster, band, &.{}, rows, false);
- const from = band.y * raster.stride;
- try std.testing.expectEqualSlices(u8, whole[from..][0..band.len], rows);
- try expectOpaque(rows);
- }
-
- // A baked highlight is drawn under the same CTM, so it has to land on the
- // same rows through a band as it does through a whole page.
- const highlights = [_]Highlight{.{
- .quad = .{
- .ul = .{ .x = 0.1, .y = 0.4 },
- .ur = .{ .x = 0.9, .y = 0.4 },
- .ll = .{ .x = 0.1, .y = 0.6 },
- .lr = .{ .x = 0.9, .y = 0.6 },
- },
- .kind = .search,
- .rgba = .{ 0x30, 0x80, 0xf0, 0x80 },
- }};
- const marked_whole = try std.testing.allocator.alloc(u8, raster.len);
- defer std.testing.allocator.free(marked_whole);
- try document.renderIntoAtWithPaper(0, request, raster, raster.wholePage(), &highlights, marked_whole, false);
- const marked_band = raster.band(raster.height / 3, raster.height / 3);
- const marked_rows = try std.testing.allocator.alloc(u8, marked_band.len);
- defer std.testing.allocator.free(marked_rows);
- try document.renderIntoAtWithPaper(0, request, raster, marked_band, &highlights, marked_rows, false);
- const marked_from = marked_band.y * raster.stride;
- try std.testing.expectEqualSlices(
- u8,
- marked_whole[marked_from..][0..marked_band.len],
- marked_rows,
- );
- // ...and the highlight really is in the band that was compared, or the
- // comparison above would be two identical plain renders agreeing.
- try std.testing.expect(!std.mem.eql(
- u8,
- whole[marked_from..][0..marked_band.len],
- marked_rows,
- ));
-
- // A band request that misses the page is a viewport that has left it, not
- // a malformed call: it clamps instead of failing.
- const past_end = raster.band(raster.height + 500, 64);
- try std.testing.expect(past_end.y < raster.height);
- try std.testing.expectEqual(@as(usize, 1), past_end.height);
-}
-
-test "MuPDF search returns normalized oriented quads and word selection text" {
- var document = try openTestFile("docs/design.pdf");
- defer document.deinit();
-
- const projected = try document.pageText(std.testing.allocator, 0);
- defer std.testing.allocator.free(projected);
- try std.testing.expect(std.ascii.findIgnoreCase(projected, "Pardes") != null);
- // Exercise transactional cache replacement before searching page zero
- // again; a failed ownership handoff here tends to surface as a double drop.
- if (document.pages > 1) {
- const other_page = try document.pageText(std.testing.allocator, 1);
- std.testing.allocator.free(other_page);
- }
-
- var found = try document.search(std.testing.allocator, 0, "Pardes");
- defer found.deinit(std.testing.allocator);
- try std.testing.expect(found.hit_count > 0);
- try std.testing.expect(found.quads.len > 0);
- for (found.quads) |item| {
- try std.testing.expect(item.hit < found.hit_count);
- try std.testing.expect(validQuad(item.quad));
- }
-
- const first = found.quads[0].quad;
- var selected = try document.select(std.testing.allocator, 0, first.ul, first.lr);
- defer selected.deinit(std.testing.allocator);
- try std.testing.expect(selected.quads.len > 0);
- try std.testing.expect(validPoint(selected.start));
- try std.testing.expect(validPoint(selected.end));
-
- const text = try document.copySelection(std.testing.allocator, 0, selected.start, selected.end);
- defer std.testing.allocator.free(text);
- try std.testing.expect(std.ascii.findIgnoreCase(text, "Pardes") != null);
-}
-
-test "highlighted render changes pixels while plain render stays stable" {
- var document = try openTestFile("docs/design.pdf");
- defer document.deinit();
-
- const plain_before = try document.render(std.testing.allocator, 0, .{}, &.{});
- defer std.testing.allocator.free(plain_before.rgba);
- const whole_page = Quad{
- .ul = .{ .x = 0, .y = 0 },
- .ur = .{ .x = 1, .y = 0 },
- .ll = .{ .x = 0, .y = 1 },
- .lr = .{ .x = 1, .y = 1 },
- };
- const highlights = [_]Highlight{
- Highlight.init(whole_page, .{ 255, 0, 0, 128 }, .custom),
- };
- const marked = try document.render(std.testing.allocator, 0, .{}, &highlights);
- defer std.testing.allocator.free(marked.rgba);
- const plain_after = try document.render(std.testing.allocator, 0, .{}, &.{});
- defer std.testing.allocator.free(plain_after.rgba);
-
- try expectOpaque(plain_before.rgba);
- try expectOpaque(marked.rgba);
- try expectOpaque(plain_after.rgba);
- try std.testing.expectEqual(plain_before.width, marked.width);
- try std.testing.expectEqual(plain_before.height, marked.height);
- try std.testing.expect(!std.mem.eql(u8, plain_before.rgba, marked.rgba));
- try std.testing.expectEqualSlices(u8, plain_before.rgba, plain_after.rgba);
-}
-
-test "offset crop and rotation keep normalized highlights pixel-aligned" {
- var document = try openTestFile("test/pdf-fixtures/offset-rotated.pdf");
- defer document.deinit();
- const plain = try document.render(std.testing.allocator, 0, .{}, &.{});
- defer std.testing.allocator.free(plain.rgba);
- // CropBox is 160x150 points and /Rotate 90 swaps its displayed axes.
- try std.testing.expectEqual(@as(usize, 300), plain.width);
- try std.testing.expectEqual(@as(usize, 320), plain.height);
-
- // The SIZE comes off the page object rather than a loaded page (see
- // pardes_pdf_get_page_size), and this is the fixture that would catch it
- // being a different answer: an offset CropBox plus /Rotate 90, where a
- // MediaBox reading, an untransformed cropbox or a missed rotation all give
- // plausible-looking wrong numbers. The rendered raster above is what
- // fz_bound_page produces, so the strip's layout has to agree with it.
- const size = try document.pageSize(0);
- try std.testing.expectEqual(@as(f32, 150), size.width);
- try std.testing.expectEqual(@as(f32, 160), size.height);
- try std.testing.expectApproxEqAbs(
- @as(f32, @floatFromInt(plain.width)) / @as(f32, @floatFromInt(plain.height)),
- size.width / size.height,
- 0.001,
- );
-
- const kitty = try document.render(std.testing.allocator, 0, .{
- .dpi = 96,
- .max_dimension = 1200,
- }, &.{});
- defer std.testing.allocator.free(kitty.rgba);
- try std.testing.expect(kitty.width < plain.width);
- try std.testing.expect(kitty.height < plain.height);
-
- const sdl = try document.render(std.testing.allocator, 0, .{
- .dpi = 192,
- .minimum_width = 640,
- .minimum_height = 480,
- .max_dimension = 4096,
- }, &.{});
- defer std.testing.allocator.free(sdl.rgba);
- try std.testing.expect(sdl.width >= 640);
- try std.testing.expect(sdl.height >= 480);
- try std.testing.expect(sdl.width * sdl.height >= kitty.width * kitty.height * 4);
-
- const capped = try document.render(std.testing.allocator, 0, .{
- .dpi = 192,
- .minimum_width = 4096,
- .minimum_height = 4096,
- .max_dimension = 512,
- }, &.{});
- defer std.testing.allocator.free(capped.rgba);
- try std.testing.expectEqual(@as(usize, 512), @max(capped.width, capped.height));
-
- const left_half = Quad{
- .ul = .{ .x = 0, .y = 0 },
- .ur = .{ .x = 0.5, .y = 0 },
- .ll = .{ .x = 0, .y = 1 },
- .lr = .{ .x = 0.5, .y = 1 },
- };
- const highlights = [_]Highlight{
- Highlight.init(left_half, .{ 0, 0, 255, 255 }, .custom),
- };
- const marked = try document.render(std.testing.allocator, 0, .{}, &highlights);
- defer std.testing.allocator.free(marked.rgba);
- try std.testing.expectEqual(plain.width, marked.width);
- try std.testing.expectEqual(plain.height, marked.height);
-
- const left = (plain.height / 2 * plain.width + plain.width / 4) * 4;
- const right = (plain.height / 2 * plain.width + plain.width * 3 / 4) * 4;
- try std.testing.expect(plain.rgba[left] > 240 and
- plain.rgba[left + 1] < 10 and plain.rgba[left + 2] < 10);
- try std.testing.expect(marked.rgba[left] < 10 and
- marked.rgba[left + 1] < 10 and marked.rgba[left + 2] > 240);
- try std.testing.expectEqualSlices(u8, plain.rgba[right .. right + 4], marked.rgba[right .. right + 4]);
-}
-
-test "transparent PDF paper preserves ink and band coverage" {
- var document = try openTestFile("docs/9p.pdf");
- defer document.deinit();
- const request: RenderRequest = .{ .dpi = 96, .max_dimension = 1200 };
- const raster = try document.measureRenderAt(0, request);
- const flattened = try std.testing.allocator.alloc(u8, raster.len);
- defer std.testing.allocator.free(flattened);
- const content = try std.testing.allocator.alloc(u8, raster.len);
- defer std.testing.allocator.free(content);
- try document.renderIntoAtWithPaper(0, request, raster, raster.wholePage(), &.{}, flattened, false);
- try document.renderIntoAtWithPaper(0, request, raster, raster.wholePage(), &.{}, content, true);
- var paper: usize = 0;
- var ink: usize = 0;
- var edges: usize = 0;
- for (std.mem.bytesAsSlice([4]u8, content), std.mem.bytesAsSlice([4]u8, flattened)) |pixel, reference| {
- const a: u32 = pixel[3];
- paper += @intFromBool(a == 0);
- ink += @intFromBool(a == 255);
- edges += @intFromBool(a > 0 and a < 255);
- for (0..3) |channel| {
- const over_white = (a * pixel[channel] + (255 - a) * 255 + 127) / 255;
- try std.testing.expect(@abs(@as(i32, @intCast(over_white)) - @as(i32, reference[channel])) <= 2);
- }
- }
- try std.testing.expect(paper > 100 and ink > 100 and edges > 100);
- const band = raster.band(raster.height / 3, raster.height / 4);
- const rows = try std.testing.allocator.alloc(u8, band.len);
- defer std.testing.allocator.free(rows);
- try document.renderIntoAtWithPaper(0, request, raster, band, &.{}, rows, true);
- try std.testing.expectEqualSlices(u8, content[band.y * raster.stride ..][0..band.len], rows);
-}