media: Update to zig 0.16.0, harden tests and add test build step

packages/media/src/stbi.zig

@@ -5,17 +5,20 @@ const image = @import("image.zig");
 const vm = @import("vecmath");
 
 allocator: std.mem.Allocator,
+io: std.Io,
+
+mutex: std.Io.Mutex = .init,
 allocations: std.AutoHashMapUnmanaged(*anyopaque, usize) = .empty,
-mutex: std.Thread.Mutex = .{},
 allocated_bytes: usize = 0,
 
 const alignment: std.mem.Alignment = .@"16";
 const VoidPtr = ?*align(alignment.toByteUnits()) anyopaque;
 const log = std.log.scoped(.stbi);
 
-pub fn init(allocator: std.mem.Allocator) Self {
+pub fn init(allocator: std.mem.Allocator, io: std.Io) Self {
     return .{
         .allocator = allocator,
+        .io = io,
     };
 }
 
@@ -76,7 +79,7 @@ pub fn loadStaticBuf(self: *Self, comptime W: u32, comptime H: u32, buf: []const
     return .{ .data = @as(*const [W * H]vm.Color, @ptrCast(@alignCast(res))).* };
 }
 
-pub fn loadStaticIo(self: *Self, comptime W: u32, comptime H: u32, reader: *std.io.Reader) !image.Static(W, H) {
+pub fn loadStaticIo(self: *Self, comptime W: u32, comptime H: u32, reader: *std.Io.Reader) !image.Static(W, H) {
     current_self = self;
     defer current_self = undefined;
 
@@ -109,7 +112,7 @@ pub fn loadDynamicBuf(self: *Self, buf: []const u8) !image.Dynamic {
 }
 
 /// On success, must free memory by calling `freeDynamic` method.
-pub fn loadDynamicIo(self: *Self, reader: *std.io.Reader) !image.Dynamic {
+pub fn loadDynamicIo(self: *Self, reader: *std.Io.Reader) !image.Dynamic {
     current_self = self;
     defer current_self = undefined;
 
@@ -155,7 +158,7 @@ pub fn loadHdrBuf(self: *Self, buf: []const u8) !image.Hdr {
 }
 
 /// On success, must free memory by calling `freeHdr` method.
-pub fn loadHdrIo(self: *Self, reader: *std.io.Reader) !image.Hdr {
+pub fn loadHdrIo(self: *Self, reader: *std.Io.Reader) !image.Hdr {
     current_self = self;
     defer current_self = undefined;
 
@@ -243,8 +246,8 @@ threadlocal var current_self: *Self = undefined;
 export fn castle_media_stbi_malloc(size: usize) callconv(.c) VoidPtr {
     const self = current_self;
 
-    self.mutex.lock();
-    defer self.mutex.unlock();
+    self.mutex.lock(self.io) catch return null;
+    defer self.mutex.unlock(self.io);
 
     self.allocations.ensureUnusedCapacity(self.allocator, 1) catch return null;
     const memory = self.allocator.alignedAlloc(u8, alignment, size) catch return null;
@@ -259,8 +262,8 @@ export fn castle_media_stbi_malloc(size: usize) callconv(.c) VoidPtr {
 export fn castle_media_stbi_realloc(maybe_ptr: VoidPtr, size: usize) callconv(.c) VoidPtr {
     const self = current_self;
 
-    self.mutex.lock();
-    defer self.mutex.unlock();
+    self.mutex.lock(self.io) catch return null;
+    defer self.mutex.unlock(self.io);
 
     // NOTE If we were pedantic, we would consider the fact that we might not
     // need unused capacity if the memory doesn't get relocated.
@@ -291,8 +294,8 @@ export fn castle_media_stbi_free(maybe_ptr: VoidPtr) callconv(.c) void {
     const self = current_self;
 
     if (maybe_ptr) |ptr| {
-        self.mutex.lock();
-        defer self.mutex.unlock();
+        self.mutex.lockUncancelable(self.io);
+        defer self.mutex.unlock(self.io);
 
         const size = self.allocations.fetchRemove(ptr).?.value;
         self.allocated_bytes -= size;
@@ -301,3 +304,7 @@ export fn castle_media_stbi_free(maybe_ptr: VoidPtr) callconv(.c) void {
         self.allocator.free(memory);
     }
 }
+
+test "refAllDecls" {
+    std.testing.refAllDecls(@This());
+}