aboutsummaryrefslogtreecommitdiffstats
path: root/vendor/libghostty-vt/src/font/glyf_rasterize_png_test.zig
blob: 881c0ed98aee538b81cab366607d83506a9b963f (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
const std = @import("std");
const Allocator = std.mem.Allocator;
const wuffs = @import("wuffs");
const z2d = @import("z2d");
const compat_file = @import("../lib/compat/file.zig");

const glyf_rasterize = @import("glyf_rasterize.zig");
const glyf = @import("opentype/glyf.zig");

const log = std.log.scoped(.glyf_rasterize);

const test_glyf_payloads = [_][]const u8{
    // Nerd Font branch, folder, home, heart, and Rust cog outlines from:
    // https://github.com/raphamorim/glyph-protocol-examples/blob/main/bubbletea/main.go
    "AAIARv8zAhIDnQAZAB0AABcjNTQ3Njc3Njc2NTUjNxcjFRQGBwcGBwYVEQcRM82HJxs3SyoUE2aPjmY0NCUvDxSHh83rVzgoIzAbKSZAoaenvF5kIhkfHSM9AVdXAn8=",
    "AAEAAP/UA5wC/AAVAAAXIiY1ETQ2MzMyFxcWMyEyFgcRFgYjcy9ERC/nOCQjER0BITBEAQFEMCxELwJBMEQvLhdEL/4yL0Q=",
    "AAEAAP+aBBEDNgA+AAABFAYjIxMUBxUUBisFIiY9AjQmIyMiBh0CFAYrAiIiJwYiIyMiJjc1MjQ1NSMiJjQ3ATYzMhcBFgQOJBY5AQEqHh0GBzsrHioiGHMYIioeLDkBBAMBBAIcHiwBAToYIhIBzg4aFw8BzBcBahgi/t4KBB4eKioeLHQYIiIYdCweKgICKh7KBAJ+IDISAZQODP5qFA==",
    "AAEAAP/dA5sC+QAZAAATJjU1NDY3NhYXFzc2NhcWFhUVFAcBBiMiJ1ZWel09eCwWFSx4PV16Vv66FB0eFAEhUHULXpAQCiYsFhYsJgoQkF4LdVD+zxMT",
    "AAoAAP/YAyEC+AENARcBWgFlAW8BfQGIAbsBxAHNAAAAMhYXFhYyNjc2MzIXFhcWFxY3NjMyFhcWFxY3NjMyFxcHBxcWNzYXFgcGFxYzMhcWBw4CFAcUFQcUFxYWFRQGFhcWFgcGFBcWFxYGBwYUFxYGBw4CFhYXFgcGBwYVFBcWBwYjIgYXFgYnJgcGFxcHBiInJgYHBiMiJyYHBgcGBiMiJyYiBwYiJyYmBwYGJyYmJyYHBiImJyYmBwYiJjc3JyYHBicmNzYmIwYmNzY2Nzc0JyYmNTQ3NiYnJiY3NjQnJiY0Njc2NjQnJicmJjY3NjYnJjc3Mjc2NScmJyYnJjYXMjY1NCYmJyc3NhcWNzcnJjYzMhcWNjc2NjMyFxY3Njc2NjMyFxYyNzY3FyIHBhYzMjYnJgczBwYHBhUUMzIXFhYHBgcOAhUGFQciFhcWFxYXFhcWFjc2NzY3NjMzNzYvAiYnJjU0NzcnJicmJicnBwYGJyYnBwYGFxYyNzYmJyYFIgcGFBcWNicmBRcWBwYPAgYXFzM1NRcVMzY3NjU0JyYjBxUzMhcWFQcjIhUGFjMyNzYyFxYXFhUWFhcWNzY/AjY2Fxc2NjQjIiYnJicmJyYnJiMGIgcGFjMyNiclIgcGFjc2JyYBjQQICgcECAgIEQMJBgUCAwUGEBMDBgQEAwUDFBIFAwQEAQEEBRIZBQUGBQMCFxUFBwwBAgICARgSChoEFBcEExEUDwQECBATERMEGAoGCAQEBhEHAxUZCAsGAxcYBAUGChoVAgMBAQQEBhQSCgMECgQRFAUEBgcGBAUQEAgLDQwOCwoODQgFBg4CBRUPDAQEBAgTFAYIAQEEBREaBAYGBQQYGQYKAQQCARgSCg0NBBQXBBMQERIEBg4KCAIDCg0ECBEUBA0QBwQFEBcBAQICAgsIGRgCAgIBBAMFGhIFBAEBCAMFEhMIBAQEBgUREQQGCAcEBgQQDwoLCQQFCQcMDBARCg0HPgEPQjEfoJ8NJzACAykCBAQCAQEEAgIDGAgEAwggCg0BAQMCDBABAgIBHRsDBw4PAx8xFkQTCRQSEAkHEvoMDgcHGAgEBAcFAjAHBA0OFBQTBf3wBAsIAh0cAQMKBFOENjcIERsLLzEkJAECAXl5ARgBBBQZEAYEBQYBRCEnKiYSBgYGECAcARg/NhQLDgkLBQkQBimQEAQPChESCA4BVRAGCigLChEFAvgEEQsIBgkREA8FCAIBDA0KERYCAgkIBAQWFwIDBQYFBBkVAwIDBhkDBAQEAQEBAQcEAwQHBSQICAgMEREICwoFBggKDAgQEQwJBAQCCAgHGAYDAwQIAxAXBwMGFBkKBgQCAxYWBAQJCAQVHAwOAwQQEwYREBMVFBMCEA0GAgQmAgQPDAoSFgQJCQgXFgICBAYEBhgVBgEMFgQKAwMGBAQEBgQTEQgJCQwQEAgLCwQMBAkHBAoDAwkLDAgGCAgSFwcEAwQHAgIGBQQXDAEEBQEGCgQTBAcGBAICFxYICAkEFhEKDA0BARcSBBEPEw8ERQcKHiAKBScEESgaBAIDCjghJh4BBAIBAQEBBAECAhUjEQMJAgcIGBMBAQURFgcNDAMHCgYgIQY0IxAcBAETEwgDBBObARgMCwwIFAQEAgIIHAYKKAsDAwkYDQQNDRAjLg9eXgE4AQQHDhQHA4g0AgQqKwICGgUECAkVHAEHFAMDCAcKAx4iCgcGARwCBAwPJjAHDgQCwgMJIiIJAg0UFBIRDgQ=",
};

/// Return deterministic font metrics for the PNG reference test.
///
/// These are intentionally minimal: the rasterizer only needs cell geometry,
/// face geometry, and icon heights for constraint calculations.
fn testMetrics(width: u32, height: u32) @import("Metrics.zig") {
    return .{
        .cell_width = width,
        .cell_height = height,
        .cell_baseline = 0,
        .underline_position = height,
        .underline_thickness = 1,
        .strikethrough_position = height / 2,
        .strikethrough_thickness = 1,
        .overline_position = 0,
        .overline_thickness = 1,
        .box_thickness = 1,
        .cursor_thickness = 1,
        .cursor_height = height,
        .icon_height = @floatFromInt(height),
        .icon_height_single = @floatFromInt(height),
        .face_width = @floatFromInt(width),
        .face_height = @floatFromInt(height),
        .face_y = 0,
    };
}

/// Decode a base64-encoded glyf protocol payload into an owned outline.
///
/// The payload is a complete simple-glyph `glyf` table entry. The returned
/// outline owns decoded point and contour storage and must be deinitialized by
/// the caller.
fn decodeGlyfPayload(alloc: Allocator, payload: []const u8) !glyf.Glyf.Outline {
    const decoder = std.base64.standard.Decoder;
    const size = try decoder.calcSizeForSlice(payload);
    const data = try alloc.alloc(u8, size);
    defer alloc.free(data);

    try decoder.decode(data, payload);
    const entry = try glyf.Glyf.Entry.init(data);
    return try entry.decode(alloc);
}

/// Copy a tightly packed alpha bitmap into the alpha atlas at `dst_x`, `dst_y`.
///
/// The destination rectangle must fit inside the atlas. This is a test helper,
/// so it trusts the hardcoded atlas layout rather than clipping.
fn blitBitmap(atlas: *z2d.Surface, bm: glyf_rasterize.Bitmap, dst_x: usize, dst_y: usize) void {
    const dst_width: usize = @intCast(atlas.getWidth());
    const dst = std.mem.sliceAsBytes(atlas.image_surface_alpha8.buf);
    for (0..bm.height) |y| {
        const src_start = y * bm.width;
        const src_end = src_start + bm.width;
        const dst_start = (dst_y + y) * dst_width + dst_x;
        @memcpy(dst[dst_start .. dst_start + bm.width], bm.data[src_start..src_end]);
    }
}

/// Draw faint terminal-cell outlines into one row of the alpha atlas.
///
/// The boxes make cell advance and placement behavior visible in the reference
/// PNG without overpowering the rendered glyph coverage.
fn drawCellBoxes(atlas: *z2d.Surface, y: usize, cell_width: usize, cell_height: usize) void {
    const width: usize = @intCast(atlas.getWidth());
    const dst = std.mem.sliceAsBytes(atlas.image_surface_alpha8.buf);
    const alpha = 64;

    var x: usize = 0;
    while (x < width) : (x += cell_width) {
        const right = @min(x + cell_width - 1, width - 1);
        const bottom = y + cell_height - 1;

        for (x..right + 1) |px| {
            dst[y * width + px] = @max(dst[y * width + px], alpha);
            dst[bottom * width + px] = @max(dst[bottom * width + px], alpha);
        }
        for (y..bottom + 1) |py| {
            dst[py * width + x] = @max(dst[py * width + x], alpha);
            dst[py * width + right] = @max(dst[py * width + right], alpha);
        }
    }
}

/// Compare a generated atlas PNG against the checked-in reference image.
///
/// On missing reference or mismatch, copy the generated PNG into the workspace
/// as `glyf_rasterize_test.png`. On pixel mismatch, also write
/// `glyf_rasterize_diff.png`, where red is reference-only coverage and green is
/// newly generated coverage. Returns true when a difference was found.
fn diffAtlas(
    io: std.Io,
    alloc: Allocator,
    atlas: *z2d.Surface,
    generated_path: []const u8,
) !bool {
    const ref_path = "src/font/testdata/glyf_rasterize.png";

    const generated_file = try std.Io.Dir.openFileAbsolute(io, generated_path, .{ .mode = .read_only });
    defer generated_file.close(io);
    const generated_bytes = try compat_file.readToEndAlloc(generated_file, alloc, std.math.maxInt(usize));
    defer alloc.free(generated_bytes);

    const cwd_absolute = try std.Io.Dir.cwd().realPathFileAlloc(io, ".", alloc);
    defer alloc.free(cwd_absolute);

    const ref_file = std.Io.Dir.cwd().openFile(io, ref_path, .{ .mode = .read_only }) catch |err| {
        log.err("Can't open reference file {s}: {}", .{ ref_path, err });

        const test_path = try std.fmt.allocPrint(alloc, "{s}/glyf_rasterize_test.png", .{cwd_absolute});
        defer alloc.free(test_path);
        try std.Io.Dir.copyFileAbsolute(generated_path, test_path, io, .{});
        return true;
    };
    defer ref_file.close(io);
    const ref_bytes = try compat_file.readToEndAlloc(ref_file, alloc, std.math.maxInt(usize));
    defer alloc.free(ref_bytes);

    if (std.mem.eql(u8, generated_bytes, ref_bytes)) return false;

    const test_path = try std.fmt.allocPrint(alloc, "{s}/glyf_rasterize_test.png", .{cwd_absolute});
    defer alloc.free(test_path);
    try std.Io.Dir.copyFileAbsolute(generated_path, test_path, io, .{});

    const ref_rgba = try wuffs.png.decode(alloc, ref_bytes);
    defer alloc.free(ref_rgba.data);

    if (ref_rgba.width != atlas.getWidth() or ref_rgba.height != atlas.getHeight()) {
        log.err(
            "glyf rasterize visual output dimensions differ from reference: " ++
                "test={s} ({d}x{d}), reference={s} ({d}x{d})",
            .{ test_path, atlas.getWidth(), atlas.getHeight(), ref_path, ref_rgba.width, ref_rgba.height },
        );
        return true;
    }

    var diff = try z2d.Surface.init(
        .image_surface_rgb,
        alloc,
        atlas.getWidth(),
        atlas.getHeight(),
    );
    defer diff.deinit(alloc);

    const test_gray = std.mem.sliceAsBytes(atlas.image_surface_alpha8.buf);
    const diff_pix = diff.image_surface_rgb.buf;
    var differs = false;
    for (test_gray, 0..) |t, i| {
        const r = ref_rgba.data[i * 4];
        if (t == r) {
            diff_pix[i].r = t / 3;
            diff_pix[i].g = t / 3;
            diff_pix[i].b = t / 3;
        } else {
            differs = true;
            diff_pix[i].r = r;
            diff_pix[i].g = t;
        }
    }

    if (!differs) {
        log.err(
            "generated glyf rasterize PNG bytes differ from reference but pixels match; " ++
                "test={s}, reference={s}",
            .{ test_path, ref_path },
        );
        return true;
    }

    const diff_path = "./glyf_rasterize_diff.png";
    try z2d.png_exporter.writeToPNGFile(io, diff, diff_path, .{});
    log.err(
        "glyf rasterize visual output differs from reference: test={s}, reference={s}, diff={s}",
        .{ test_path, ref_path, diff_path },
    );

    return true;
}

test "glyf_rasterize: bubbletea glyph protocol examples match reference image" {
    const testing = std.testing;
    const alloc = testing.allocator;

    // The generated PNG is a visual atlas for reading placement behavior.
    // Each column below is one terminal cell. The five payloads are rendered in
    // order: branch, folder, home, heart, rust.
    //
    // ```text
    // columns: 0 1 2 3 4 5 6 7 8 9
    //          ┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
    // row 0    │B│F│H│♥│R│ │ │ │ │ │  narrow/default: one-cell bitmap stride
    //          ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
    // row 1    │B  │F  │H  │♥  │R  │  width=2: same glyphs, two-cell bitmaps
    //          ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
    // row 2    │  B│  F│  H│  ♥│  R│  width=2 + horizontal center alignment
    //          ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
    // row 3    │B  │F  │H  │♥  │R  │  advance_width=2000: wider design box
    //          └─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
    // ```
    //
    // The faint grid lines in the PNG are these cell boundaries. Rows 2 and 3
    // are the design-metric/placement regression checks: row 2 centers a
    // one-cell-wide design box inside two cells, while row 3 centers a two-cell
    // design box so the visible glyph returns to the start of each span.
    const cell_width = 20;
    const cell_height = 20;
    const columns = test_glyf_payloads.len;
    const narrow_stride_x = cell_width;
    const wide_stride_x = cell_width * 2;
    const row_count = 4;

    var atlas = try z2d.Surface.init(
        .image_surface_alpha8,
        alloc,
        @intCast(wide_stride_x * columns),
        cell_height * row_count,
    );
    defer atlas.deinit(alloc);

    for (test_glyf_payloads, 0..) |payload, i| {
        var outline = try decodeGlyfPayload(alloc, payload);
        defer outline.deinit(alloc);

        var narrow = try glyf_rasterize.rasterize(alloc, outline, .{
            .units_per_em = 1000,
            .advance_width = 1000,
            .line_height = 1000,
        }, .{
            .grid_metrics = testMetrics(cell_width, cell_height),
        });
        defer narrow.deinit(alloc);
        blitBitmap(&atlas, narrow, i * narrow_stride_x, 0);

        var wide = try glyf_rasterize.rasterize(alloc, outline, .{
            .units_per_em = 1000,
            .advance_width = 1000,
            .line_height = 1000,
        }, .{
            .grid_metrics = testMetrics(cell_width, cell_height),
            .cell_width = 2,
        });
        defer wide.deinit(alloc);
        blitBitmap(&atlas, wide, i * wide_stride_x, cell_height);

        var centered = try glyf_rasterize.rasterize(alloc, outline, .{
            .units_per_em = 1000,
            .advance_width = 1000,
            .line_height = 1000,
        }, .{
            .grid_metrics = testMetrics(cell_width, cell_height),
            .cell_width = 2,
            .constraint_width = 2,
            .constraint = .{ .align_horizontal = .center },
        });
        defer centered.deinit(alloc);
        blitBitmap(&atlas, centered, i * wide_stride_x, cell_height * 2);

        var designed_wide = try glyf_rasterize.rasterize(alloc, outline, .{
            .units_per_em = 1000,
            .advance_width = 2000,
            .line_height = 1000,
        }, .{
            .grid_metrics = testMetrics(cell_width, cell_height),
            .cell_width = 2,
            .constraint_width = 2,
            .constraint = .{ .align_horizontal = .center },
        });
        defer designed_wide.deinit(alloc);
        blitBitmap(&atlas, designed_wide, i * wide_stride_x, cell_height * 3);
    }

    for (0..row_count) |row| drawCellBoxes(&atlas, row * cell_height, cell_width, cell_height);

    var dir = testing.tmpDir(.{});
    defer dir.cleanup();
    const tmp_dir = try dir.dir.realPathFileAlloc(testing.io, ".", alloc);
    defer alloc.free(tmp_dir);

    const generated_path = try std.fmt.allocPrint(alloc, "{s}/glyf_rasterize.png", .{tmp_dir});
    defer alloc.free(generated_path);
    try z2d.png_exporter.writeToPNGFile(testing.io, atlas, generated_path, .{});

    try testing.expect(!try diffAtlas(testing.io, alloc, &atlas, generated_path));
}