summaryrefslogtreecommitdiff
path: root/src/image.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-10-30 17:35:06 -0300
committerGabriel Schneider <[email protected]>2026-10-30 17:35:06 -0300
commit6d8da8721141284cf33bb901168b26135893eb86 (patch)
tree791d63401d4e85fbca1d597a8ce0326e70efd545 /src/image.zig
parentefd43a3a2cf03bb741366331158b368abf9ac583 (diff)
parentbf6810a8f9d6cc82050e7d9c0cfb06358301b574 (diff)
downloadpardes-6d8da8721141284cf33bb901168b26135893eb86.tar.gz
pardes-6d8da8721141284cf33bb901168b26135893eb86.zip
Merge latest upstream into the macOS branch for Zig 0.17
Retain the macOS branch history and local Acme selection color while adopting upstream's current core and platform changes. Pin Zig and ZLS to 0.17.0, and fetch the existing zstbi compatibility commit through upstream after its original fork was removed.
Diffstat (limited to 'src/image.zig')
-rw-r--r--src/image.zig453
1 files changed, 443 insertions, 10 deletions
diff --git a/src/image.zig b/src/image.zig
index 592230c8..e334965a 100644
--- a/src/image.zig
+++ b/src/image.zig
@@ -1,5 +1,6 @@
//! Image decoding, pixel placement, and glyph approximation.
const std = @import("std");
+const builtin = @import("builtin");
const zstbi = @import("zstbi");
/// The 16-colour ANSI table below is the only thing this file ever wanted from
/// the emulator, and a build without one still renders images — see
@@ -7,6 +8,10 @@ const zstbi = @import("zstbi");
const terminal_panes = @import("pardes.zig").terminal_panes;
const ghostty_vt = if (terminal_panes) @import("ghostty-vt") else struct {};
const pdf_enabled = @import("pardes_config").mupdf;
+const pardes = @import("pardes.zig");
+const config = @import("config.zig");
+const filesystem = @import("fs.zig");
+const dump = @import("dump.zig");
// Glyph matching adapted from caioluders/petsciinator.
pub const GlyphArt = struct {
pub const commodore = [16][3]u8{
@@ -238,11 +243,11 @@ pub const GlyphArt = struct {
const glyphs_ascii = glyphs ++ ascii_glyphs;
fn matchCell(cell: *const [64][3]u8, pal: Palette, gset: []const Glyph) Cell {
- var counts = [_]u16{0} ** 16;
+ var counts = @as([16]u16, @splat(0));
for (cell) |px| counts[nearest(px, pal)] += 1;
var cand: [4]u4 = undefined;
var ncand: usize = 0;
- var used = [_]bool{false} ** 16;
+ var used = @as([16]bool, @splat(false));
while (ncand < 4) : (ncand += 1) {
var best: ?usize = null;
for (counts, 0..) |c, i| {
@@ -301,7 +306,6 @@ pub const GlyphArt = struct {
pub fn render(gpa: std.mem.Allocator, rgba: []const u8, iw: usize, ih: usize, max_cols: usize, max_rows: usize, pal: Palette, ascii: bool) !Grid {
if (iw == 0 or ih == 0 or max_cols == 0 or max_rows == 0) return .{ .cells = try gpa.alloc(Cell, 0), .cols = 0, .rows = 0 };
- const gset: []const Glyph = if (ascii) &glyphs_ascii else &glyphs;
// contain-fit; cells are ~twice as tall as wide, so a row spans 2 width-units.
var cols = max_cols;
var rows = (max_cols * ih) / (2 * iw);
@@ -311,16 +315,28 @@ pub const GlyphArt = struct {
}
cols = std.math.clamp(cols, 1, max_cols);
rows = std.math.clamp(rows, 1, max_rows);
+ return renderRect(gpa, rgba, iw, ih, .{ .w = @intCast(iw), .h = @intCast(ih) }, cols, rows, pal, ascii);
+ }
+ /// The pixels of `src` (a rectangle of the `iw` x `ih` image) laid
+ /// over exactly `cols` x `rows` cells, whatever their shape: a
+ /// terminal's image fragment is already the size its cells are.
+ pub fn renderRect(gpa: std.mem.Allocator, rgba: []const u8, iw: usize, ih: usize, src: PixelRect, cols: usize, rows: usize, pal: Palette, ascii: bool) !Grid {
+ const x0: usize = @min(src.x, iw);
+ const y0: usize = @min(src.y, ih);
+ const sw: usize = @min(src.w, iw - x0);
+ const sh: usize = @min(src.h, ih - y0);
+ if (sw == 0 or sh == 0 or cols == 0 or rows == 0) return .{ .cells = try gpa.alloc(Cell, 0), .cols = 0, .rows = 0 };
+ const gset: []const Glyph = if (ascii) &glyphs_ascii else &glyphs;
const cells = try gpa.alloc(Cell, cols * rows);
var cy: usize = 0;
while (cy < rows) : (cy += 1) {
- const ry0 = cy * ih / rows;
- const ry1 = @max(ry0 + 1, (cy + 1) * ih / rows);
+ const ry0 = y0 + cy * sh / rows;
+ const ry1 = @max(ry0 + 1, y0 + (cy + 1) * sh / rows);
var cx: usize = 0;
while (cx < cols) : (cx += 1) {
- const rx0 = cx * iw / cols;
- const rx1 = @max(rx0 + 1, (cx + 1) * iw / cols);
+ const rx0 = x0 + cx * sw / cols;
+ const rx1 = @max(rx0 + 1, x0 + (cx + 1) * sw / cols);
var cell: [64][3]u8 = undefined;
var sy: usize = 0;
while (sy < 8) : (sy += 1) {
@@ -417,7 +433,7 @@ pub const GlyphArt = struct {
test "render: tiny image produces a grid within bounds" {
const a = std.testing.allocator;
// 2x2 checker, RGBA
- var img = [_]u8{0} ** (2 * 2 * 4);
+ var img = @as([2 * 2 * 4]u8, @splat(0));
img[0] = 255;
img[1] = 255;
img[2] = 255;
@@ -728,17 +744,131 @@ test "native geometry is total at extreme accepted aspect ratios" {
/// call once at startup / exit (stb_image's allocator shim)
pub fn start(io: std.Io, gpa: std.mem.Allocator) void {
zstbi.init(io, gpa);
+ started = true;
}
pub fn stop() void {
+ started = false;
zstbi.deinit();
}
+/// stb_image has its allocator (`start`): before, nothing of it may run.
+var started = false;
+
+extern fn stbi_info_from_memory(buffer: [*]const u8, len: c_int, x: *c_int, y: *c_int, comp: *c_int) c_int;
+
+/// PNG and JPEG are ghostty's decoders (wuffs, which ghostty-vt links for
+/// kitty graphics) wherever ghostty-vt is in the build; stb_image is then
+/// compiled without them, and without the inflate only its PNG used
+/// (build.zig, docs/shared-libs.md). Other formats, and builds without
+/// ghostty-vt, are stb_image's.
+const wuffs_images = @hasDecl(@import("pardes_config"), "wuffs_images") and @import("pardes_config").wuffs_images;
+const wuffs = if (wuffs_images) @import("wuffs") else struct {};
+
+const Format = enum { png, jpeg, other };
+
+fn format(bytes: []const u8) Format {
+ if (std.mem.startsWith(u8, bytes, "\x89PNG\r\n\x1a\n")) return .png;
+ if (bytes.len >= 3 and bytes[0] == 0xff and bytes[1] == 0xd8 and bytes[2] == 0xff) return .jpeg;
+ return .other;
+}
+
+const Size = struct { w: usize, h: usize };
+
+/// An image's size from its header alone, before anything is decoded.
+fn headerSize(bytes: []const u8) ?Size {
+ if (comptime wuffs_images) switch (format(bytes)) {
+ .png => {
+ // The signature, then IHDR first: length, type, width, height.
+ if (bytes.len < 24 or !std.mem.eql(u8, bytes[12..16], "IHDR")) return null;
+ return .{ .w = std.mem.readInt(u32, bytes[16..20], .big), .h = std.mem.readInt(u32, bytes[20..24], .big) };
+ },
+ .jpeg => return jpegSize(bytes),
+ .other => {},
+ };
+ var iw: c_int = 0;
+ var ih: c_int = 0;
+ var ic: c_int = 0;
+ if (stbi_info_from_memory(bytes.ptr, @intCast(bytes.len), &iw, &ih, &ic) != 1) return null;
+ return .{ .w = @intCast(@max(0, iw)), .h = @intCast(@max(0, ih)) };
+}
+
+/// A JPEG's size, from its first start-of-frame segment (any SOFn but the
+/// DHT, JPG and DAC markers that share their range).
+fn jpegSize(bytes: []const u8) ?Size {
+ var at: usize = 2;
+ while (at + 4 <= bytes.len) {
+ if (bytes[at] != 0xff) return null;
+ const marker = bytes[at + 1];
+ // Fill bytes, and the markers that stand alone.
+ if (marker == 0xff) {
+ at += 1;
+ continue;
+ }
+ if (marker == 0x01 or (marker >= 0xd0 and marker <= 0xd7)) {
+ at += 2;
+ continue;
+ }
+ const len = std.mem.readInt(u16, bytes[at + 2 ..][0..2], .big);
+ if (len < 2) return null;
+ const sof = marker >= 0xc0 and marker <= 0xcf and marker != 0xc4 and marker != 0xc8 and marker != 0xcc;
+ if (sof) {
+ if (at + 9 > bytes.len) return null;
+ return .{ .w = std.mem.readInt(u16, bytes[at + 7 ..][0..2], .big), .h = std.mem.readInt(u16, bytes[at + 5 ..][0..2], .big) };
+ }
+ if (marker == 0xda) return null; // scan data before any frame
+ at += 2 + len;
+ }
+ return null;
+}
+
+/// Whether `bytes` are an image `decode` can read, from its header alone.
+pub fn readable(bytes: []const u8) bool {
+ if (bytes.len == 0 or bytes.len > std.math.maxInt(c_int)) return false;
+ var w: c_int = 0;
+ var h: c_int = 0;
+ var c: c_int = 0;
+ if (!started) return true; // ponytail: no stb_image yet (a unit test), so no judging
+ if (comptime wuffs_images) if (format(bytes) != .other) return headerSize(bytes) != null;
+ return stbi_info_from_memory(bytes.ptr, @intCast(bytes.len), &w, &h, &c) == 1;
+}
+
/// decode + downscale to RGBA, gpa-owned. Returns null on any failure — the
/// pane then simply shows a blank body.
-pub fn decode(gpa: std.mem.Allocator, bytes: []const u8) ?struct { rgba: []u8, w: usize, h: usize } {
- if (bytes.len == 0) return null;
+const Decoded = struct { rgba: []u8, w: usize, h: usize };
+
+pub fn decode(gpa: std.mem.Allocator, bytes: []const u8) ?Decoded {
+ // stb_image allocates through what `start` gave it: before that, a call
+ // jumps through a null pointer (a terminal's PNG in a core no shell set up).
+ if (!started) return null;
+ if (bytes.len == 0 or bytes.len > std.math.maxInt(c_int)) return null;
+ // Bounded before decoding: a few KB of PNG can name gigapixels.
+ const size = headerSize(bytes) orelse return null;
+ const pixels = std.math.mul(usize, size.w, size.h) catch return null;
+ if (pixels > @import("memory.zig").limits.image_decode_pixels) return null;
+ if (comptime wuffs_images) switch (format(bytes)) {
+ inline .png, .jpeg => |f| {
+ const got = @field(wuffs, @tagName(f)).decode(gpa, bytes) catch return null;
+ defer gpa.free(got.data);
+ if (got.data.len != @as(usize, got.width) * got.height * 4) return null;
+ return finish(gpa, .{
+ .data = got.data,
+ .width = got.width,
+ .height = got.height,
+ .num_components = 4,
+ .bytes_per_component = 1,
+ .bytes_per_row = got.width * 4,
+ .is_hdr = false,
+ });
+ },
+ .other => {},
+ };
var img = zstbi.Image.loadFromMemory(bytes, 4) catch return null; // 4 = RGBA
defer img.deinit();
+ return finish(gpa, img);
+}
+
+/// The decoded RGBA, scaled to MAX_DIM at most, in a gpa copy.
+fn finish(gpa: std.mem.Allocator, img: zstbi.Image) ?Decoded {
var scaled: ?zstbi.Image = null;
defer if (scaled) |*s| s.deinit();
const longest = @max(img.width, img.height);
@@ -751,3 +881,306 @@ pub fn decode(gpa: std.mem.Allocator, bytes: []const u8) ?struct { rgba: []u8, w
const rgba = gpa.dupe(u8, src.data) catch return null;
return .{ .rgba = rgba, .w = src.width, .h = src.height };
}
+
+test "PNG and JPEG decode through wuffs, sized from their headers first; other formats through stb_image" {
+ const gpa = std.testing.allocator;
+ start(std.testing.io, gpa);
+ defer stop();
+ const dec = std.base64.standard.Decoder;
+ const Fixture = struct { b64: []const u8, w: usize, h: usize, rgb: [3]u8, tolerance: u8 };
+ const fixtures = [_]Fixture{
+ // 4x2, red left, blue right (a hand-built PNG).
+ .{ .b64 = "iVBORw0KGgoAAAANSUhEUgAAAAQAAAACCAIAAADwyuo0AAAAE0lEQVR4nGP4z8AARGDiPwMyBwBnsgf5Q2OaZwAAAABJRU5ErkJggg==", .w = 4, .h = 2, .rgb = .{ 255, 0, 0 }, .tolerance = 0 },
+ // 16x8 of (200,30,30), baseline and progressive (Pillow, quality 95).
+ .{ .b64 = "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAIBAQEBAQIBAQECAgICAgQDAgICAgUEBAMEBgUGBgYFBgYGBwkIBgcJBwYGCAsICQoKCgoKBggLDAsKDAkKCgr/2wBDAQICAgICAgUDAwUKBwYHCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgr/wAARCAAIABADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD5Dooor8LP9VD/2Q==", .w = 16, .h = 8, .rgb = .{ 200, 30, 30 }, .tolerance = 6 },
+ .{ .b64 = "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAIBAQEBAQIBAQECAgICAgQDAgICAgUEBAMEBgUGBgYFBgYGBwkIBgcJBwYGCAsICQoKCgoKBggLDAsKDAkKCgr/2wBDAQICAgICAgUDAwUKBwYHCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgr/wgARCAAIABADASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAf/xAAVAQEBAAAAAAAAAAAAAAAAAAAGCP/aAAwDAQACEAMQAAABkIC1V//EABQQAQAAAAAAAAAAAAAAAAAAABD/2gAIAQEAAQUCP//EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQMBAT8Bf//EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQIBAT8Bf//EABQQAQAAAAAAAAAAAAAAAAAAABD/2gAIAQEABj8CP//EABQQAQAAAAAAAAAAAAAAAAAAABD/2gAIAQEAAT8hP//aAAwDAQACAAMAAAAQA//EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQMBAT8Qf//EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQIBAT8Qf//EABQQAQAAAAAAAAAAAAAAAAAAABD/2gAIAQEAAT8QP//Z", .w = 16, .h = 8, .rgb = .{ 200, 30, 30 }, .tolerance = 6 },
+ };
+ for (fixtures) |f| {
+ const bytes = try gpa.alloc(u8, try dec.calcSizeForSlice(f.b64));
+ defer gpa.free(bytes);
+ try dec.decode(bytes, f.b64);
+ try std.testing.expect(readable(bytes));
+ const size = headerSize(bytes).?;
+ try std.testing.expectEqual(Size{ .w = f.w, .h = f.h }, size);
+ const got = decode(gpa, bytes) orelse return error.NotDecoded;
+ defer gpa.free(got.rgba);
+ try std.testing.expectEqual(f.w, got.w);
+ try std.testing.expectEqual(f.h, got.h);
+ for (got.rgba[0..3], f.rgb) |have, want| try std.testing.expect(@max(have, want) - @min(have, want) <= f.tolerance);
+ try std.testing.expectEqual(@as(u8, 255), got.rgba[3]);
+ }
+ // A PPM still goes through stb_image.
+ const ppm = "P6\n2 1\n255\n\x0d\x4d\xe7\x0d\x4d\xe7";
+ try std.testing.expectEqual(Format.other, format(ppm));
+ const got = decode(gpa, ppm) orelse return error.NotDecoded;
+ defer gpa.free(got.rgba);
+ try std.testing.expectEqualSlices(u8, &.{ 0x0d, 0x4d, 0xe7, 255 }, got.rgba[0..4]);
+ // Truncated headers are no image, never a read past the end.
+ try std.testing.expect(headerSize("\x89PNG\r\n\x1a\n\x00\x00") == null);
+ try std.testing.expect(headerSize("\xff\xd8\xff\xe0\x00\x10JFIF") == null);
+ try std.testing.expect(decode(gpa, "\xff\xd8\xff\xe0\x00\x10JFIF") == null);
+}
+
+// ---- the image pane ----
+
+const GridKey = struct {
+ cols: u16 = 0,
+ rows: u16 = 0,
+ palette: PaletteMode = .commodore,
+ ascii: bool = true,
+};
+
+pub const State = struct {
+ path: []u8,
+ glyph_art: bool = false,
+ pmode: PaletteMode = .commodore,
+ ascii: bool = true,
+ tried: bool = false,
+ rgba: []u8 = &.{},
+ iw: usize = 0,
+ ih: usize = 0,
+ /// Dump-loaded bytes, decoded lazily by the same path as a disk image.
+ raw: []u8 = &.{},
+ grid: GlyphArt.Grid = .{ .cells = &.{}, .cols = 0, .rows = 0 },
+ grid_key: GridKey = .{},
+ /// The decode under way off the loop (ensureDecoded), and its answer.
+ decoder: ?std.Thread = null,
+ decoded: std.atomic.Value(bool) = .init(false),
+ answer: ?Decoded = null,
+
+ pub fn deinit(state: *State, gpa: std.mem.Allocator) void {
+ if (state.decoder) |t| t.join();
+ if (state.answer) |a| gpa.free(a.rgba);
+ gpa.free(state.path);
+ if (state.rgba.len > 0) gpa.free(state.rgba);
+ if (state.raw.len > 0) gpa.free(state.raw);
+ if (state.grid.cells.len > 0) gpa.free(state.grid.cells);
+ state.* = undefined;
+ }
+};
+
+/// Construct an image pane from a path and optionally transferred dump bytes.
+/// `raw` must be image_gpa-owned and ownership transfers only on success.
+/// Without them the file is read here, not at the first draw: a draw
+/// must not go out into the host (`pardes.turn`), and the path may be a
+/// mount this editor serves. A file that cannot be read draws blank.
+pub fn create(p: *pardes.Pardes, id: usize, path: []const u8, raw: []u8) !*pardes.Pane {
+ var bytes = raw;
+ var read_here = false;
+ if (bytes.len == 0) {
+ // The slot stays ours across the read: another request may
+ // make a pane meanwhile.
+ p.reserved_slots[id] = true;
+ defer p.reserved_slots[id] = false;
+ if (filesystem.read(p, path)) |from_disk| {
+ defer p.gpa.free(from_disk);
+ bytes = try p.image_gpa.dupe(u8, from_disk);
+ read_here = true;
+ } else |_| {}
+ }
+ errdefer if (read_here) p.image_gpa.free(bytes);
+ const path_copy = try p.image_gpa.dupe(u8, path);
+ errdefer p.image_gpa.free(path_copy);
+ const pane = try p.newDocPane(id);
+ pane.image = .{ .path = path_copy, .raw = bytes };
+ return pane;
+}
+
+/// Serialize the binary image record used by images and, for dump-schema
+/// compatibility, PDFs. Common pane metadata is supplied by the core.
+pub fn dumpPane(
+ p: *pardes.Pardes,
+ arena: std.mem.Allocator,
+ pane: *const pardes.Pane,
+ tag: []const u8,
+ body: []const u8,
+ scroll: usize,
+ path: []const u8,
+ raw: []const u8,
+) !dump.Pane {
+ // A picture or PDF on disk is read from there at Restore, as a clean
+ // file's text is: the dump keeps only the bytes of one that is not
+ // (megabytes of a PDF per dump, and a stale copy, otherwise).
+ _ = p;
+ const on_disk = if (comptime !pardes.hosted) false else if (filesystem.localPath(path)) |local| @import("exec.zig").kindOf(local) == .file else false;
+ const bytes: []const u8 = if (on_disk) &.{} else raw;
+ return .{
+ .kind = .image,
+ .tag = tag,
+ .body = body,
+ .scroll = scroll,
+ .cols = pane.cols,
+ .rows = pane.rows,
+ .vweight = pane.vweight,
+ .collapsed = pane.collapsed,
+ .image = .{
+ .path = path,
+ .bytes_b64 = if (bytes.len > 0) try dump.encodeBytes(arena, bytes) else "",
+ .petscii = if (pane.image) |state| state.glyph_art else false,
+ .palette = if (pane.image) |state| switch (state.pmode) {
+ .commodore => .commodore,
+ .terminal => .terminal,
+ } else .commodore,
+ .ascii = if (pane.image) |state| state.ascii else true,
+ .pdf_fit = if (comptime pardes.pdf_enabled) (if (pane.pdf) |pv| @tagName(pv.fit) else "") else "",
+ .pdf_tint = if (comptime pardes.pdf_enabled) (if (pane.pdf) |pv| @tagName(pv.tint) else "") else "",
+ },
+ };
+}
+
+pub fn restore(p: *pardes.Pardes, id: usize, src: dump.Pane) !*pardes.Pane {
+ const saved = src.image.?;
+ var raw: []u8 = if (saved.bytes_b64.len > 0)
+ try dump.decodeBytes(p.image_gpa, saved.bytes_b64)
+ else
+ &.{};
+ errdefer if (raw.len > 0) p.image_gpa.free(raw);
+ const pane = try create(p, id, saved.path, raw);
+ raw = &.{};
+ pane.image.?.glyph_art = saved.petscii;
+ pane.image.?.pmode = switch (saved.palette) {
+ .commodore => .commodore,
+ .terminal => .terminal,
+ };
+ pane.image.?.ascii = saved.ascii;
+ pane.cols = @max(1, src.cols);
+ pane.rows = @max(1, src.rows);
+ return pane;
+}
+
+pub fn toggleGlyphArt(state: *State) void {
+ state.glyph_art = !state.glyph_art;
+}
+
+pub fn togglePalette(state: *State) void {
+ state.pmode = if (state.pmode == .commodore) .terminal else .commodore;
+}
+
+pub fn toggleAscii(state: *State) void {
+ state.ascii = !state.ascii;
+}
+
+/// Image renderer choices are pane-local, not global Config values. Keep them
+/// queryable where they apply: the live tag beside the image's path.
+/// `glyphs`: whether the picture is drawn as glyph art, which a terminal
+/// with no graphics does whatever `glyph_art` says.
+pub fn tagPrefix(arena: std.mem.Allocator, state: *const State, glyphs: bool) ![]u8 {
+ return std.fmt.allocPrint(
+ arena,
+ "{s} petscii:{s} palette:{s} ascii:{s} {s}",
+ .{
+ config.tag_image,
+ if (glyphs) "on" else "off",
+ @tagName(state.pmode),
+ if (state.ascii) "on" else "off",
+ state.path,
+ },
+ );
+}
+
+/// The picture decoded off the loop: the first draw starts a thread and
+/// draws the pane without it (its tag and frame at once); the frames after
+/// it look (Pardes.nextWake asks for them) and the picture lands on the
+/// first one after the decode (80 ms in ReleaseSafe, 290 in Debug, for the
+/// docs' screenshot: all of it once on the frame before).
+/// ponytail: a thread a picture; a pool if many open at once.
+fn ensureDecoded(p: *pardes.Pardes, state: *State) void {
+ if (state.decoder) |t| {
+ if (!state.decoded.load(.acquire)) return;
+ t.join();
+ state.decoder = null;
+ }
+ if (state.answer) |decoded| {
+ state.answer = null;
+ state.rgba = decoded.rgba;
+ state.iw = decoded.w;
+ state.ih = decoded.h;
+ }
+ if (state.tried) return;
+ state.tried = true;
+ if (state.raw.len == 0) return; // nothing was readable at open
+ const Work = struct {
+ fn run(gpa: std.mem.Allocator, st: *State) void {
+ st.answer = decode(gpa, st.raw);
+ st.decoded.store(true, .release);
+ }
+ };
+ if (comptime pardes.hosted and !builtin.is_test) {
+ if (std.Thread.spawn(.{}, Work.run, .{ p.image_gpa, state })) |t| {
+ state.decoder = t;
+ return;
+ } else |_| {}
+ }
+ Work.run(p.image_gpa, state);
+ ensureDecoded(p, state);
+}
+
+fn ensureGrid(p: *pardes.Pardes, state: *State, cols: u16, rows: u16) void {
+ const wanted = GridKey{ .cols = cols, .rows = rows, .palette = state.pmode, .ascii = state.ascii };
+ if (state.grid.cells.len > 0 and std.meta.eql(state.grid_key, wanted)) return;
+ if (state.grid.cells.len > 0) p.image_gpa.free(state.grid.cells);
+ const palette = switch (state.pmode) {
+ .commodore => GlyphArt.commodore,
+ .terminal => terminal_palette,
+ };
+ state.grid = GlyphArt.render(
+ p.image_gpa,
+ state.rgba,
+ state.iw,
+ state.ih,
+ cols,
+ rows,
+ palette,
+ state.ascii,
+ ) catch .{ .cells = &.{}, .cols = 0, .rows = 0 };
+ state.grid_key = wanted;
+}
+
+pub fn draw(
+ p: *pardes.Pardes,
+ s: *pardes.Surface,
+ state: *State,
+ pane_id: u8,
+ serial: u32,
+ x: u16,
+ y: u16,
+ cols: u16,
+ rows: u16,
+) void {
+ ensureDecoded(p, state);
+ if (state.rgba.len == 0 or cols == 0 or rows == 0) return;
+ if (!state.glyph_art and p.native_images) {
+ _ = p.appendImagePlace(.{
+ .pane = pane_id,
+ .serial = serial,
+ .x = x,
+ .y = y,
+ .w = cols,
+ .h = rows,
+ .rgba = state.rgba,
+ .iw = state.iw,
+ .ih = state.ih,
+ });
+ return;
+ }
+
+ ensureGrid(p, state, cols, rows);
+ if (state.grid.cells.len == 0) return;
+ const offx = if (cols > state.grid.cols) (@as(usize, cols) - state.grid.cols) / 2 else 0;
+ const offy = if (rows > state.grid.rows) (@as(usize, rows) - state.grid.rows) / 2 else 0;
+ for (0..state.grid.rows) |cy| for (0..state.grid.cols) |cx| {
+ const cell = &state.grid.cells[cy * state.grid.cols + cx];
+ const fg: pardes.Color = switch (state.pmode) {
+ .commodore => .{ .rgb = GlyphArt.commodore[cell.fg] },
+ .terminal => .{ .index = cell.fg },
+ };
+ const bg: pardes.Color = switch (state.pmode) {
+ .commodore => .{ .rgb = GlyphArt.commodore[cell.bg] },
+ .terminal => .{ .index = cell.bg },
+ };
+ const sx = x + @as(u16, @intCast(offx + cx));
+ const sy = y + @as(u16, @intCast(offy + cy));
+ if (sx < s.cols and sy < s.rows)
+ s.set(sx, sy, cell.glyph[0..cell.glyph_len], .{ .fg = fg, .bg = bg });
+ };
+}