@@ -0,0 +1,144 @@
1+const std = @import("std");
2+const message_mod = @import("../message.zig");
3+
4+const placeholder_cp: u21 = 0x10EEEE;
5+const chunk_size = 4096;
6+const header_b64_bytes = 32;
7+const header_bytes = 24;
8+const max_placeholder_rows = 255;
9+const placeholder_id_mask = 0xFF_FFFF;
10+
11+/// Kitty row/column diacritics, indexed by value (rowcolumn-diacritics.txt).
12+const diacritics = [_]u21{
13+ 0x0305, 0x030D, 0x030E, 0x0310, 0x0312, 0x033D, 0x033E, 0x033F,
14+ 0x0346, 0x034A, 0x034B, 0x034C, 0x0350, 0x0351, 0x0352, 0x0357,
15+ 0x035B, 0x0363, 0x0364, 0x0365, 0x0366, 0x0367, 0x0368, 0x0369,
16+ 0x036A, 0x036B, 0x036C, 0x036D, 0x036E, 0x036F, 0x0483, 0x0484,
17+ 0x0485, 0x0486, 0x0487, 0x0592, 0x0593, 0x0594, 0x0595, 0x0597,
18+ 0x0598, 0x0599, 0x059C, 0x059D, 0x059E, 0x059F, 0x05A0, 0x05A1,
19+ 0x05A8, 0x05A9, 0x05AB, 0x05AC, 0x05AF, 0x05C4, 0x0610, 0x0611,
20+ 0x0612, 0x0613, 0x0614, 0x0615, 0x0616, 0x0617, 0x0657, 0x0658,
21+ 0x0659, 0x065A, 0x065B, 0x065D, 0x065E, 0x06D6, 0x06D7, 0x06D8,
22+ 0x06D9, 0x06DA, 0x06DB, 0x06DC, 0x06DF, 0x06E0, 0x06E1, 0x06E2,
23+ 0x06E4, 0x06E7, 0x06E8, 0x06EB, 0x06EC, 0x0730, 0x0732, 0x0733,
24+ 0x0735, 0x0736, 0x073A, 0x073D, 0x073F, 0x0740, 0x0741, 0x0743,
25+ 0x0745, 0x0747, 0x0749, 0x074A, 0x07EB, 0x07EC, 0x07ED, 0x07EE,
26+ 0x07EF, 0x07F0, 0x07F1, 0x07F3, 0x0816, 0x0817, 0x0818, 0x0819,
27+ 0x081B, 0x081C, 0x081D, 0x081E, 0x081F, 0x0820, 0x0821, 0x0822,
28+ 0x0823, 0x0825, 0x0826, 0x0827, 0x0829, 0x082A, 0x082B, 0x082C,
29+ 0x082D, 0x0951, 0x0953, 0x0954, 0x0F82, 0x0F83, 0x0F86, 0x0F87,
30+ 0x135D, 0x135E, 0x135F, 0x17DD, 0x193A, 0x1A17, 0x1A75, 0x1A76,
31+ 0x1A77, 0x1A78, 0x1A79, 0x1A7A, 0x1A7B, 0x1A7C, 0x1B6B, 0x1B6D,
32+ 0x1B6E, 0x1B6F, 0x1B70, 0x1B71, 0x1B72, 0x1B73, 0x1CD0, 0x1CD1,
33+ 0x1CD2, 0x1CDA, 0x1CDB, 0x1CE0, 0x1DC0, 0x1DC1, 0x1DC3, 0x1DC4,
34+ 0x1DC5, 0x1DC6, 0x1DC7, 0x1DC8, 0x1DC9, 0x1DCB, 0x1DCC, 0x1DD1,
35+ 0x1DD2, 0x1DD3, 0x1DD4, 0x1DD5, 0x1DD6, 0x1DD7, 0x1DD8, 0x1DD9,
36+ 0x1DDA, 0x1DDB, 0x1DDC, 0x1DDD, 0x1DDE, 0x1DDF, 0x1DE0, 0x1DE1,
37+ 0x1DE2, 0x1DE3, 0x1DE4, 0x1DE5, 0x1DE6, 0x1DFE, 0x20D0, 0x20D1,
38+ 0x20D4, 0x20D5, 0x20D6, 0x20D7, 0x20DB, 0x20DC, 0x20E1, 0x20E7,
39+ 0x20E9, 0x20F0, 0x2CEF, 0x2CF0, 0x2CF1, 0x2DE0, 0x2DE1, 0x2DE2,
40+ 0x2DE3, 0x2DE4, 0x2DE5, 0x2DE6, 0x2DE7, 0x2DE8, 0x2DE9, 0x2DEA,
41+ 0x2DEB, 0x2DEC, 0x2DED, 0x2DEE, 0x2DEF, 0x2DF0, 0x2DF1, 0x2DF2,
42+ 0x2DF3, 0x2DF4, 0x2DF5, 0x2DF6, 0x2DF7, 0x2DF8, 0x2DF9, 0x2DFA,
43+ 0x2DFB, 0x2DFC, 0x2DFD, 0x2DFE, 0x2DFF, 0xA66F, 0xA67C, 0xA67D,
44+ 0xA6F0, 0xA6F1, 0xA8E0, 0xA8E1, 0xA8E2, 0xA8E3, 0xA8E4, 0xA8E5,
45+};
46+
47+fn be32(b: []const u8) u32 {
48+ return (@as(u32, b[0]) << 24) | (@as(u32, b[1]) << 16) | (@as(u32, b[2]) << 8) | b[3];
49+}
50+
51+/// Width and height from the PNG IHDR chunk, decoding only the header.
52+fn pngSize(data: []const u8) ?struct { w: u32, h: u32 } {
53+ if (data.len < header_b64_bytes) return null;
54+ var head: [header_bytes]u8 = undefined;
55+ std.base64.standard.Decoder.decode(&head, data[0..header_b64_bytes]) catch return null;
56+ if (!std.mem.eql(u8, head[0..8], "\x89PNG\r\n\x1a\n")) return null;
57+ if (!std.mem.eql(u8, head[12..16], "IHDR")) return null;
58+ const w = be32(head[16..20]);
59+ const h = be32(head[20..24]);
60+ if (w == 0 or h == 0) return null;
61+ return .{ .w = w, .h = h };
62+}
63+
64+/// A stable, unique-enough image id whose low 24 bits address the placeholder
65+/// foreground color. `salt` varies per commit, `seq` per image.
66+pub fn imageId(salt: u8, seq: u32) u32 {
67+ return (@as(u32, salt) << 16) | (seq & 0xFFFF);
68+}
69+
70+fn writeCp(w: *std.Io.Writer, cp: u21) !void {
71+ var buf: [4]u8 = undefined;
72+ const n = std.unicode.utf8Encode(cp, &buf) catch unreachable;
73+ try w.writeAll(buf[0..n]);
74+}
75+
76+/// Transmit the base64 PNG payload to the terminal in `chunk_size` byte chunks.
77+/// `chunk_size` is a multiple of 4 so every chunk is valid base64.
78+fn transmit(w: *std.Io.Writer, id: u32, data: []const u8) !void {
79+ var off: usize = 0;
80+ var first = true;
81+ while (off < data.len) {
82+ const end = @min(off + chunk_size, data.len);
83+ const more = end < data.len;
84+ if (first) {
85+ try w.print("\x1b_Ga=t,f=100,i={d},q=2", .{id});
86+ first = false;
87+ if (more) try w.writeAll(",m=1");
88+ } else if (more) {
89+ try w.writeAll("\x1b_Gm=1");
90+ } else {
91+ try w.writeAll("\x1b_G");
92+ }
93+ try w.writeAll(";");
94+ try w.writeAll(data[off..end]);
95+ try w.writeAll("\x1b\\");
96+ off = end;
97+ }
98+}
99+
100+/// Transmit the PNG, place it virtually, and lay out the Unicode placeholder
101+/// grid that displays it: `cols` x `rows` cells, each row tagged with its index.
102+fn emit(w: *std.Io.Writer, id: u32, cols: usize, rows: usize, data: []const u8) !void {
103+ try transmit(w, id, data);
104+ try w.print("\x1b_Ga=p,U=1,i={d},c={d},r={d},q=2\x1b\\", .{ id, cols, rows });
105+ const r: u8 = @intCast((id >> 16) & 0xFF);
106+ const g: u8 = @intCast((id >> 8) & 0xFF);
107+ const b: u8 = @intCast(id & 0xFF);
108+ var row: usize = 0;
109+ while (row < rows) : (row += 1) {
110+ try w.print("\x1b[38;2;{d};{d};{d}m", .{ r, g, b });
111+ var col: usize = 0;
112+ while (col < cols) : (col += 1) {
113+ try writeCp(w, placeholder_cp);
114+ // The first cell of each row carries the row; the rest inherit.
115+ if (col == 0) try writeCp(w, diacritics[row]);
116+ }
117+ try w.writeAll("\x1b[39m\r\n");
118+ }
119+}
120+
121+/// Build the kitty graphics sequence that transmits a PNG, creates a virtual
122+/// placement for it, and lays out the Unicode placeholder grid that displays it.
123+/// Sized to fit `avail_cols` columns and at most `max_rows` rows. Returns null
124+/// when the image is not a PNG whose size can be read.
125+pub fn block(a: std.mem.Allocator, id: u32, image: message_mod.ImageContent, avail_cols: usize, max_rows: usize, cell_w: usize, cell_h: usize) ?[]const u8 {
126+ if (!std.mem.eql(u8, image.mime_type, "image/png")) return null;
127+ const size = pngSize(image.data) orelse return null;
128+ if (avail_cols == 0 or max_rows == 0 or cell_w == 0 or cell_h == 0) return null;
129+ const img_w: f64 = @floatFromInt(size.w);
130+ const img_h: f64 = @floatFromInt(size.h);
131+ const fit_w: f64 = @floatFromInt(avail_cols * cell_w);
132+ const row_cap = @min(max_rows, max_placeholder_rows);
133+ const fit_h: f64 = @floatFromInt(row_cap * cell_h);
134+ const scale = @min(@min(fit_w / img_w, fit_h / img_h), 1);
135+ const cols: usize = @min(@max(1, @as(usize, @intFromFloat(@round(img_w * scale / @as(f64, @floatFromInt(cell_w)))))), avail_cols);
136+ const rows: usize = @min(@max(1, @as(usize, @intFromFloat(@round(img_h * scale / @as(f64, @floatFromInt(cell_h)))))), row_cap);
137+
138+ var out: std.Io.Writer.Allocating = .init(a);
139+ emit(&out.writer, id & placeholder_id_mask, cols, rows, image.data) catch {
140+ out.deinit();
141+ return null;
142+ };
143+ return out.written();
144+}