feat: replace Gamepak

In an effort to reuse code between zba and zba-gdbstub, move common util
code (like the SPSC Channel I implemented in this commit) in a new lib

.gitmodules

@@ -22,3 +22,6 @@
 [submodule "lib/nfd-zig"]
 	path = lib/nfd-zig
 	url = https://github.com/fabioarnold/nfd-zig
+[submodule "lib/zba-util"]
+	path = lib/zba-util
+	url = https://git.musuka.dev/paoda/zba-util.git

build.zig

@@ -33,7 +33,7 @@ pub fn build(b: *std.build.Builder) void {
     exe.addAnonymousModule("datetime", .{ .source_file = .{ .path = "lib/zig-datetime/src/main.zig" } });
 
     // Bitfield type from FlorenceOS: https://github.com/FlorenceOS/
-    exe.addAnonymousModule("bitfield", .{ .source_file = .{ .path = "lib/util/bitfield.zig" } });
+    exe.addAnonymousModule("bitfield", .{ .source_file = .{ .path = "lib/bitfield.zig" } });
 
     // Argument Parsing Library
     exe.addAnonymousModule("clap", .{ .source_file = .{ .path = "lib/zig-clap/clap.zig" } });
@@ -44,6 +44,9 @@ pub fn build(b: *std.build.Builder) void {
     // OpenGL 3.3 Bindings
     exe.addAnonymousModule("gl", .{ .source_file = .{ .path = "lib/gl.zig" } });
 
+    // ZBA utility code
+    exe.addAnonymousModule("zba-util", .{ .source_file = .{ .path = "lib/zba-util/src/lib.zig" } });
+
     // gdbstub
     gdbstub.link(exe);
     // NativeFileDialog(ue) Bindings

lib/zba-util

@@ -0,0 +1 @@
+Subproject commit d5e66caf2180324d83ad9be30e887849f5ed74da

src/core/Bus.zig

@@ -19,7 +19,7 @@ const log = std.log.scoped(.Bus);
 
 const createDmaTuple = @import("bus/dma.zig").create;
 const createTimerTuple = @import("bus/timer.zig").create;
-const rotr = @import("../util.zig").rotr;
+const rotr = @import("zba-util").rotr;
 
 const timings: [2][0x10]u8 = [_][0x10]u8{
     // BIOS, Unused, EWRAM, IWRAM, I/0, PALRAM, VRAM, OAM, ROM0, ROM0, ROM1, ROM1, ROM2, ROM2, SRAM, Unused
@@ -104,7 +104,7 @@ pub fn deinit(self: *Self) void {
 
 pub fn reset(self: *Self) void {
     self.bios.reset();
-    // TODO: deinit ppu
+    self.ppu.reset();
     self.apu.reset();
     self.iwram.reset();
     self.ewram.reset();
@@ -128,6 +128,21 @@ pub fn reset(self: *Self) void {
     self.io.reset();
 }
 
+pub fn replaceGamepak(self: *Self, file_path: []const u8) !void {
+    // Note: `save_path` isn't owned by `Backup`
+    const save_path = self.pak.backup.save_path;
+    self.pak.deinit();
+
+    self.pak = try GamePak.init(self.allocator, self.cpu, file_path, save_path);
+
+    const read_ptr: *[table_len]?*const anyopaque = @constCast(self.read_table);
+    const write_ptrs: [2]*[table_len]?*anyopaque = .{ @constCast(self.write_tables[0]), @constCast(self.write_tables[1]) };
+
+    self.fillReadTable(read_ptr);
+    self.fillWriteTable(u32, write_ptrs[0]);
+    self.fillWriteTable(u8, write_ptrs[1]);
+}
+
 fn fillReadTable(self: *Self, table: *[table_len]?*const anyopaque) void {
     const vramMirror = @import("ppu/Vram.zig").mirror;
 

src/core/apu.zig

@@ -14,7 +14,6 @@ const SoundFifo = std.fifo.LinearFifo(u8, .{ .Static = 0x20 });
 
 const getHalf = util.getHalf;
 const setHalf = util.setHalf;
-const intToBytes = util.intToBytes;
 
 const log = std.log.scoped(.APU);
 
@@ -279,16 +278,20 @@ pub const Apu = struct {
             .is_buffer_full = false,
         };
 
-        sched.push(.SampleAudio, apu.interval());
+        Self.initEvents(apu.sched, apu.interval());
-        sched.push(.{ .ApuChannel = 0 }, @import("apu/signal/Square.zig").interval);
-        sched.push(.{ .ApuChannel = 1 }, @import("apu/signal/Square.zig").interval);
-        sched.push(.{ .ApuChannel = 2 }, @import("apu/signal/Wave.zig").interval);
-        sched.push(.{ .ApuChannel = 3 }, @import("apu/signal/Lfsr.zig").interval);
-        sched.push(.FrameSequencer, FrameSequencer.interval);
 
         return apu;
     }
 
+    fn initEvents(scheduler: *Scheduler, apu_interval: u64) void {
+        scheduler.push(.SampleAudio, apu_interval);
+        scheduler.push(.{ .ApuChannel = 0 }, @import("apu/signal/Square.zig").interval);
+        scheduler.push(.{ .ApuChannel = 1 }, @import("apu/signal/Square.zig").interval);
+        scheduler.push(.{ .ApuChannel = 2 }, @import("apu/signal/Wave.zig").interval);
+        scheduler.push(.{ .ApuChannel = 3 }, @import("apu/signal/Lfsr.zig").interval);
+        scheduler.push(.FrameSequencer, FrameSequencer.interval);
+    }
+
     /// Used when resetting the emulator
     pub fn reset(self: *Self) void {
         // FIXME: These reset functions are meant to emulate obscure APU behaviour. Write proper emu reset fns
@@ -307,6 +310,8 @@ pub const Apu = struct {
 
         self.sampling_cycle = 0;
         self.fs.reset();
+
+        Self.initEvents(self.sched, self.interval());
     }
 
     /// Emulates the reset behaviour of the APU
@@ -557,7 +562,7 @@ pub fn DmaSound(comptime kind: DmaSoundKind) type {
         pub fn push(self: *Self, value: u32) void {
             if (!self.enabled) self.enable();
 
-            self.fifo.write(&intToBytes(u32, value)) catch |e| log.err("{} Error: {}", .{ kind, e });
+            self.fifo.write(std.mem.asBytes(&value)) catch |e| log.err("{} Error: {}", .{ kind, e });
         }
 
         fn enable(self: *Self) void {

src/core/bus/Bios.zig

@@ -3,7 +3,7 @@ const std = @import("std");
 const Allocator = std.mem.Allocator;
 const log = std.log.scoped(.Bios);
 
-const rotr = @import("../../util.zig").rotr;
+const rotr = @import("zba-util").rotr;
 const forceAlign = @import("../Bus.zig").forceAlign;
 
 /// Size of the BIOS in bytes

src/core/bus/dma.zig

@@ -12,7 +12,7 @@ const getHalf = util.getHalf;
 const setHalf = util.setHalf;
 const setQuart = util.setQuart;
 
-const rotr = @import("../../util.zig").rotr;
+const rotr = @import("zba-util").rotr;
 
 pub fn create() DmaTuple {
     return .{ DmaController(0).init(), DmaController(1).init(), DmaController(2).init(), DmaController(3).init() };

src/core/cpu/arm/branch.zig

@@ -2,7 +2,7 @@ const Bus = @import("../../Bus.zig");
 const Arm7tdmi = @import("../../cpu.zig").Arm7tdmi;
 const InstrFn = @import("../../cpu.zig").arm.InstrFn;
 
-const sext = @import("../../../util.zig").sext;
+const sext = @import("zba-util").sext;
 
 pub fn branch(comptime L: bool) InstrFn {
     return struct {

src/core/cpu/arm/half_signed_data_transfer.zig

@@ -2,8 +2,8 @@ const Bus = @import("../../Bus.zig");
 const Arm7tdmi = @import("../../cpu.zig").Arm7tdmi;
 const InstrFn = @import("../../cpu.zig").arm.InstrFn;
 
-const sext = @import("../../../util.zig").sext;
+const sext = @import("zba-util").sext;
-const rotr = @import("../../../util.zig").rotr;
+const rotr = @import("zba-util").rotr;
 
 pub fn halfAndSignedDataTransfer(comptime P: bool, comptime U: bool, comptime I: bool, comptime W: bool, comptime L: bool) InstrFn {
     return struct {

src/core/cpu/arm/psr_transfer.zig

@@ -7,7 +7,7 @@ const PSR = @import("../../cpu.zig").PSR;
 
 const log = std.log.scoped(.PsrTransfer);
 
-const rotr = @import("../../../util.zig").rotr;
+const rotr = @import("zba-util").rotr;
 
 pub fn psrTransfer(comptime I: bool, comptime R: bool, comptime kind: u2) InstrFn {
     return struct {

src/core/cpu/arm/single_data_swap.zig

@@ -2,7 +2,7 @@ const Bus = @import("../../Bus.zig");
 const Arm7tdmi = @import("../../cpu.zig").Arm7tdmi;
 const InstrFn = @import("../../cpu.zig").arm.InstrFn;
 
-const rotr = @import("../../../util.zig").rotr;
+const rotr = @import("zba-util").rotr;
 
 pub fn singleDataSwap(comptime B: bool) InstrFn {
     return struct {

src/core/cpu/arm/single_data_transfer.zig

@@ -3,7 +3,7 @@ const Bus = @import("../../Bus.zig");
 const Arm7tdmi = @import("../../cpu.zig").Arm7tdmi;
 const InstrFn = @import("../../cpu.zig").arm.InstrFn;
 
-const rotr = @import("../../../util.zig").rotr;
+const rotr = @import("zba-util").rotr;
 
 pub fn singleDataTransfer(comptime I: bool, comptime P: bool, comptime U: bool, comptime B: bool, comptime W: bool, comptime L: bool) InstrFn {
     return struct {

src/core/cpu/barrel_shifter.zig

@@ -1,7 +1,7 @@
 const Arm7tdmi = @import("../cpu.zig").Arm7tdmi;
 const CPSR = @import("../cpu.zig").PSR;
 
-const rotr = @import("../../util.zig").rotr;
+const rotr = @import("zba-util").rotr;
 
 pub fn exec(comptime S: bool, cpu: *Arm7tdmi, opcode: u32) u32 {
     var result: u32 = undefined;

src/core/cpu/thumb/branch.zig

@@ -3,7 +3,7 @@ const Arm7tdmi = @import("../../cpu.zig").Arm7tdmi;
 const InstrFn = @import("../../cpu.zig").thumb.InstrFn;
 
 const checkCond = @import("../../cpu.zig").checkCond;
-const sext = @import("../../../util.zig").sext;
+const sext = @import("zba-util").sext;
 
 pub fn fmt16(comptime cond: u4) InstrFn {
     return struct {

src/core/cpu/thumb/data_transfer.zig

@@ -2,8 +2,8 @@ const Bus = @import("../../Bus.zig");
 const Arm7tdmi = @import("../../cpu.zig").Arm7tdmi;
 const InstrFn = @import("../../cpu.zig").thumb.InstrFn;
 
-const rotr = @import("../../../util.zig").rotr;
+const rotr = @import("zba-util").rotr;
-const sext = @import("../../../util.zig").sext;
+const sext = @import("zba-util").sext;
 
 pub fn fmt6(comptime rd: u3) InstrFn {
     return struct {

src/core/emu.zig

@@ -5,9 +5,9 @@ const config = @import("../config.zig");
 const Scheduler = @import("scheduler.zig").Scheduler;
 const Arm7tdmi = @import("cpu.zig").Arm7tdmi;
 const Tracker = @import("../util.zig").FpsTracker;
+const TwoWayChannel = @import("zba-util").TwoWayChannel;
 
 const Timer = std.time.Timer;
-const Atomic = std.atomic.Atomic;
 
 /// 4 Cycles in 1 dot
 const cycles_per_dot = 4;
@@ -35,29 +35,40 @@ const RunKind = enum {
     LimitedFPS,
 };
 
-pub fn run(quit: *Atomic(bool), pause: *Atomic(bool), cpu: *Arm7tdmi, scheduler: *Scheduler, tracker: *Tracker) void {
+pub fn run(cpu: *Arm7tdmi, scheduler: *Scheduler, tracker: *Tracker, channel: *TwoWayChannel) void {
     const audio_sync = config.config().guest.audio_sync and !config.config().host.mute;
     if (audio_sync) log.info("Audio sync enabled", .{});
 
     if (config.config().guest.video_sync) {
-        inner(.LimitedFPS, audio_sync, quit, pause, cpu, scheduler, tracker);
+        inner(.LimitedFPS, audio_sync, cpu, scheduler, tracker, channel);
     } else {
-        inner(.UnlimitedFPS, audio_sync, quit, pause, cpu, scheduler, tracker);
+        inner(.UnlimitedFPS, audio_sync, cpu, scheduler, tracker, channel);
     }
 }
 
-fn inner(comptime kind: RunKind, audio_sync: bool, quit: *Atomic(bool), pause: *Atomic(bool), cpu: *Arm7tdmi, scheduler: *Scheduler, tracker: ?*Tracker) void {
+fn inner(comptime kind: RunKind, audio_sync: bool, cpu: *Arm7tdmi, scheduler: *Scheduler, tracker: ?*Tracker, channel: *TwoWayChannel) void {
     if (kind == .UnlimitedFPS or kind == .LimitedFPS) {
         std.debug.assert(tracker != null);
         log.info("FPS tracking enabled", .{});
     }
 
+    var paused: bool = false;
+
     switch (kind) {
         .Unlimited, .UnlimitedFPS => {
             log.info("Emulation w/out video sync", .{});
 
-            while (!quit.load(.Monotonic)) {
+            while (true) {
-                if (pause.load(.Monotonic)) continue;
+                if (channel.emu.pop()) |e| switch (e) {
+                    .Quit => break,
+                    .Resume => paused = false,
+                    .Pause => {
+                        paused = true;
+                        channel.gui.push(.Paused);
+                    },
+                };
+
+                if (paused) continue;
 
                 runFrame(scheduler, cpu);
                 audioSync(audio_sync, cpu.bus.apu.stream, &cpu.bus.apu.is_buffer_full);
@@ -70,8 +81,17 @@ fn inner(comptime kind: RunKind, audio_sync: bool, quit: *Atomic(bool), pause: *
             var timer = Timer.start() catch @panic("failed to initalize std.timer.Timer");
             var wake_time: u64 = frame_period;
 
-            while (!quit.load(.Monotonic)) {
+            while (true) {
-                if (pause.load(.Monotonic)) continue;
+                if (channel.emu.pop()) |e| switch (e) {
+                    .Quit => break,
+                    .Resume => paused = false,
+                    .Pause => {
+                        paused = true;
+                        channel.gui.push(.Paused);
+                    },
+                };
+
+                if (paused) continue;
 
                 runFrame(scheduler, cpu);
                 const new_wake_time = videoSync(&timer, wake_time);
@@ -229,3 +249,8 @@ pub fn reset(cpu: *Arm7tdmi) void {
     cpu.bus.reset();
     cpu.reset();
 }
+
+pub fn replaceGamepak(cpu: *Arm7tdmi, file_path: []const u8) !void {
+    try cpu.bus.replaceGamepak(file_path);
+    reset(cpu);
+}

src/core/ppu.zig

@@ -290,6 +290,26 @@ pub const Ppu = struct {
         };
     }
 
+    pub fn reset(self: *Self) void {
+        self.sched.push(.Draw, 240 * 4);
+
+        self.vram.reset();
+        self.palette.reset();
+        self.oam.reset();
+        self.framebuf.reset();
+
+        self.win = Window.init();
+        self.bg = [_]Background{Background.init()} ** 4;
+        self.aff_bg = [_]AffineBackground{AffineBackground.init()} ** 2;
+        self.bld = Blend.create();
+        self.dispcnt = .{ .raw = 0x0000 };
+        self.dispstat = .{ .raw = 0x0000 };
+        self.vcount = .{ .raw = 0x0000 };
+
+        self.scanline.reset();
+        std.mem.set(?Sprite, self.scanline_sprites, null);
+    }
+
     pub fn deinit(self: *Self) void {
         self.allocator.destroy(self.scanline_sprites);
         self.framebuf.deinit();

src/core/ppu/Oam.zig

@@ -34,6 +34,10 @@ pub fn init(allocator: Allocator) !Self {
     return Self{ .buf = buf, .allocator = allocator };
 }
 
+pub fn reset(self: *Self) void {
+    std.mem.set(u8, self.buf, 0);
+}
+
 pub fn deinit(self: *Self) void {
     self.allocator.free(self.buf);
     self.* = undefined;

src/core/ppu/Palette.zig

@@ -37,6 +37,10 @@ pub fn init(allocator: Allocator) !Self {
     return Self{ .buf = buf, .allocator = allocator };
 }
 
+pub fn reset(self: *Self) void {
+    std.mem.set(u8, self.buf, 0);
+}
+
 pub fn deinit(self: *Self) void {
     self.allocator.free(self.buf);
     self.* = undefined;

src/core/ppu/Vram.zig

@@ -45,6 +45,10 @@ pub fn init(allocator: Allocator) !Self {
     return Self{ .buf = buf, .allocator = allocator };
 }
 
+pub fn reset(self: *Self) void {
+    std.mem.set(u8, self.buf, 0);
+}
+
 pub fn deinit(self: *Self) void {
     self.allocator.free(self.buf);
     self.* = undefined;

src/imgui.zig

@@ -11,7 +11,7 @@ const emu = @import("core/emu.zig");
 
 const Gui = @import("platform.zig").Gui;
 const Arm7tdmi = @import("core/cpu.zig").Arm7tdmi;
-const RingBuffer = @import("util.zig").RingBuffer;
+const RingBuffer = @import("zba-util").RingBuffer;
 
 const Allocator = std.mem.Allocator;
 const GLuint = gl.GLuint;
@@ -43,7 +43,7 @@ pub const State = struct {
 
     pub fn deinit(self: *@This(), allocator: Allocator) void {
         allocator.free(self.title);
-        self.fps_hist.deinit(allocator);
+        allocator.free(self.fps_hist.buf);
 
         self.* = undefined;
     }
@@ -70,7 +70,10 @@ pub fn draw(state: *State, tex_id: GLuint, cpu: *Arm7tdmi) void {
                     defer nfd.freePath(file_path);
                     log.info("user chose: \"{s}\"", .{file_path});
 
-                    // emu.loadRom(cpu, file_path);
+                    emu.replaceGamepak(cpu, file_path) catch |e| {
+                        log.err("failed to replace GamePak: {}", .{e});
+                        break :blk;
+                    };
                 }
             }
         }

src/main.zig

@@ -6,6 +6,7 @@ const clap = @import("clap");
 const config = @import("config.zig");
 const emu = @import("core/emu.zig");
 
+const TwoWayChannel = @import("zba-util").TwoWayChannel;
 const Gui = @import("platform.zig").Gui;
 const Bus = @import("core/Bus.zig");
 const Arm7tdmi = @import("core/cpu.zig").Arm7tdmi;
@@ -13,7 +14,6 @@ const Scheduler = @import("core/scheduler.zig").Scheduler;
 const FilePaths = @import("util.zig").FilePaths;
 const FpsTracker = @import("util.zig").FpsTracker;
 const Allocator = std.mem.Allocator;
-const Atomic = std.atomic.Atomic;
 
 const log = std.log.scoped(.Cli);
 pub const log_level = if (builtin.mode != .Debug) .info else std.log.default_level;
@@ -70,9 +70,10 @@ pub fn main() void {
     const paths = handleArguments(allocator, data_path, &result) catch |e| exitln("failed to handle cli arguments: {}", .{e});
     defer if (paths.save) |path| allocator.free(path);
 
-    const log_file = if (config.config().debug.cpu_trace) blk: {
+    const log_file = switch (config.config().debug.cpu_trace) {
-        break :blk std.fs.cwd().createFile("zba.log", .{}) catch |e| exitln("failed to create trace log file: {}", .{e});
+        true => std.fs.cwd().createFile("zba.log", .{}) catch |e| exitln("failed to create trace log file: {}", .{e}),
-    } else null;
+        false => null,
+    };
     defer if (log_file) |file| file.close();
 
     // TODO: Take Emulator Init Code out of main.zig
@@ -93,7 +94,10 @@ pub fn main() void {
     var gui = Gui.init(allocator, bus.pak.title, &bus.apu) catch |e| exitln("failed to init gui: {}", .{e});
     defer gui.deinit();
 
-    var quit = Atomic(bool).init(false);
+    var quit = std.atomic.Atomic(bool).init(false);
+
+    var items: [0x100]u8 = undefined;
+    var channel = TwoWayChannel.init(&items);
 
     if (result.args.gdb) {
         const Server = @import("gdbstub").Server;
@@ -116,21 +120,19 @@ pub fn main() void {
         gui.run(.{
             .cpu = &cpu,
             .scheduler = &scheduler,
-            .quit = &quit,
+            .channel = &channel,
         }) catch |e| exitln("main thread panicked: {}", .{e});
     } else {
         var tracker = FpsTracker.init();
-        var pause = Atomic(bool).init(false);
 
-        const thread = std.Thread.spawn(.{}, emu.run, .{ &quit, &pause, &cpu, &scheduler, &tracker }) catch |e| exitln("emu thread panicked: {}", .{e});
+        const thread = std.Thread.spawn(.{}, emu.run, .{ &cpu, &scheduler, &tracker, &channel }) catch |e| exitln("emu thread panicked: {}", .{e});
         defer thread.join();
 
         gui.run(.{
             .cpu = &cpu,
             .scheduler = &scheduler,
+            .channel = &channel,
             .tracker = &tracker,
-            .quit = &quit,
-            .pause = &pause,
         }) catch |e| exitln("main thread panicked: {}", .{e});
     }
 }

src/platform.zig

@@ -11,7 +11,7 @@ const Apu = @import("core/apu.zig").Apu;
 const Arm7tdmi = @import("core/cpu.zig").Arm7tdmi;
 const Scheduler = @import("core/scheduler.zig").Scheduler;
 const FpsTracker = @import("util.zig").FpsTracker;
-const RingBuffer = @import("util.zig").RingBuffer;
+const TwoWayChannel = @import("zba-util").TwoWayChannel;
 
 const gba_width = @import("core/ppu.zig").width;
 const gba_height = @import("core/ppu.zig").height;
@@ -243,8 +243,7 @@ pub const Gui = struct {
     }
 
     const RunOptions = struct {
-        quit: *std.atomic.Atomic(bool),
+        channel: *TwoWayChannel,
-        pause: ?*std.atomic.Atomic(bool) = null,
         tracker: ?*FpsTracker = null,
         cpu: *Arm7tdmi,
         scheduler: *Scheduler,
@@ -253,8 +252,7 @@ pub const Gui = struct {
     pub fn run(self: *Self, opt: RunOptions) !void {
         const cpu = opt.cpu;
         const tracker = opt.tracker;
-        const quit = opt.quit;
+        const channel = opt.channel;
-        const pause = opt.pause;
 
         const obj_ids = Self.genBufferObjects();
         defer gl.deleteBuffers(3, @as(*const [3]c_uint, &obj_ids));
@@ -269,7 +267,10 @@ pub const Gui = struct {
         emu_loop: while (true) {
             // `quit` from RunOptions may be modified by the GDBSTUB thread,
             // so we want to recognize that it may change to `true` and exit the GUI thread
-            if (quit.load(.Monotonic)) break :emu_loop;
+            if (channel.gui.pop()) |event| switch (event) {
+                .Quit => break :emu_loop,
+                .Paused => @panic("TODO: We want to peek (and then pop if it's .Quit), not always pop"),
+            };
 
             // Outside of `SDL.SDL_QUIT` below, the DearImgui UI might signal that the program
             // should exit, in which case we should also handle this
@@ -325,17 +326,18 @@ pub const Gui = struct {
                 }
             }
 
-            // If `Gui.run` has been passed with a `pause` atomic, we should
-            // pause the emulation thread while we access the data there
             {
-                // TODO: Is there a nicer way to express this?
+                channel.emu.push(.Pause);
-                if (pause) |val| val.store(true, .Monotonic);
+                defer channel.emu.push(.Resume);
-                defer if (pause) |val| val.store(false, .Monotonic);
+
+                // Spin Loop until we know that the emu is paused
+                wait: while (true) switch (channel.gui.pop() orelse continue) {
+                    .Paused => break :wait,
+                    else => |any| std.debug.panic("[Gui/Channel]: Unhandled Event: {}", .{any}),
+                };
 
                 // Add FPS count to the histogram
-                if (tracker) |t| {
+                if (tracker) |t| self.state.fps_hist.push(t.value()) catch {};
-                    self.state.fps_hist.push(t.value()) catch {};
-                }
 
                 // Draw GBA Screen to Texture
                 {
@@ -361,7 +363,7 @@ pub const Gui = struct {
             SDL.SDL_GL_SwapWindow(self.window);
         }
 
-        quit.store(true, .Monotonic); // Signals to emu thread to exit
+        channel.emu.push(.Quit);
     }
 
     fn glGetProcAddress(ctx: SDL.SDL_GLContext, proc: [:0]const u8) ?*anyopaque {

src/util.zig

@@ -7,27 +7,6 @@ const Arm7tdmi = @import("core/cpu.zig").Arm7tdmi;
 
 const Allocator = std.mem.Allocator;
 
-// Sign-Extend value of type `T` to type `U`
-pub fn sext(comptime T: type, comptime U: type, value: T) T {
-    // U must have less bits than T
-    comptime std.debug.assert(@typeInfo(U).Int.bits <= @typeInfo(T).Int.bits);
-
-    const iT = std.meta.Int(.signed, @typeInfo(T).Int.bits);
-    const ExtU = if (@typeInfo(U).Int.signedness == .unsigned) T else iT;
-    const shift_amt = @intCast(Log2Int(T), @typeInfo(T).Int.bits - @typeInfo(U).Int.bits);
-
-    return @bitCast(T, @bitCast(iT, @as(ExtU, @truncate(U, value)) << shift_amt) >> shift_amt);
-}
-
-/// See https://godbolt.org/z/W3en9Eche
-pub inline fn rotr(comptime T: type, x: T, r: anytype) T {
-    if (@typeInfo(T).Int.signedness == .signed)
-        @compileError("cannot rotate signed integer");
-
-    const ar = @intCast(Log2Int(T), @mod(r, @typeInfo(T).Int.bits));
-    return x >> ar | x << (1 +% ~ar);
-}
-
 pub const FpsTracker = struct {
     const Self = @This();
 
@@ -57,17 +36,6 @@ pub const FpsTracker = struct {
     }
 };
 
-pub fn intToBytes(comptime T: type, value: anytype) [@sizeOf(T)]u8 {
-    comptime std.debug.assert(@typeInfo(T) == .Int);
-
-    var result: [@sizeOf(T)]u8 = undefined;
-
-    var i: Log2Int(T) = 0;
-    while (i < result.len) : (i += 1) result[i] = @truncate(u8, value >> i * @bitSizeOf(u8));
-
-    return result;
-}
-
 /// Creates a copy of a title with all Filesystem-invalid characters replaced
 ///
 /// e.g. POKEPIN R/S to POKEPIN R_S
@@ -283,7 +251,7 @@ pub const FrameBuffer = struct {
 
     layers: [2][]u8,
     buf: []u8,
-    current: u1,
+    current: u1 = 0,
 
     allocator: Allocator,
 
@@ -298,12 +266,16 @@ pub const FrameBuffer = struct {
             // Front and Back Framebuffers
             .layers = [_][]u8{ buf[0..][0..len], buf[len..][0..len] },
             .buf = buf,
-            .current = 0,
 
             .allocator = allocator,
         };
     }
 
+    pub fn reset(self: *Self) void {
+        std.mem.set(u8, self.buf, 0);
+        self.current = 0;
+    }
+
     pub fn deinit(self: *Self) void {
         self.allocator.free(self.buf);
         self.* = undefined;
@@ -317,78 +289,3 @@ pub const FrameBuffer = struct {
         return self.layers[if (dev == .Emulator) self.current else ~self.current];
     }
 };
-
-pub fn RingBuffer(comptime T: type) type {
-    return struct {
-        const Self = @This();
-        const Index = usize;
-        const max_capacity = (@as(Index, 1) << @typeInfo(Index).Int.bits - 1) - 1; // half the range of index type
-
-        const log = std.log.scoped(.RingBuffer);
-
-        read: Index,
-        write: Index,
-        buf: []T,
-
-        const Error = error{buffer_full};
-
-        pub fn init(buf: []T) Self {
-            std.debug.assert(std.math.isPowerOfTwo(buf.len)); // capacity must be a power of two
-            std.debug.assert(buf.len <= max_capacity);
-
-            std.mem.set(T, buf, 0);
-
-            return .{ .read = 0, .write = 0, .buf = buf };
-        }
-
-        pub fn deinit(self: *Self, allocator: Allocator) void {
-            allocator.free(self.buf);
-            self.* = undefined;
-        }
-
-        pub fn push(self: *Self, value: T) Error!void {
-            if (self.isFull()) return error.buffer_full;
-            defer self.write += 1;
-
-            self.buf[self.mask(self.write)] = value;
-        }
-
-        pub fn pop(self: *Self) ?T {
-            if (self.isEmpty()) return null;
-            defer self.read += 1;
-
-            return self.buf[self.mask(self.read)];
-        }
-
-        /// Returns the number of entries read
-        pub fn copy(self: *const Self, cpy: []T) Index {
-            const count = std.math.min(self.len(), cpy.len);
-            var start: Index = self.read;
-
-            for (cpy, 0..) |*v, i| {
-                if (i >= count) break;
-
-                v.* = self.buf[self.mask(start)];
-                start += 1;
-            }
-
-            return count;
-        }
-
-        fn len(self: *const Self) Index {
-            return self.write - self.read;
-        }
-
-        fn isFull(self: *const Self) bool {
-            return self.len() == self.buf.len;
-        }
-
-        fn isEmpty(self: *const Self) bool {
-            return self.read == self.write;
-        }
-
-        fn mask(self: *const Self, idx: Index) Index {
-            return idx & (self.buf.len - 1);
-        }
-    };
-}