summaryrefslogtreecommitdiff
path: root/src/screen_state.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/screen_state.zig')
-rw-r--r--src/screen_state.zig197
1 files changed, 197 insertions, 0 deletions
diff --git a/src/screen_state.zig b/src/screen_state.zig
index 53288c7e..07d4153b 100644
--- a/src/screen_state.zig
+++ b/src/screen_state.zig
@@ -1292,3 +1292,200 @@ test "a replica's terminal pane draws as its authority's does" {
};
}
}
+
+// ---- a pane of a kind, as a Shadow (architecture ยง16.5) ----
+//
+// A replica's core has no code for a library's kind: such a pane is drawn
+// from the authority's frame of it, painted at the size the peer's view
+// gives it. A frame crosses as its size, the prefix the kind gave it and
+// whether it placed a picture, each row by its hash (with its cells when
+// the peer's row there is another), then each placement, with its raster's
+// bytes when the peer was not sent that key with the frame before. The
+// stream is ordered and loses nothing, so what the authority last sent a
+// peer is what the peer holds.
+
+const Kind = @import("Kind.zig");
+const Cell = Kind.c.pa_cell;
+const Place = Kind.c.pa_placement;
+
+/// A replica's frame of a pane of a kind: what Kind.draw draws for it.
+pub const Shadow = struct {
+ cols: u16 = 0,
+ rows: u16 = 0,
+ cells: []Cell = &.{},
+ hashes: []Hash = &.{},
+ places: std.ArrayList(Place) = .empty,
+ /// Each placement's raster, owned, beside it.
+ rasters: std.ArrayList([]u8) = .empty,
+ prefix: Kind.Buf(96) = .{},
+ placed: bool = false,
+
+ pub fn deinit(sh: *Shadow, gpa: std.mem.Allocator) void {
+ gpa.free(sh.cells);
+ gpa.free(sh.hashes);
+ for (sh.rasters.items) |r| gpa.free(r);
+ sh.rasters.deinit(gpa);
+ sh.places.deinit(gpa);
+ gpa.destroy(sh);
+ }
+
+ /// A frame message applied (`encodeShadow`'s).
+ pub fn apply(sh: *Shadow, gpa: std.mem.Allocator, bytes: []const u8) !void {
+ var r: std.Io.Reader = .fixed(bytes);
+ const cols = try r.takeInt(u16, .little);
+ const rows = try r.takeInt(u16, .little);
+ if (cols != sh.cols or rows != sh.rows) {
+ gpa.free(sh.cells);
+ gpa.free(sh.hashes);
+ sh.cells = try gpa.alloc(Cell, @as(usize, cols) * rows);
+ sh.hashes = try gpa.alloc(Hash, rows);
+ @memset(std.mem.sliceAsBytes(sh.cells), 0);
+ @memset(sh.hashes, 0);
+ sh.cols = cols;
+ sh.rows = rows;
+ }
+ sh.placed = try r.takeByte() != 0;
+ sh.prefix.set(try r.take(try r.takeByte()));
+ for (0..rows) |y| {
+ sh.hashes[y] = try r.takeInt(u64, .little);
+ if (try r.takeByte() == 0) continue;
+ for (sh.cells[y * cols ..][0..cols]) |*c| {
+ @memcpy(&c.text, try r.take(8));
+ c.fg = try r.takeInt(u32, .little);
+ c.bg = try r.takeInt(u32, .little);
+ c.attrs = try r.takeInt(u16, .little);
+ c.len = try r.takeByte();
+ c.flags = try r.takeByte();
+ }
+ }
+ var places: std.ArrayList(Place) = .empty;
+ errdefer places.deinit(gpa);
+ var rasters: std.ArrayList([]u8) = .empty;
+ defer {
+ for (sh.rasters.items) |old| if (for (rasters.items) |kept| {
+ if (kept.ptr == old.ptr) break false;
+ } else true) gpa.free(old);
+ sh.rasters.deinit(gpa);
+ sh.rasters = rasters;
+ sh.places.deinit(gpa);
+ sh.places = places;
+ }
+ for (0..try r.takeByte()) |_| {
+ var pl = std.mem.zeroes(Place);
+ pl.w = try r.takeInt(u32, .little);
+ pl.h = try r.takeInt(u32, .little);
+ inline for (.{ &pl.src.x, &pl.src.y, &pl.src.w, &pl.src.h, &pl.at.x, &pl.at.y, &pl.at.w, &pl.at.h }) |f| f.* = try r.takeInt(u32, .little);
+ inline for (.{ &pl.dst.x, &pl.dst.y, &pl.dst.w, &pl.dst.h }) |f| f.* = try r.takeInt(u16, .little);
+ pl.key = try r.takeInt(u64, .little);
+ const raster = if (try r.takeByte() != 0) try gpa.dupe(u8, try r.take(@as(usize, pl.w) * pl.h * 4)) else for (sh.places.items, sh.rasters.items) |old, held| {
+ if (old.key == pl.key) break held;
+ } else return error.BadShadow;
+ pl.rgba = raster.ptr;
+ try rasters.append(gpa, raster);
+ try places.append(gpa, pl);
+ }
+ }
+};
+
+/// What the authority last sent one peer of a pane of a kind: its rows'
+/// hashes and its placements' keys.
+pub const ShadowSent = struct {
+ serial: u32 = 0,
+ cols: u16 = 0,
+ hashes: std.ArrayList(Hash) = .empty,
+ keys: std.ArrayList(u64) = .empty,
+ prefix: Hash = 0,
+
+ pub fn deinit(s: *ShadowSent, gpa: std.mem.Allocator) void {
+ s.hashes.deinit(gpa);
+ s.keys.deinit(gpa);
+ s.* = .{};
+ }
+};
+
+/// Frame `f` of a pane (its prefix and `placed` from its slot) for a peer
+/// that was last sent `sent`: false, and nothing written, when it holds
+/// this frame already.
+pub fn encodeShadow(gpa: std.mem.Allocator, sent: *ShadowSent, f: *const Kind.Frame, prefix: []const u8, placed: bool, w: *std.Io.Writer) !bool {
+ var hashes: std.ArrayList(Hash) = .empty;
+ errdefer hashes.deinit(gpa);
+ for (0..f.rows) |y| try hashes.append(gpa, std.hash.Wyhash.hash(0, std.mem.sliceAsBytes(f.cells[y * f.cols ..][0..f.cols])));
+ const places = f.places[0..f.n];
+ const prefix_hash = std.hash.Wyhash.hash(@intFromBool(placed), prefix);
+ var same = sent.cols == f.cols and std.mem.eql(Hash, sent.hashes.items, hashes.items) and sent.prefix == prefix_hash and sent.keys.items.len == places.len;
+ if (same) for (places, sent.keys.items) |pl, k| {
+ if (pl.key != k) same = false;
+ };
+ if (same) {
+ hashes.deinit(gpa);
+ return false;
+ }
+ try w.writeInt(u16, f.cols, .little);
+ try w.writeInt(u16, f.rows, .little);
+ try w.writeByte(@intFromBool(placed));
+ try w.writeByte(@intCast(@min(prefix.len, 96)));
+ try w.writeAll(prefix[0..@min(prefix.len, 96)]);
+ for (hashes.items, 0..) |h, y| {
+ try w.writeInt(u64, h, .little);
+ const held = sent.cols == f.cols and y < sent.hashes.items.len and sent.hashes.items[y] == h;
+ try w.writeByte(@intFromBool(!held));
+ if (!held) for (f.cells[y * f.cols ..][0..f.cols]) |*c| {
+ try w.writeAll(&c.text);
+ try w.writeInt(u32, c.fg, .little);
+ try w.writeInt(u32, c.bg, .little);
+ try w.writeInt(u16, c.attrs, .little);
+ try w.writeByte(c.len);
+ try w.writeByte(c.flags);
+ };
+ }
+ try w.writeByte(@intCast(places.len));
+ for (places) |pl| {
+ try w.writeInt(u32, pl.w, .little);
+ try w.writeInt(u32, pl.h, .little);
+ inline for (.{ pl.src.x, pl.src.y, pl.src.w, pl.src.h, pl.at.x, pl.at.y, pl.at.w, pl.at.h }) |v| try w.writeInt(u32, v, .little);
+ inline for (.{ pl.dst.x, pl.dst.y, pl.dst.w, pl.dst.h }) |v| try w.writeInt(u16, v, .little);
+ try w.writeInt(u64, pl.key, .little);
+ const held = std.mem.indexOfScalar(u64, sent.keys.items, pl.key) != null;
+ try w.writeByte(@intFromBool(!held));
+ if (!held) try w.writeAll(pl.rgba[0 .. @as(usize, pl.w) * pl.h * 4]);
+ }
+ sent.hashes.deinit(gpa);
+ sent.hashes = hashes;
+ sent.cols = f.cols;
+ sent.prefix = prefix_hash;
+ sent.keys.clearRetainingCapacity();
+ for (places) |pl| try sent.keys.append(gpa, pl.key);
+ return true;
+}
+
+test "a pane of a kind crosses as its frame, a row or a raster the peer holds as its hash" {
+ const gpa = std.testing.allocator;
+ var cells: [3 * 2]Cell = @splat(std.mem.zeroes(Cell));
+ cells[0] = .{ .text = "a".* ++ @as([7]u8, @splat(0)), .fg = 1, .bg = 2, .attrs = 0, .len = 1, .flags = Kind.c.PA_PAINTED };
+ var pixels: [4]u8 = .{ 1, 2, 3, 4 };
+ var f: Kind.Frame = .{ .cells = &cells, .cols = 3, .rows = 2, .n = 1 };
+ f.buf[0] = std.mem.zeroInit(Place, .{ .rgba = &pixels, .w = 1, .h = 1, .key = 9 });
+ f.places = &f.buf;
+ var sent: ShadowSent = .{};
+ defer sent.deinit(gpa);
+ const sh = try gpa.create(Shadow);
+ sh.* = .{};
+ defer sh.deinit(gpa);
+ var out: std.Io.Writer.Allocating = .init(gpa);
+ defer out.deinit();
+ try std.testing.expect(try encodeShadow(gpa, &sent, &f, "fake", true, &out.writer));
+ try sh.apply(gpa, out.written());
+ try std.testing.expectEqualStrings("a", sh.cells[0].text[0..1]);
+ try std.testing.expectEqualStrings("fake", sh.prefix.slice());
+ try std.testing.expectEqual(@as(u8, 3), sh.rasters.items[0][2]);
+ // The same frame again: nothing to send.
+ out.clearRetainingCapacity();
+ try std.testing.expect(!try encodeShadow(gpa, &sent, &f, "fake", true, &out.writer));
+ // A cell of the second row moves: the first row and the raster go as hashes.
+ cells[4].flags = Kind.c.PA_PAINTED;
+ try std.testing.expect(try encodeShadow(gpa, &sent, &f, "fake", true, &out.writer));
+ try std.testing.expect(out.written().len < 20 + 2 * 9 + 3 * 20 + 60);
+ try sh.apply(gpa, out.written());
+ try std.testing.expectEqual(@as(u8, Kind.c.PA_PAINTED), sh.cells[4].flags);
+ try std.testing.expectEqual(@as(u8, 3), sh.rasters.items[0][2]);
+}