chore: add test for RingBuffer

.github/workflows/main.yml

@@ -39,7 +39,7 @@ jobs:
         with:
           submodules: true
       - name: build 
-        run: zig build -Doptimize=ReleaseSafe
+        run: zig build -Drelease-safe
       - name: upload
         uses: actions/upload-artifact@v3
         with:

.gitignore

@@ -12,7 +12,3 @@
 
 # Any Custom Scripts for Debugging purposes
 *.sh
-
-
-# Dear ImGui
-**/imgui.ini

.gitmodules

@@ -13,9 +13,3 @@
 [submodule "lib/zig-toml"]
 	path = lib/zig-toml
 	url = https://github.com/aeronavery/zig-toml
-[submodule "lib/zgui"]
-	path = lib/zgui
-	url = https://git.musuka.dev/paoda/zgui
-[submodule "lib/nfd-zig"]
-	path = lib/nfd-zig
-	url = https://github.com/fabioarnold/nfd-zig

.vscode/extensions.json

@@ -0,0 +1,8 @@
+{
+    "recommendations": [
+        "augusterame.zls-vscode",
+        "usernamehw.errorlens",
+        "vadimcn.vscode-lldb",
+        "dan-c-underwood.arm"
+    ]
+}

README.md

@@ -10,10 +10,10 @@ This is a simple (read: incomplete) for-fun long-term project. I hope to get "mo
 
 ### TODO
 
-- [x] Affine Sprites
+- [ ] Affine Sprites
 - [ ] Windowing (see [this branch](https://git.musuka.dev/paoda/zba/src/branch/window))
 - [ ] Audio Resampler (Having issues with SDL2's)
-- [x] Immediate Mode GUI (see [this branch](https://git.musuka.dev/paoda/zba/src/branch/imgui))
+- [ ] Immediate Mode GUI
 - [ ] Refactoring for easy-ish perf boosts
 
 ## Usage
@@ -77,33 +77,31 @@ arm7wrestler GBA Fixed | [destoer](https://github.com/destoer)
 
 ## Compiling
 
-Most recently built on Zig [v0.11.0-dev.1557+03cdb4fb5](https://github.com/ziglang/zig/tree/03cdb4fb5)
+Most recently built on Zig [0.11.0-dev.368+1829b6eab](https://github.com/ziglang/zig/tree/1829b6eab)
 
 ### Dependencies
 
 Dependency | Source
 --- | ---
 SDL.zig | <https://github.com/MasterQ32/SDL.zig>
-known-folders | <https://github.com/ziglibs/known-folders>
-nfd-zig | <https://github.com/fabioarnold/nfd-zig>
-zgui | <https://github.com/michal-z/zig-gamedev/tree/main/libs/zgui>
 zig-clap | <https://github.com/Hejsil/zig-clap>
-zig-datetime | <https://github.com/frmdstryr/zig-datetime>
+known-folders | <https://github.com/ziglibs/known-folders>
 zig-toml | <https://github.com/aeronavery/zig-toml>
+zig-datetime | <https://github.com/frmdstryr/zig-datetime>
 `bitfields.zig` | [https://github.com/FlorenceOS/Florence](https://github.com/FlorenceOS/Florence/blob/aaa5a9e568/lib/util/bitfields.zig)
 `gl.zig` | <https://github.com/MasterQ32/zig-opengl>
 
-Use `git submodule update --init` from the project root to pull the git relevant git submodules
+Use `git submodule update --init` from the project root to pull the git submodules `SDL.zig`, `zig-clap`, `known-folders`, `zig-toml` and `zig-datetime`
 
 Be sure to provide SDL2 using:
 
 - Linux: Your distro's package manager
-- MacOS: `brew` (install [this formula](https://formulae.brew.sh/formula/sdl2))
+- MacOS: ¯\\\_(ツ)_/¯
 - Windows: [`vcpkg`](https://github.com/Microsoft/vcpkg) (install `sdl2:x64-windows`)
 
 `SDL.zig` will provide a helpful compile error if the zig compiler is unable to find SDL2.
 
-Once you've got all the dependencies, execute `zig build -Doptimize=ReleaseSafe`. The executable is located at `zig-out/bin/`.
+Once you've got all the dependencies, execute `zig build -Drelease-fast`. The executable is located at `zig-out/bin/`.
 
 ## Controls
 

build.zig

@@ -1,29 +1,28 @@
 const std = @import("std");
 const builtin = @import("builtin");
-
 const Sdk = @import("lib/SDL.zig/Sdk.zig");
-const zgui = @import("lib/zgui/build.zig");
-const nfd = @import("lib/nfd-zig/build.zig");
 
 pub fn build(b: *std.build.Builder) void {
     // Minimum Zig Version
-    const min_ver = std.SemanticVersion.parse("0.11.0-dev.1557+03cdb4fb5") catch return; // https://github.com/ziglang/zig/commit/03cdb4fb5
+    const min_ver = std.SemanticVersion.parse("0.11.0-dev.323+30eb2a175") catch return; // https://github.com/ziglang/zig/commit/30eb2a175
     if (builtin.zig_version.order(min_ver).compare(.lt)) {
         std.log.err("{s}", .{b.fmt("Zig v{} does not meet the minimum version requirement. (Zig v{})", .{ builtin.zig_version, min_ver })});
         std.os.exit(1);
     }
 
+    // Standard target options allows the person running `zig build` to choose
+    // what target to build for. Here we do not override the defaults, which
+    // means any target is allowed, and the default is native. Other options
+    // for restricting supported target set are available.
     const target = b.standardTargetOptions(.{});
-    const optimize = b.standardOptimizeOption(.{});
 
-    const exe = b.addExecutable(.{
+    // Standard release options allow the person running `zig build` to select
-        .name = "zba",
+    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
-        .root_source_file = .{ .path = "src/main.zig" },
+    const mode = b.standardReleaseOptions();
-        .target = target,
-        .optimize = optimize,
-    });
 
+    const exe = b.addExecutable("zba", "src/main.zig");
     exe.setMainPkgPath("."); // Necessary so that src/main.zig can embed example.toml
+    exe.setTarget(target);
 
     // Known Folders (%APPDATA%, XDG, etc.)
     exe.addPackagePath("known_folders", "lib/known-folders/known-folders.zig");
@@ -44,21 +43,12 @@ pub fn build(b: *std.build.Builder) void {
     // OpenGL 3.3 Bindings
     exe.addPackagePath("gl", "lib/gl.zig");
 
-    // NativeFileDialog(ue) Bindings
-    exe.linkLibrary(nfd.makeLib(b, target, optimize));
-    exe.addPackage(nfd.getPackage("nfd"));
-
     // Zig SDL Bindings: https://github.com/MasterQ32/SDL.zig
-    const sdk = Sdk.init(b, null);
+    const sdk = Sdk.init(b);
     sdk.link(exe, .dynamic);
     exe.addPackage(sdk.getNativePackage("sdl2"));
 
-    // Dear ImGui bindings
+    exe.setBuildMode(mode);
-    const zgui_options = zgui.BuildOptionsStep.init(b, .{ .backend = .sdl2_opengl3 });
-    const zgui_pkg = zgui.getPkg(&.{zgui_options.getPkg()});
-    zgui.link(exe, zgui_options);
-    exe.addPackage(zgui_pkg);
-
     exe.install();
 
     const run_cmd = exe.run();
@@ -70,11 +60,9 @@ pub fn build(b: *std.build.Builder) void {
     const run_step = b.step("run", "Run the app");
     run_step.dependOn(&run_cmd.step);
 
-    const exe_tests = b.addTest(.{
+    const exe_tests = b.addTest("src/main.zig");
-        .root_source_file = .{ .path = "src/main.zig" },
+    exe_tests.setTarget(target);
-        .target = target,
+    exe_tests.setBuildMode(mode);
-        .optimize = optimize,
-    });
 
     const test_step = b.step("test", "Run unit tests");
     test_step.dependOn(&exe_tests.step);

src/core/Bus.zig

@@ -60,8 +60,9 @@ allocator: Allocator,
 pub fn init(self: *Self, allocator: Allocator, sched: *Scheduler, cpu: *Arm7tdmi, paths: FilePaths) !void {
     const tables = try allocator.alloc(?*anyopaque, 3 * table_len); // Allocate all tables
 
-    const read_table = tables[0..table_len];
+    const read_table: *[table_len]?*const anyopaque = tables[0..table_len];
-    const write_tables = .{ tables[table_len .. 2 * table_len], tables[2 * table_len .. 3 * table_len] };
+    const left_write: *[table_len]?*anyopaque = tables[table_len .. 2 * table_len];
+    const right_write: *[table_len]?*anyopaque = tables[2 * table_len .. 3 * table_len];
 
     self.* = .{
         .pak = try GamePak.init(allocator, cpu, paths.rom, paths.save),
@@ -77,15 +78,18 @@ pub fn init(self: *Self, allocator: Allocator, sched: *Scheduler, cpu: *Arm7tdmi
         .sched = sched,
 
         .read_table = read_table,
-        .write_tables = write_tables,
+        .write_tables = .{ left_write, right_write },
         .allocator = allocator,
     };
 
-    self.fillReadTable(read_table);
+    // read_table, write_tables, and *Self are not restricted to the lifetime
+    // of this init function so we can initialize our tables here
+    fillReadTable(self, read_table);
 
-    // Internal Display Memory behaves differently on 8-bit reads
+    // Internal Display Memory behavious unusually on 8-bit reads
-    self.fillWriteTable(u32, write_tables[0]);
+    // so we have two different tables depending on whether there's an 8-bit read or not
-    self.fillWriteTable(u8, write_tables[1]);
+    fillWriteTable(u32, self, left_write);
+    fillWriteTable(u8, self, right_write);
 }
 
 pub fn deinit(self: *Self) void {
@@ -102,50 +106,50 @@ pub fn deinit(self: *Self) void {
     self.* = undefined;
 }
 
-fn fillReadTable(self: *Self, table: *[table_len]?*const anyopaque) void {
+fn fillReadTable(bus: *Self, table: *[table_len]?*const anyopaque) void {
-    const vramMirror = @import("ppu/Vram.zig").mirror;
+    const vramMirror = @import("ppu.zig").Vram.mirror;
 
     for (table) |*ptr, i| {
-        const addr = @intCast(u32, page_size * i);
+        const addr = page_size * i;
 
         ptr.* = switch (addr) {
             // General Internal Memory
             0x0000_0000...0x0000_3FFF => null, // BIOS has it's own checks
-            0x0200_0000...0x02FF_FFFF => &self.ewram.buf[addr & 0x3FFFF],
+            0x0200_0000...0x02FF_FFFF => &bus.ewram.buf[addr & 0x3FFFF],
-            0x0300_0000...0x03FF_FFFF => &self.iwram.buf[addr & 0x7FFF],
+            0x0300_0000...0x03FF_FFFF => &bus.iwram.buf[addr & 0x7FFF],
             0x0400_0000...0x0400_03FF => null, // I/O
 
             // Internal Display Memory
-            0x0500_0000...0x05FF_FFFF => &self.ppu.palette.buf[addr & 0x3FF],
+            0x0500_0000...0x05FF_FFFF => &bus.ppu.palette.buf[addr & 0x3FF],
-            0x0600_0000...0x06FF_FFFF => &self.ppu.vram.buf[vramMirror(addr)],
+            0x0600_0000...0x06FF_FFFF => &bus.ppu.vram.buf[vramMirror(addr)],
-            0x0700_0000...0x07FF_FFFF => &self.ppu.oam.buf[addr & 0x3FF],
+            0x0700_0000...0x07FF_FFFF => &bus.ppu.oam.buf[addr & 0x3FF],
 
             // External Memory (Game Pak)
-            0x0800_0000...0x0DFF_FFFF => self.fillReadTableExternal(addr),
+            0x0800_0000...0x0DFF_FFFF => fillTableExternalMemory(bus, addr),
             0x0E00_0000...0x0FFF_FFFF => null, // SRAM
             else => null,
         };
     }
 }
 
-fn fillWriteTable(self: *Self, comptime T: type, table: *[table_len]?*const anyopaque) void {
+fn fillWriteTable(comptime T: type, bus: *Self, table: *[table_len]?*const anyopaque) void {
     comptime std.debug.assert(T == u32 or T == u16 or T == u8);
-    const vramMirror = @import("ppu/Vram.zig").mirror;
+    const vramMirror = @import("ppu.zig").Vram.mirror;
 
     for (table) |*ptr, i| {
-        const addr = @intCast(u32, page_size * i);
+        const addr = page_size * i;
 
         ptr.* = switch (addr) {
             // General Internal Memory
             0x0000_0000...0x0000_3FFF => null, // BIOS has it's own checks
-            0x0200_0000...0x02FF_FFFF => &self.ewram.buf[addr & 0x3FFFF],
+            0x0200_0000...0x02FF_FFFF => &bus.ewram.buf[addr & 0x3FFFF],
-            0x0300_0000...0x03FF_FFFF => &self.iwram.buf[addr & 0x7FFF],
+            0x0300_0000...0x03FF_FFFF => &bus.iwram.buf[addr & 0x7FFF],
             0x0400_0000...0x0400_03FF => null, // I/O
 
             // Internal Display Memory
-            0x0500_0000...0x05FF_FFFF => if (T != u8) &self.ppu.palette.buf[addr & 0x3FF] else null,
+            0x0500_0000...0x05FF_FFFF => if (T != u8) &bus.ppu.palette.buf[addr & 0x3FF] else null,
-            0x0600_0000...0x06FF_FFFF => if (T != u8) &self.ppu.vram.buf[vramMirror(addr)] else null,
+            0x0600_0000...0x06FF_FFFF => if (T != u8) &bus.ppu.vram.buf[vramMirror(addr)] else null,
-            0x0700_0000...0x07FF_FFFF => if (T != u8) &self.ppu.oam.buf[addr & 0x3FF] else null,
+            0x0700_0000...0x07FF_FFFF => if (T != u8) &bus.ppu.oam.buf[addr & 0x3FF] else null,
 
             // External Memory (Game Pak)
             0x0800_0000...0x0DFF_FFFF => null, // ROM
@@ -155,29 +159,24 @@ fn fillWriteTable(self: *Self, comptime T: type, table: *[table_len]?*const anyo
     }
 }
 
-fn fillReadTableExternal(self: *Self, addr: u32) ?*anyopaque {
+fn fillTableExternalMemory(bus: *Self, addr: usize) ?*anyopaque {
     // see `GamePak.zig` for more information about what conditions need to be true
     // so that a simple pointer dereference isn't possible
 
-    std.debug.assert(addr & @as(u32, page_size - 1) == 0); // addr is guaranteed to be page-aligned
-
     const start_addr = addr;
-    const end_addr = start_addr + page_size;
+    const end_addr = addr + page_size;
 
-    {
+    const gpio_data = start_addr <= 0x0800_00C4 and 0x0800_00C4 < end_addr;
-        const data = start_addr <= 0x0800_00C4 and 0x0800_00C4 < end_addr; // GPIO Data
+    const gpio_direction = start_addr <= 0x0800_00C6 and 0x0800_00C6 < end_addr;
-        const direction = start_addr <= 0x0800_00C6 and 0x0800_00C6 < end_addr; // GPIO Direction
+    const gpio_control = start_addr <= 0x0800_00C8 and 0x0800_00C8 < end_addr;
-        const control = start_addr <= 0x0800_00C8 and 0x0800_00C8 < end_addr; // GPIO Control
 
-        const has_gpio = data or direction or control;
+    if (bus.pak.gpio.device.kind != .None and (gpio_data or gpio_direction or gpio_control)) {
-        const gpio_kind = self.pak.gpio.device.kind;
+        // We found a GPIO device, and this page a GPIO register. We want to handle this in slowmem
-
+        return null;
-        // There is a GPIO Device, and the current page contains at least one memory-mapped GPIO register
-        if (gpio_kind != .None and has_gpio) return null;
     }
 
-    if (self.pak.backup.kind == .Eeprom) {
+    if (bus.pak.backup.kind == .Eeprom) {
-        if (self.pak.buf.len > 0x100_000) {
+        if (bus.pak.buf.len > 0x100_000) {
             // We are using a "large" EEPROM which means that if the below check is true
             // this page has an address that's reserved for the EEPROM and therefore must
             // be handled in slowmem
@@ -193,33 +192,13 @@ fn fillReadTableExternal(self: *Self, addr: u32) ?*anyopaque {
     // Finally, the GamePak has some unique behaviour for reads past the end of the ROM,
     // so those will be handled by slowmem as well
     const masked_addr = addr & 0x1FF_FFFF;
-    if (masked_addr >= self.pak.buf.len) return null;
+    if (masked_addr >= bus.pak.buf.len) return null;
 
-    return &self.pak.buf[masked_addr];
+    return &bus.pak.buf[masked_addr];
 }
 
+// TODO: Take advantage of fastmem here too?
 pub fn dbgRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
-    const bits = @typeInfo(std.math.IntFittingRange(0, page_size - 1)).Int.bits;
-    const page = unaligned_address >> bits;
-    const offset = unaligned_address & (page_size - 1);
-
-    // We're doing some serious out-of-bounds open-bus reads
-    if (page >= table_len) return self.openBus(T, unaligned_address);
-
-    if (self.read_table[page]) |some_ptr| {
-        // We have a pointer to a page, cast the pointer to it's underlying type
-        const Ptr = [*]const T;
-        const ptr = @ptrCast(Ptr, @alignCast(@alignOf(std.meta.Child(Ptr)), some_ptr));
-
-        // Note: We don't check array length, since we force align the
-        // lower bits of the address as the GBA would
-        return ptr[forceAlign(T, offset) / @sizeOf(T)];
-    }
-
-    return self.dbgSlowRead(T, unaligned_address);
-}
-
-fn dbgSlowRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
     const page = @truncate(u8, unaligned_address >> 24);
     const address = forceAlign(T, unaligned_address);
 
@@ -227,22 +206,33 @@ fn dbgSlowRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
         // General Internal Memory
         0x00 => blk: {
             if (address < Bios.size)
-                break :blk self.bios.dbgRead(T, self.cpu.r[15], unaligned_address);
+                break :blk self.bios.dbgRead(T, self.cpu.r[15], address);
 
             break :blk self.openBus(T, address);
         },
-        0x02 => unreachable, // handled by fastmem
+        0x02 => self.ewram.read(T, address),
-        0x03 => unreachable, // handled by fastmem
+        0x03 => self.iwram.read(T, address),
         0x04 => self.readIo(T, address),
 
         // Internal Display Memory
-        0x05 => unreachable, // handled by fastmem
+        0x05 => self.ppu.palette.read(T, address),
-        0x06 => unreachable, // handled by fastmem
+        0x06 => self.ppu.vram.read(T, address),
-        0x07 => unreachable, // handled by fastmem
+        0x07 => self.ppu.oam.read(T, address),
 
         // External Memory (Game Pak)
         0x08...0x0D => self.pak.dbgRead(T, address),
-        0x0E...0x0F => self.readBackup(T, unaligned_address),
+        0x0E...0x0F => blk: {
+            const value = self.pak.backup.read(unaligned_address);
+
+            const multiplier = switch (T) {
+                u32 => 0x01010101,
+                u16 => 0x0101,
+                u8 => 1,
+                else => @compileError("Backup: Unsupported read width"),
+            };
+
+            break :blk @as(T, value) * multiplier;
+        },
         else => self.openBus(T, address),
     };
 }
@@ -326,7 +316,8 @@ pub fn read(self: *Self, comptime T: type, unaligned_address: u32) T {
     if (self.read_table[page]) |some_ptr| {
         // We have a pointer to a page, cast the pointer to it's underlying type
         const Ptr = [*]const T;
-        const ptr = @ptrCast(Ptr, @alignCast(@alignOf(std.meta.Child(Ptr)), some_ptr));
+        const alignment = @alignOf(std.meta.Child(Ptr));
+        const ptr = @ptrCast(Ptr, @alignCast(alignment, some_ptr));
 
         // Note: We don't check array length, since we force align the
         // lower bits of the address as the GBA would
@@ -346,7 +337,7 @@ fn slowRead(self: *Self, comptime T: type, unaligned_address: u32) T {
         // General Internal Memory
         0x00 => blk: {
             if (address < Bios.size)
-                break :blk self.bios.read(T, self.cpu.r[15], unaligned_address);
+                break :blk self.bios.read(T, self.cpu.r[15], address);
 
             break :blk self.openBus(T, address);
         },
@@ -361,24 +352,22 @@ fn slowRead(self: *Self, comptime T: type, unaligned_address: u32) T {
 
         // External Memory (Game Pak)
         0x08...0x0D => self.pak.read(T, address),
-        0x0E...0x0F => self.readBackup(T, unaligned_address),
+        0x0E...0x0F => blk: {
+            const value = self.pak.backup.read(unaligned_address);
+
+            const multiplier = switch (T) {
+                u32 => 0x01010101,
+                u16 => 0x0101,
+                u8 => 1,
+                else => @compileError("Backup: Unsupported read width"),
+            };
+
+            break :blk @as(T, value) * multiplier;
+        },
         else => self.openBus(T, address),
     };
 }
 
-fn readBackup(self: *const Self, comptime T: type, unaligned_address: u32) T {
-    const value = self.pak.backup.read(unaligned_address);
-
-    const multiplier = switch (T) {
-        u32 => 0x01010101,
-        u16 => 0x0101,
-        u8 => 1,
-        else => @compileError("Backup: Unsupported read width"),
-    };
-
-    return @as(T, value) * multiplier;
-}
-
 pub fn write(self: *Self, comptime T: type, unaligned_address: u32, value: T) void {
     const bits = @typeInfo(std.math.IntFittingRange(0, page_size - 1)).Int.bits;
     const page = unaligned_address >> bits;
@@ -393,7 +382,8 @@ pub fn write(self: *Self, comptime T: type, unaligned_address: u32, value: T) vo
     if (self.write_tables[@boolToInt(T == u8)][page]) |some_ptr| {
         // We have a pointer to a page, cast the pointer to it's underlying type
         const Ptr = [*]T;
-        const ptr = @ptrCast(Ptr, @alignCast(@alignOf(std.meta.Child(Ptr)), some_ptr));
+        const alignment = @alignOf(std.meta.Child(Ptr));
+        const ptr = @ptrCast(Ptr, @alignCast(alignment, some_ptr));
 
         // Note: We don't check array length, since we force align the
         // lower bits of the address as the GBA would
@@ -406,9 +396,8 @@ pub fn write(self: *Self, comptime T: type, unaligned_address: u32, value: T) vo
     }
 }
 
-fn slowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) void {
+pub fn slowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) void {
-    @setCold(true);
+    // @setCold(true);
-
     const page = @truncate(u8, unaligned_address >> 24);
     const address = forceAlign(T, unaligned_address);
 
@@ -436,11 +425,11 @@ inline fn rotateBy(comptime T: type, address: u32) u32 {
         u32 => address & 3,
         u16 => address & 1,
         u8 => 0,
-        else => @compileError("Unsupported write width"),
+        else => @compileError("Backup: Unsupported write width"),
     };
 }
 
-pub inline fn forceAlign(comptime T: type, address: u32) u32 {
+inline fn forceAlign(comptime T: type, address: u32) u32 {
     return switch (T) {
         u32 => address & ~@as(u32, 3),
         u16 => address & ~@as(u32, 1),

src/core/apu.zig

@@ -15,12 +15,10 @@ const SoundFifo = std.fifo.LinearFifo(u8, .{ .Static = 0x20 });
 const getHalf = util.getHalf;
 const setHalf = util.setHalf;
 const intToBytes = util.intToBytes;
+const RingBuffer = util.RingBuffer;
 
 const log = std.log.scoped(.APU);
 
-pub const host_rate = @import("../platform.zig").sample_rate;
-pub const host_format = @import("../platform.zig").sample_format;
-
 pub fn read(comptime T: type, apu: *const Apu, addr: u32) ?T {
     const byte_addr = @truncate(u8, addr);
 
@@ -246,17 +244,20 @@ pub const Apu = struct {
 
     sampling_cycle: u2,
 
-    stream: *SDL.SDL_AudioStream,
+    sample_queue: RingBuffer(u16),
     sched: *Scheduler,
 
     fs: FrameSequencer,
     capacitor: f32,
 
-    is_buffer_full: bool,
-
     pub const Tick = enum { Length, Envelope, Sweep };
 
     pub fn init(sched: *Scheduler) Self {
+        const NUM_CHANNELS: usize = 2;
+
+        const allocator = std.heap.c_allocator;
+        const sample_buf = allocator.alloc(u16, 0x800 * NUM_CHANNELS) catch @panic("failed to allocate sample buffer");
+
         const apu: Self = .{
             .ch1 = ToneSweep.init(sched),
             .ch2 = Tone.init(sched),
@@ -271,12 +272,11 @@ pub const Apu = struct {
             .bias = .{ .raw = 0x0200 },
 
             .sampling_cycle = 0b00,
-            .stream = SDL.SDL_NewAudioStream(SDL.AUDIO_U16, 2, 1 << 15, host_format, 2, host_rate).?,
+            .sample_queue = RingBuffer(u16).init(sample_buf),
             .sched = sched,
 
             .capacitor = 0,
             .fs = FrameSequencer.init(),
-            .is_buffer_full = false,
         };
 
         sched.push(.SampleAudio, apu.interval());
@@ -370,11 +370,6 @@ pub const Apu = struct {
     pub fn sampleAudio(self: *Self, late: u64) void {
         self.sched.push(.SampleAudio, self.interval() -| late);
 
-        // Whether the APU is busy or not is determined  by the main loop in emu.zig
-        // This should only ever be true (because this side of the emu is single threaded)
-        // When audio sync is disaabled
-        if (self.is_buffer_full) return;
-
         var left: i16 = 0;
         var right: i16 = 0;
 
@@ -430,23 +425,7 @@ pub const Apu = struct {
         const ext_left = (clamped_left << 5) | (clamped_left >> 6);
         const ext_right = (clamped_right << 5) | (clamped_right >> 6);
 
-        if (self.sampling_cycle != self.bias.sampling_cycle.read()) self.replaceSDLResampler();
+        self.sample_queue.push(ext_left, ext_right) catch {};
-
-        _ = SDL.SDL_AudioStreamPut(self.stream, &[2]u16{ ext_left, ext_right }, 2 * @sizeOf(u16));
-    }
-
-    fn replaceSDLResampler(self: *Self) void {
-        @setCold(true);
-        const sample_rate = Self.sampleRate(self.bias.sampling_cycle.read());
-        log.info("Sample Rate changed from {}Hz to {}Hz", .{ Self.sampleRate(self.sampling_cycle), sample_rate });
-
-        // Sampling Cycle (Sample Rate) changed, Craete a new SDL Audio Resampler
-        // FIXME: Replace SDL's Audio Resampler with either a custom or more reliable one
-        const old_stream = self.stream;
-        defer SDL.SDL_FreeAudioStream(old_stream);
-
-        self.sampling_cycle = self.bias.sampling_cycle.read();
-        self.stream = SDL.SDL_NewAudioStream(SDL.AUDIO_U16, 2, @intCast(c_int, sample_rate), host_format, 2, host_rate).?;
     }
 
     fn interval(self: *const Self) u64 {

src/core/bus/Bios.zig

@@ -3,9 +3,6 @@ const std = @import("std");
 const Allocator = std.mem.Allocator;
 const log = std.log.scoped(.Bios);
 
-const rotr = @import("../../util.zig").rotr;
-const forceAlign = @import("../Bus.zig").forceAlign;
-
 /// Size of the BIOS in bytes
 pub const size = 0x4000;
 const Self = @This();
@@ -13,37 +10,21 @@ const Self = @This();
 buf: ?[]u8,
 allocator: Allocator,
 
-addr_latch: u32 = 0,
+addr_latch: u32,
 
-// https://github.com/ITotalJustice/notorious_beeg/issues/106
+pub fn read(self: *Self, comptime T: type, r15: u32, addr: u32) T {
-pub fn read(self: *Self, comptime T: type, r15: u32, address: u32) T {
     if (r15 < Self.size) {
-        const addr = forceAlign(T, address);
-
         self.addr_latch = addr;
         return self._read(T, addr);
     }
 
-    log.warn("Open Bus! Read from 0x{X:0>8}, but PC was 0x{X:0>8}", .{ address, r15 });
+    log.debug("Rejected read since r15=0x{X:0>8}", .{r15});
-    const value = self._read(u32, self.addr_latch);
+    return @truncate(T, self._read(T, self.addr_latch));
-
-    return @truncate(T, rotr(u32, value, 8 * rotateBy(T, address)));
 }
 
-fn rotateBy(comptime T: type, address: u32) u32 {
+pub fn dbgRead(self: *const Self, comptime T: type, r15: u32, addr: u32) T {
-    return switch (T) {
+    if (r15 < Self.size) return self._read(T, addr);
-        u8 => address & 3,
+    return @truncate(T, self._read(T, self.addr_latch + 8));
-        u16 => address & 2,
-        u32 => 0,
-        else => @compileError("bios: unsupported read width"),
-    };
-}
-
-pub fn dbgRead(self: *const Self, comptime T: type, r15: u32, address: u32) T {
-    if (r15 < Self.size) return self._read(T, forceAlign(T, address));
-
-    const value = self._read(u32, self.addr_latch);
-    return @truncate(T, rotr(u32, value, 8 * rotateBy(T, address)));
 }
 
 /// Read without the GBA safety checks
@@ -62,19 +43,18 @@ pub fn write(_: *Self, comptime T: type, addr: u32, value: T) void {
 }
 
 pub fn init(allocator: Allocator, maybe_path: ?[]const u8) !Self {
-    if (maybe_path == null) return .{ .buf = null, .allocator = allocator };
+    const buf: ?[]u8 = if (maybe_path) |path| blk: {
-    const path = maybe_path.?;
+        const file = try std.fs.cwd().openFile(path, .{});
+        defer file.close();
 
-    const buf = try allocator.alloc(u8, Self.size);
+        break :blk try file.readToEndAlloc(allocator, try file.getEndPos());
-    errdefer allocator.free(buf);
+    } else null;
 
-    const file = try std.fs.cwd().openFile(path, .{});
+    return Self{
-    defer file.close();
+        .buf = buf,
-
+        .allocator = allocator,
-    const file_len = try file.readAll(buf);
+        .addr_latch = 0,
-    if (file_len != Self.size) log.err("Expected BIOS to be {}B, was {}B", .{ Self.size, file_len });
+    };
-
-    return Self{ .buf = buf, .allocator = allocator };
 }
 
 pub fn deinit(self: *Self) void {

src/core/bus/GamePak.zig

@@ -188,7 +188,7 @@ pub fn init(allocator: Allocator, cpu: *Arm7tdmi, rom_path: []const u8, save_pat
     const kind = Backup.guess(file_buf);
     const device = if (config.config().guest.force_rtc) .Rtc else guessDevice(file_buf);
 
-    logHeader(file_buf, title);
+    logHeader(file_buf, &title);
 
     return .{
         .buf = file_buf,
@@ -219,17 +219,19 @@ fn guessDevice(buf: []const u8) Gpio.Device.Kind {
     }
 
     // TODO: Detect other GPIO devices
+
     return .None;
 }
 
-fn logHeader(buf: []const u8, title: [12]u8) void {
+fn logHeader(buf: []const u8, title: *const [12]u8) void {
-    const ver = buf[0xBC];
+    const code = buf[0xAC..0xB0];
+    const maker = buf[0xB0..0xB2];
+    const version = buf[0xBC];
 
     log.info("Title: {s}", .{title});
-    if (ver != 0) log.info("Version: {}", .{ver});
+    if (version != 0) log.info("Version: {}", .{version});
-
+    log.info("Game Code: {s}", .{code});
-    log.info("Game Code: {s}", .{buf[0xAC..0xB0]});
+    log.info("Maker Code: {s}", .{maker});
-    log.info("Maker Code: {s}", .{buf[0xB0..0xB2]});
 }
 
 test "OOB Access" {

src/core/bus/dma.zig

@@ -338,7 +338,7 @@ fn DmaController(comptime id: u2) type {
     };
 }
 
-pub fn onBlanking(bus: *Bus, comptime kind: DmaKind) void {
+pub fn pollDmaOnBlank(bus: *Bus, comptime kind: DmaKind) void {
     comptime var i: usize = 0;
     inline while (i < 4) : (i += 1) {
         bus.dma[i].poll(kind);

src/core/bus/io.zig

@@ -346,10 +346,10 @@ const InterruptEnable = extern union {
     vblank: Bit(u16, 0),
     hblank: Bit(u16, 1),
     coincidence: Bit(u16, 2),
-    tim0: Bit(u16, 3),
+    tm0_overflow: Bit(u16, 3),
-    tim1: Bit(u16, 4),
+    tm1_overflow: Bit(u16, 4),
-    tim2: Bit(u16, 5),
+    tm2_overflow: Bit(u16, 5),
-    tim3: Bit(u16, 6),
+    tm3_overflow: Bit(u16, 6),
     serial: Bit(u16, 7),
     dma0: Bit(u16, 8),
     dma1: Bit(u16, 9),
@@ -449,8 +449,6 @@ pub const BldY = extern union {
     raw: u16,
 };
 
-const u8WriteKind = enum { Hi, Lo };
-
 /// Write-only
 pub const WinH = extern union {
     x2: Bitfield(u16, 0, 8),
@@ -460,8 +458,6 @@ pub const WinH = extern union {
 
 /// Write-only
 pub const WinV = extern union {
-    const Self = @This();
-
     y2: Bitfield(u16, 0, 8),
     y1: Bitfield(u16, 8, 8),
     raw: u16,
@@ -470,20 +466,20 @@ pub const WinV = extern union {
 pub const WinIn = extern union {
     w0_bg: Bitfield(u16, 0, 4),
     w0_obj: Bit(u16, 4),
-    w0_bld: Bit(u16, 5),
+    w0_colour: Bit(u16, 5),
     w1_bg: Bitfield(u16, 8, 4),
     w1_obj: Bit(u16, 12),
-    w1_bld: Bit(u16, 13),
+    w1_colour: Bit(u16, 13),
     raw: u16,
 };
 
 pub const WinOut = extern union {
     out_bg: Bitfield(u16, 0, 4),
     out_obj: Bit(u16, 4),
-    out_bld: Bit(u16, 5),
+    out_colour: Bit(u16, 5),
     obj_bg: Bitfield(u16, 8, 4),
     obj_obj: Bit(u16, 12),
-    obj_bld: Bit(u16, 13),
+    obj_colour: Bit(u16, 13),
     raw: u16,
 };
 

src/core/cpu.zig

@@ -647,7 +647,7 @@ pub const PSR = extern union {
     }
 };
 
-pub const Mode = enum(u5) {
+const Mode = enum(u5) {
     User = 0b10000,
     Fiq = 0b10001,
     Irq = 0b10010,
@@ -656,7 +656,7 @@ pub const Mode = enum(u5) {
     Undefined = 0b11011,
     System = 0b11111,
 
-    pub fn toString(self: Mode) []const u8 {
+    fn toString(self: Mode) []const u8 {
         return switch (self) {
             .User => "usr",
             .Fiq => "fiq",

src/core/cpu/arm/data_processing.zig

@@ -24,7 +24,7 @@ pub fn dataProcessing(comptime I: bool, comptime S: bool, comptime kind: u4) Ins
             if (!I and opcode >> 4 & 1 == 1) cpu.r[15] -= 4;
 
             var result: u32 = undefined;
-            var overflow: u1 = undefined;
+            var overflow: bool = undefined;
 
             // Perform Data Processing Logic
             switch (kind) {
@@ -62,9 +62,7 @@ pub fn dataProcessing(comptime I: bool, comptime S: bool, comptime kind: u4) Ins
                     if (rd == 0xF)
                         return undefinedTestBehaviour(cpu);
 
-                    const tmp = @addWithOverflow(op1, op2);
+                    overflow = @addWithOverflow(u32, op1, op2, &result);
-                    result = tmp[0];
-                    overflow = tmp[1];
                 },
                 0xC => result = op1 | op2, // ORR
                 0xD => result = op2, // MOV
@@ -112,7 +110,7 @@ pub fn dataProcessing(comptime I: bool, comptime S: bool, comptime kind: u4) Ins
                     // ADD, ADC Flags
                     cpu.cpsr.n.write(result >> 31 & 1 == 1);
                     cpu.cpsr.z.write(result == 0);
-                    cpu.cpsr.c.write(overflow == 0b1);
+                    cpu.cpsr.c.write(overflow);
                     cpu.cpsr.v.write(((op1 ^ result) & (op2 ^ result)) >> 31 & 1 == 1);
                 },
                 0x6, 0x7 => if (S and rd != 0xF) {
@@ -143,7 +141,7 @@ pub fn dataProcessing(comptime I: bool, comptime S: bool, comptime kind: u4) Ins
                         cpu.cpsr.v.write(((op1 ^ result) & (~op2 ^ result)) >> 31 & 1 == 1);
                     } else if (kind == 0xB) {
                         // CMN specific
-                        cpu.cpsr.c.write(overflow == 0b1);
+                        cpu.cpsr.c.write(overflow);
                         cpu.cpsr.v.write(((op1 ^ result) & (op2 ^ result)) >> 31 & 1 == 1);
                     } else {
                         // TST, TEQ specific
@@ -164,19 +162,19 @@ pub fn sbc(left: u32, right: u32, old_carry: u1) u32 {
     return ret;
 }
 
-pub fn add(overflow: *u1, left: u32, right: u32) u32 {
+pub fn add(overflow: *bool, left: u32, right: u32) u32 {
-    const ret = @addWithOverflow(left, right);
+    var ret: u32 = undefined;
-    overflow.* = ret[1];
+    overflow.* = @addWithOverflow(u32, left, right, &ret);
-
+    return ret;
-    return ret[0];
 }
 
-pub fn adc(overflow: *u1, left: u32, right: u32, old_carry: u1) u32 {
+pub fn adc(overflow: *bool, left: u32, right: u32, old_carry: u1) u32 {
-    const tmp = @addWithOverflow(left, right);
+    var ret: u32 = undefined;
-    const ret = @addWithOverflow(tmp[0], old_carry);
+    const first = @addWithOverflow(u32, left, right, &ret);
-    overflow.* = tmp[1] | ret[1];
+    const second = @addWithOverflow(u32, ret, old_carry, &ret);
 
-    return ret[0];
+    overflow.* = first or second;
+    return ret;
 }
 
 fn undefinedTestBehaviour(cpu: *Arm7tdmi) void {

src/core/cpu/arm/single_data_transfer.zig

@@ -11,7 +11,9 @@ pub fn singleDataTransfer(comptime I: bool, comptime P: bool, comptime U: bool,
             const rn = opcode >> 16 & 0xF;
             const rd = opcode >> 12 & 0xF;
 
-            const base = cpu.r[rn];
+            // rn is r15 and L is not set, the PC is 12 ahead
+            const base = cpu.r[rn] + if (!L and rn == 0xF) 4 else @as(u32, 0);
+
             const offset = if (I) shifter.immediate(false, cpu, opcode) else opcode & 0xFFF;
 
             const modified_base = if (U) base +% offset else base -% offset;

src/core/cpu/thumb/alu.zig

@@ -21,8 +21,7 @@ pub fn fmt4(comptime op: u4) InstrFn {
             const op2 = cpu.r[rs];
 
             var result: u32 = undefined;
-            var overflow: u1 = undefined;
+            var overflow: bool = undefined;
-
             switch (op) {
                 0x0 => result = op1 & op2, // AND
                 0x1 => result = op1 ^ op2, // EOR
@@ -35,12 +34,7 @@ pub fn fmt4(comptime op: u4) InstrFn {
                 0x8 => result = op1 & op2, // TST
                 0x9 => result = 0 -% op2, // NEG
                 0xA => result = op1 -% op2, // CMP
-                0xB => {
+                0xB => overflow = @addWithOverflow(u32, op1, op2, &result), // CMN
-                    // CMN
-                    const tmp = @addWithOverflow(op1, op2);
-                    result = tmp[0];
-                    overflow = tmp[1];
-                },
                 0xC => result = op1 | op2, // ORR
                 0xD => result = @truncate(u32, @as(u64, op2) * @as(u64, op1)),
                 0xE => result = op1 & ~op2,
@@ -77,7 +71,7 @@ pub fn fmt4(comptime op: u4) InstrFn {
                     // ADC, CMN
                     cpu.cpsr.n.write(result >> 31 & 1 == 1);
                     cpu.cpsr.z.write(result == 0);
-                    cpu.cpsr.c.write(overflow == 0b1);
+                    cpu.cpsr.c.write(overflow);
                     cpu.cpsr.v.write(((op1 ^ result) & (op2 ^ result)) >> 31 & 1 == 1);
                 },
                 0x6 => {

src/core/cpu/thumb/data_processing.zig

@@ -64,7 +64,7 @@ pub fn fmt5(comptime op: u2, comptime h1: u1, comptime h2: u1) InstrFn {
             const op2 = cpu.r[rs];
 
             var result: u32 = undefined;
-            var overflow: u1 = undefined;
+            var overflow: bool = undefined;
             switch (op) {
                 0b00 => result = add(&overflow, op1, op2), // ADD
                 0b01 => result = op1 -% op2, // CMP
@@ -126,13 +126,13 @@ pub fn fmt2(comptime I: bool, is_sub: bool, rn: u3) InstrFn {
                 cpu.cpsr.v.write(((op1 ^ result) & (~op2 ^ result)) >> 31 & 1 == 1);
             } else {
                 // ADD
-                var overflow: u1 = undefined;
+                var overflow: bool = undefined;
                 const result = add(&overflow, op1, op2);
                 cpu.r[rd] = result;
 
                 cpu.cpsr.n.write(result >> 31 & 1 == 1);
                 cpu.cpsr.z.write(result == 0);
-                cpu.cpsr.c.write(overflow == 0b1);
+                cpu.cpsr.c.write(overflow);
                 cpu.cpsr.v.write(((op1 ^ result) & (op2 ^ result)) >> 31 & 1 == 1);
             }
         }
@@ -145,7 +145,7 @@ pub fn fmt3(comptime op: u2, comptime rd: u3) InstrFn {
             const op1 = cpu.r[rd];
             const op2: u32 = opcode & 0xFF; // Offset
 
-            var overflow: u1 = undefined;
+            var overflow: bool = undefined;
             const result: u32 = switch (op) {
                 0b00 => op2, // MOV
                 0b01 => op1 -% op2, // CMP
@@ -169,7 +169,7 @@ pub fn fmt3(comptime op: u2, comptime rd: u3) InstrFn {
                 },
                 0b10 => {
                     // ADD
-                    cpu.cpsr.c.write(overflow == 0b1);
+                    cpu.cpsr.c.write(overflow);
                     cpu.cpsr.v.write(((op1 ^ result) & (op2 ^ result)) >> 31 & 1 == 1);
                 },
             }

src/core/emu.zig

@@ -4,7 +4,8 @@ const config = @import("../config.zig");
 
 const Scheduler = @import("scheduler.zig").Scheduler;
 const Arm7tdmi = @import("cpu.zig").Arm7tdmi;
-const Tracker = @import("../util.zig").FpsTracker;
+const FpsTracker = @import("../util.zig").FpsTracker;
+const RingBuffer = @import("../util.zig").RingBuffer;
 
 const Timer = std.time.Timer;
 const Atomic = std.atomic.Atomic;
@@ -35,18 +36,18 @@ const RunKind = enum {
     LimitedFPS,
 };
 
-pub fn run(quit: *Atomic(bool), pause: *Atomic(bool), cpu: *Arm7tdmi, scheduler: *Scheduler, tracker: *Tracker) void {
+pub fn run(quit: *Atomic(bool), scheduler: *Scheduler, cpu: *Arm7tdmi, tracker: *FpsTracker) 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, quit, scheduler, cpu, tracker);
     } else {
-        inner(.UnlimitedFPS, audio_sync, quit, pause, cpu, scheduler, tracker);
+        inner(.UnlimitedFPS, audio_sync, quit, scheduler, cpu, tracker);
     }
 }
 
-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, quit: *Atomic(bool), scheduler: *Scheduler, cpu: *Arm7tdmi, tracker: ?*FpsTracker) void {
     if (kind == .UnlimitedFPS or kind == .LimitedFPS) {
         std.debug.assert(tracker != null);
         log.info("FPS tracking enabled", .{});
@@ -57,10 +58,8 @@ fn inner(comptime kind: RunKind, audio_sync: bool, quit: *Atomic(bool), pause: *
             log.info("Emulation w/out video sync", .{});
 
             while (!quit.load(.Monotonic)) {
-                if (pause.load(.Monotonic)) continue;
-
                 runFrame(scheduler, cpu);
-                audioSync(audio_sync, cpu.bus.apu.stream, &cpu.bus.apu.is_buffer_full);
+                audioSync(audio_sync, &cpu.bus.apu.sample_queue);
 
                 if (kind == .UnlimitedFPS) tracker.?.tick();
             }
@@ -71,8 +70,6 @@ fn inner(comptime kind: RunKind, audio_sync: bool, quit: *Atomic(bool), pause: *
             var wake_time: u64 = frame_period;
 
             while (!quit.load(.Monotonic)) {
-                if (pause.load(.Monotonic)) continue;
-
                 runFrame(scheduler, cpu);
                 const new_wake_time = videoSync(&timer, wake_time);
 
@@ -81,7 +78,7 @@ fn inner(comptime kind: RunKind, audio_sync: bool, quit: *Atomic(bool), pause: *
                 // the amount of time needed for audio to catch up rather than
                 // our expected wake-up time
 
-                audioSync(audio_sync, cpu.bus.apu.stream, &cpu.bus.apu.is_buffer_full);
+                audioSync(audio_sync, &cpu.bus.apu.sample_queue);
                 if (!audio_sync) spinLoop(&timer, wake_time);
                 wake_time = new_wake_time;
 
@@ -98,7 +95,7 @@ pub fn runFrame(sched: *Scheduler, cpu: *Arm7tdmi) void {
         if (!cpu.stepDmaTransfer()) {
             if (cpu.isHalted()) {
                 // Fast-forward to next Event
-                sched.tick = sched.nextTimestamp();
+                sched.tick = sched.queue.peek().?.tick;
             } else {
                 cpu.step();
             }
@@ -108,22 +105,13 @@ pub fn runFrame(sched: *Scheduler, cpu: *Arm7tdmi) void {
     }
 }
 
-fn audioSync(audio_sync: bool, stream: *SDL.SDL_AudioStream, is_buffer_full: *bool) void {
+fn audioSync(audio_sync: bool, sample_queue: *RingBuffer(u16)) void {
     comptime std.debug.assert(@import("../platform.zig").sample_format == SDL.AUDIO_U16);
-    const sample_size = 2 * @sizeOf(u16);
+    // const sample_size = 2 * @sizeOf(u16);
-    const max_buf_size: c_int = 0x400;
+    // const max_buf_size: c_int = 0x400;
 
-    // Determine whether the APU is busy right at this moment
+    _ = audio_sync;
-    var still_full: bool = SDL.SDL_AudioStreamAvailable(stream) > sample_size * if (is_buffer_full.*) max_buf_size >> 1 else max_buf_size;
+    _ = sample_queue;
-    defer is_buffer_full.* = still_full; // Update APU Busy status right before exiting scope
-
-    // If Busy is false, there's no need to sync here
-    if (!still_full) return;
-
-    while (true) {
-        still_full = SDL.SDL_AudioStreamAvailable(stream) > sample_size * max_buf_size >> 1;
-        if (!audio_sync or !still_full) break;
-    }
 }
 
 fn videoSync(timer: *Timer, wake_time: u64) u64 {

src/core/ppu/Oam.zig

@@ -1,40 +0,0 @@
-const std = @import("std");
-
-const Allocator = std.mem.Allocator;
-
-const buf_len = 0x400;
-const Self = @This();
-
-buf: []u8,
-allocator: Allocator,
-
-pub fn read(self: *const Self, comptime T: type, address: usize) T {
-    const addr = address & 0x3FF;
-
-    return switch (T) {
-        u32, u16, u8 => std.mem.readIntSliceLittle(T, self.buf[addr..][0..@sizeOf(T)]),
-        else => @compileError("OAM: Unsupported read width"),
-    };
-}
-
-pub fn write(self: *Self, comptime T: type, address: usize, value: T) void {
-    const addr = address & 0x3FF;
-
-    switch (T) {
-        u32, u16 => std.mem.writeIntSliceLittle(T, self.buf[addr..][0..@sizeOf(T)], value),
-        u8 => return, // 8-bit writes are explicitly ignored
-        else => @compileError("OAM: Unsupported write width"),
-    }
-}
-
-pub fn init(allocator: Allocator) !Self {
-    const buf = try allocator.alloc(u8, buf_len);
-    std.mem.set(u8, buf, 0);
-
-    return Self{ .buf = buf, .allocator = allocator };
-}
-
-pub fn deinit(self: *Self) void {
-    self.allocator.free(self.buf);
-    self.* = undefined;
-}

src/core/ppu/Palette.zig

@@ -1,47 +0,0 @@
-const std = @import("std");
-
-const Allocator = std.mem.Allocator;
-
-const buf_len = 0x400;
-const Self = @This();
-
-buf: []u8,
-allocator: Allocator,
-
-pub fn read(self: *const Self, comptime T: type, address: usize) T {
-    const addr = address & 0x3FF;
-
-    return switch (T) {
-        u32, u16, u8 => std.mem.readIntSliceLittle(T, self.buf[addr..][0..@sizeOf(T)]),
-        else => @compileError("PALRAM: Unsupported read width"),
-    };
-}
-
-pub fn write(self: *Self, comptime T: type, address: usize, value: T) void {
-    const addr = address & 0x3FF;
-
-    switch (T) {
-        u32, u16 => std.mem.writeIntSliceLittle(T, self.buf[addr..][0..@sizeOf(T)], value),
-        u8 => {
-            const align_addr = addr & ~@as(u32, 1); // Aligned to Halfword boundary
-            std.mem.writeIntSliceLittle(u16, self.buf[align_addr..][0..@sizeOf(u16)], @as(u16, value) * 0x101);
-        },
-        else => @compileError("PALRAM: Unsupported write width"),
-    }
-}
-
-pub fn init(allocator: Allocator) !Self {
-    const buf = try allocator.alloc(u8, buf_len);
-    std.mem.set(u8, buf, 0);
-
-    return Self{ .buf = buf, .allocator = allocator };
-}
-
-pub fn deinit(self: *Self) void {
-    self.allocator.free(self.buf);
-    self.* = undefined;
-}
-
-pub inline fn backdrop(self: *const Self) u16 {
-    return std.mem.readIntNative(u16, self.buf[0..2]);
-}

src/core/ppu/Vram.zig

@@ -1,60 +0,0 @@
-const std = @import("std");
-const io = @import("../bus/io.zig");
-
-const Allocator = std.mem.Allocator;
-
-const buf_len = 0x18000;
-const Self = @This();
-
-buf: []u8,
-allocator: Allocator,
-
-pub fn read(self: *const Self, comptime T: type, address: usize) T {
-    const addr = Self.mirror(address);
-
-    return switch (T) {
-        u32, u16, u8 => std.mem.readIntSliceLittle(T, self.buf[addr..][0..@sizeOf(T)]),
-        else => @compileError("VRAM: Unsupported read width"),
-    };
-}
-
-pub fn write(self: *Self, comptime T: type, dispcnt: io.DisplayControl, address: usize, value: T) void {
-    const mode: u3 = dispcnt.bg_mode.read();
-    const idx = Self.mirror(address);
-
-    switch (T) {
-        u32, u16 => std.mem.writeIntSliceLittle(T, self.buf[idx..][0..@sizeOf(T)], value),
-        u8 => {
-            // Ignore write if it falls within the boundaries of OBJ VRAM
-            switch (mode) {
-                0, 1, 2 => if (0x0001_0000 <= idx) return,
-                else => if (0x0001_4000 <= idx) return,
-            }
-
-            const align_idx = idx & ~@as(u32, 1); // Aligned to a halfword boundary
-            std.mem.writeIntSliceLittle(u16, self.buf[align_idx..][0..@sizeOf(u16)], @as(u16, value) * 0x101);
-        },
-        else => @compileError("VRAM: Unsupported write width"),
-    }
-}
-
-pub fn init(allocator: Allocator) !Self {
-    const buf = try allocator.alloc(u8, buf_len);
-    std.mem.set(u8, buf, 0);
-
-    return Self{ .buf = buf, .allocator = allocator };
-}
-
-pub fn deinit(self: *Self) void {
-    self.allocator.free(self.buf);
-    self.* = undefined;
-}
-
-pub fn mirror(address: usize) usize {
-    // Mirrored in steps of 128K (64K + 32K + 32K) (abcc)
-    const addr = address & 0x1FFFF;
-
-    // If the address is within 96K we don't do anything,
-    // otherwise we want to mirror the last 32K (addresses between 64K and 96K)
-    return if (addr < buf_len) addr else 0x10000 + (addr & 0x7FFF);
-}

src/core/scheduler.zig

@@ -31,55 +31,61 @@ pub const Scheduler = struct {
     }
 
     pub fn handleEvent(self: *Self, cpu: *Arm7tdmi) void {
-        const event = self.queue.remove();
+        if (self.queue.removeOrNull()) |event| {
-        const late = self.tick - event.tick;
+            const late = self.tick - event.tick;
 
-        switch (event.kind) {
+            switch (event.kind) {
-            .HeatDeath => {
+                .HeatDeath => {
-                log.err("u64 overflow. This *actually* should never happen.", .{});
+                    log.err("u64 overflow. This *actually* should never happen.", .{});
-                unreachable;
+                    unreachable;
-            },
+                },
-            .Draw => {
+                .Draw => {
-                // The end of a VDraw
+                    // The end of a VDraw
-                cpu.bus.ppu.drawScanline();
+                    cpu.bus.ppu.drawScanline();
-                cpu.bus.ppu.onHdrawEnd(cpu, late);
+                    cpu.bus.ppu.onHdrawEnd(cpu, late);
-            },
+                },
-            .TimerOverflow => |id| {
+                .TimerOverflow => |id| {
-                switch (id) {
+                    switch (id) {
-                    inline 0...3 => |idx| cpu.bus.tim[idx].onTimerExpire(cpu, late),
+                        inline 0...3 => |idx| cpu.bus.tim[idx].onTimerExpire(cpu, late),
-                }
+                    }
-            },
+                },
-            .ApuChannel => |id| {
+                .ApuChannel => |id| {
-                switch (id) {
+                    switch (id) {
-                    0 => cpu.bus.apu.ch1.onToneSweepEvent(late),
+                        0 => cpu.bus.apu.ch1.onToneSweepEvent(late),
-                    1 => cpu.bus.apu.ch2.onToneEvent(late),
+                        1 => cpu.bus.apu.ch2.onToneEvent(late),
-                    2 => cpu.bus.apu.ch3.onWaveEvent(late),
+                        2 => cpu.bus.apu.ch3.onWaveEvent(late),
-                    3 => cpu.bus.apu.ch4.onNoiseEvent(late),
+                        3 => cpu.bus.apu.ch4.onNoiseEvent(late),
-                }
+                    }
-            },
+                },
-            .RealTimeClock => {
+                .RealTimeClock => {
-                const device = &cpu.bus.pak.gpio.device;
+                    const device = &cpu.bus.pak.gpio.device;
-                if (device.kind != .Rtc or device.ptr == null) return;
+                    if (device.kind != .Rtc or device.ptr == null) return;
 
-                const clock = @ptrCast(*Clock, @alignCast(@alignOf(*Clock), device.ptr.?));
+                    const clock = @ptrCast(*Clock, @alignCast(@alignOf(*Clock), device.ptr.?));
-                clock.onClockUpdate(late);
+                    clock.onClockUpdate(late);
-            },
+                },
-            .FrameSequencer => cpu.bus.apu.onSequencerTick(late),
+                .FrameSequencer => cpu.bus.apu.onSequencerTick(late),
-            .SampleAudio => cpu.bus.apu.sampleAudio(late),
+                .SampleAudio => cpu.bus.apu.sampleAudio(late),
-            .HBlank => cpu.bus.ppu.onHblankEnd(cpu, late), // The end of a HBlank
+                .HBlank => cpu.bus.ppu.onHblankEnd(cpu, late), // The end of a HBlank
-            .VBlank => cpu.bus.ppu.onHdrawEnd(cpu, late), // The end of a VBlank
+                .VBlank => cpu.bus.ppu.onHdrawEnd(cpu, late), // The end of a VBlank
+            }
         }
     }
 
     /// Removes the **first** scheduled event of type `needle`
     pub fn removeScheduledEvent(self: *Self, needle: EventKind) void {
-        for (self.queue.items) |event, i| {
+        var it = self.queue.iterator();
+
+        var i: usize = 0;
+        while (it.next()) |event| : (i += 1) {
             if (std.meta.eql(event.kind, needle)) {
 
-                // invalidates the slice we're iterating over
+                // This invalidates the iterator
                 _ = self.queue.removeIndex(i);
 
-                log.debug("Removed {?}@{}", .{ event.kind, event.tick });
+                // Since removing something from the PQ invalidates the iterator,
+                // this implementation can safely only remove the first instance of
+                // a Scheduled Event. Exit Early
                 break;
             }
         }

src/main.zig

@@ -13,6 +13,8 @@ const FilePaths = @import("util.zig").FilePaths;
 
 const Allocator = std.mem.Allocator;
 const log = std.log.scoped(.Cli);
+const width = @import("core/ppu.zig").width;
+const height = @import("core/ppu.zig").height;
 pub const log_level = if (builtin.mode != .Debug) .info else std.log.default_level;
 
 // CLI Arguments + Help Text
@@ -85,8 +87,7 @@ pub fn main() void {
         cpu.fastBoot();
     }
 
-    // TODO: Just copy the title instead of grabbing a pointer to it
+    var gui = Gui.init(&bus.pak.title, &bus.apu, width, height) catch |e| exitln("failed to init gui: {}", .{e});
-    var gui = Gui.init(allocator, bus.pak.title, &bus.apu) catch |e| exitln("failed to init gui: {}", .{e});
     defer gui.deinit();
 
     gui.run(&cpu, &scheduler) catch |e| exitln("failed to run gui thread: {}", .{e});

src/platform.zig

@@ -1,9 +1,6 @@
 const std = @import("std");
 const SDL = @import("sdl2");
 const gl = @import("gl");
-const zgui = @import("zgui");
-const nfd = @import("nfd");
-
 const emu = @import("core/emu.zig");
 const config = @import("config.zig");
 
@@ -11,43 +8,20 @@ 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 gba_width = @import("core/ppu.zig").width;
 const gba_height = @import("core/ppu.zig").height;
 
-const GLuint = gl.GLuint;
+pub const sample_rate = 1 << 16;
-const GLsizei = gl.GLsizei;
-const SDL_GLContext = *anyopaque;
-const Allocator = std.mem.Allocator;
-
-const width = 1280;
-const height = 720;
-
-pub const sample_rate = 1 << 15;
 pub const sample_format = SDL.AUDIO_U16;
 
 const default_title = "ZBA";
 
 pub const Gui = struct {
     const Self = @This();
+    const SDL_GLContext = *anyopaque; // SDL.SDL_GLContext is a ?*anyopaque
     const log = std.log.scoped(.Gui);
 
-    const State = struct {
-        fps_hist: RingBuffer(u32),
-        should_quit: bool = false,
-
-        pub fn init(allocator: Allocator) !@This() {
-            const history = try allocator.alloc(u32, 0x400);
-            return .{ .fps_hist = RingBuffer(u32).init(history) };
-        }
-
-        fn deinit(self: *@This(), allocator: Allocator) void {
-            self.fps_hist.deinit(allocator);
-            self.* = undefined;
-        }
-    };
-
     // zig fmt: off
     const vertices: [32]f32 = [_]f32{
         // Positions        // Colours      // Texture Coords
@@ -65,91 +39,47 @@ pub const Gui = struct {
 
     window: *SDL.SDL_Window,
     ctx: SDL_GLContext,
-    title: [:0]const u8,
+    title: []const u8,
     audio: Audio,
 
-    state: State,
-
-    allocator: Allocator,
     program_id: gl.GLuint,
 
-    pub fn init(allocator: Allocator, title: [12]u8, apu: *Apu) !Self {
+    pub fn init(title: *const [12]u8, apu: *Apu, width: i32, height: i32) !Self {
         if (SDL.SDL_Init(SDL.SDL_INIT_VIDEO | SDL.SDL_INIT_EVENTS | SDL.SDL_INIT_AUDIO) < 0) panic();
         if (SDL.SDL_GL_SetAttribute(SDL.SDL_GL_CONTEXT_PROFILE_MASK, SDL.SDL_GL_CONTEXT_PROFILE_CORE) < 0) panic();
         if (SDL.SDL_GL_SetAttribute(SDL.SDL_GL_CONTEXT_MAJOR_VERSION, 3) < 0) panic();
         if (SDL.SDL_GL_SetAttribute(SDL.SDL_GL_CONTEXT_MAJOR_VERSION, 3) < 0) panic();
 
+        const win_scale = @intCast(c_int, config.config().host.win_scale);
+
         const window = SDL.SDL_CreateWindow(
             default_title,
             SDL.SDL_WINDOWPOS_CENTERED,
             SDL.SDL_WINDOWPOS_CENTERED,
-            width,
+            @as(c_int, width * win_scale),
-            height,
+            @as(c_int, height * win_scale),
             SDL.SDL_WINDOW_OPENGL | SDL.SDL_WINDOW_SHOWN,
         ) orelse panic();
 
         const ctx = SDL.SDL_GL_CreateContext(window) orelse panic();
         if (SDL.SDL_GL_MakeCurrent(window, ctx) < 0) panic();
 
-        gl.load(ctx, Self.glGetProcAddress) catch {};
+        try gl.load(ctx, Self.glGetProcAddress);
         if (SDL.SDL_GL_SetSwapInterval(@boolToInt(config.config().host.vsync)) < 0) panic();
 
-        zgui.init(allocator);
+        const program_id = try compileShaders();
-        zgui.plot.init();
-        zgui.backend.init(window, ctx, "#version 330 core");
-
-        // zgui.io.setIniFilename(null);
 
         return Self{
             .window = window,
-            .title = try allocator.dupeZ(u8, &title),
+            .title = std.mem.sliceTo(title, 0),
             .ctx = ctx,
-            .program_id = try compileShaders(),
+            .program_id = program_id,
             .audio = Audio.init(apu),
-
-            .allocator = allocator,
-            .state = try State.init(allocator),
         };
     }
 
-    pub fn deinit(self: *Self) void {
+    fn compileShaders() !gl.GLuint {
-        self.audio.deinit();
+        // TODO: Panic on Shader Compiler Failure + Error Message
-        self.state.deinit(self.allocator);
-
-        zgui.backend.deinit();
-        zgui.plot.deinit();
-        zgui.deinit();
-
-        gl.deleteProgram(self.program_id);
-        SDL.SDL_GL_DeleteContext(self.ctx);
-        SDL.SDL_DestroyWindow(self.window);
-        SDL.SDL_Quit();
-
-        self.allocator.free(self.title);
-        self.* = undefined;
-    }
-
-    fn drawGbaTexture(self: *const Self, obj_ids: struct { GLuint, GLuint, GLuint }, tex_id: GLuint, buf: []const u8) void {
-        gl.bindTexture(gl.TEXTURE_2D, tex_id);
-        defer gl.bindTexture(gl.TEXTURE_2D, 0);
-
-        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, gba_width, gba_height, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, buf.ptr);
-
-        // Bind VAO, EBO. VBO not bound
-        gl.bindVertexArray(obj_ids[0]); // VAO
-        defer gl.bindVertexArray(0);
-
-        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, obj_ids[2]); // EBO
-        defer gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, 0);
-
-        // Use compiled frag + vertex shader
-        gl.useProgram(self.program_id);
-        defer gl.useProgram(0);
-
-        gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, null);
-    }
-
-    fn compileShaders() !GLuint {
         const vert_shader = @embedFile("shader/pixelbuf.vert");
         const frag_shader = @embedFile("shader/pixelbuf.frag");
 
@@ -178,25 +108,20 @@ pub const Gui = struct {
     }
 
     // Returns the VAO ID since it's used in run()
-    fn genBufferObjects() struct { GLuint, GLuint, GLuint } {
+    fn generateBuffers() struct { c_uint, c_uint, c_uint } {
-        var vao_id: GLuint = undefined;
+        var vao_id: c_uint = undefined;
-        var vbo_id: GLuint = undefined;
+        var vbo_id: c_uint = undefined;
-        var ebo_id: GLuint = undefined;
+        var ebo_id: c_uint = undefined;
-
         gl.genVertexArrays(1, &vao_id);
         gl.genBuffers(1, &vbo_id);
         gl.genBuffers(1, &ebo_id);
 
         gl.bindVertexArray(vao_id);
-        defer gl.bindVertexArray(0);
 
         gl.bindBuffer(gl.ARRAY_BUFFER, vbo_id);
-        defer gl.bindBuffer(gl.ARRAY_BUFFER, 0);
+        gl.bufferData(gl.ARRAY_BUFFER, @sizeOf(@TypeOf(vertices)), &vertices, gl.STATIC_DRAW);
 
         gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ebo_id);
-        defer gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, 0);
-
-        gl.bufferData(gl.ARRAY_BUFFER, @sizeOf(@TypeOf(vertices)), &vertices, gl.STATIC_DRAW);
         gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, @sizeOf(@TypeOf(indices)), &indices, gl.STATIC_DRAW);
 
         // Position
@@ -212,242 +137,46 @@ pub const Gui = struct {
         return .{ vao_id, vbo_id, ebo_id };
     }
 
-    fn genGbaTexture(buf: []const u8) GLuint {
+    fn generateTexture(buf: []const u8) c_uint {
-        var tex_id: GLuint = undefined;
+        var tex_id: c_uint = undefined;
         gl.genTextures(1, &tex_id);
-
         gl.bindTexture(gl.TEXTURE_2D, tex_id);
-        defer gl.bindTexture(gl.TEXTURE_2D, 0);
+
+        // gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        // gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
 
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
 
         gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gba_width, gba_height, 0, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, buf.ptr);
+        // gl.generateMipmap(gl.TEXTURE_2D); // TODO: Remove?
 
         return tex_id;
     }
 
-    fn genOutTexture() GLuint {
-        var tex_id: GLuint = undefined;
-        gl.genTextures(1, &tex_id);
-
-        gl.bindTexture(gl.TEXTURE_2D, tex_id);
-        defer gl.bindTexture(gl.TEXTURE_2D, 0);
-
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
-
-        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gba_width, gba_height, 0, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, null);
-
-        return tex_id;
-    }
-
-    fn genFrameBufObject(tex_id: c_uint) !GLuint {
-        var fbo_id: GLuint = undefined;
-        gl.genFramebuffers(1, &fbo_id);
-
-        gl.bindFramebuffer(gl.FRAMEBUFFER, fbo_id);
-        defer gl.bindFramebuffer(gl.FRAMEBUFFER, 0);
-
-        gl.framebufferTexture(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, tex_id, 0);
-
-        const draw_buffers: [1]GLuint = .{gl.COLOR_ATTACHMENT0};
-        gl.drawBuffers(1, &draw_buffers);
-
-        if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) != gl.FRAMEBUFFER_COMPLETE)
-            return error.FrameBufferObejctInitFailed;
-
-        return fbo_id;
-    }
-
-    fn draw(self: *Self, tex_id: GLuint, cpu: *const Arm7tdmi) void {
-        const win_scale = config.config().host.win_scale;
-
-        {
-            _ = zgui.beginMainMenuBar();
-            defer zgui.endMainMenuBar();
-
-            if (zgui.beginMenu("File", true)) {
-                defer zgui.endMenu();
-
-                if (zgui.menuItem("Quit", .{})) self.state.should_quit = true;
-                if (zgui.menuItem("Insert ROM", .{})) blk: {
-                    const maybe_path = nfd.openFileDialog("gba", null) catch |e| {
-                        log.err("failed to open file dialog: {?}", .{e});
-                        break :blk;
-                    };
-
-                    if (maybe_path) |file_path| {
-                        defer nfd.freePath(file_path);
-                        log.info("user chose: \"{s}\"", .{file_path});
-
-                        // emu.loadRom(cpu, file_path);
-                    }
-                }
-            }
-
-            if (zgui.beginMenu("Emulation", true)) {
-                defer zgui.endMenu();
-
-                if (zgui.menuItem("Restart", .{})) log.warn("TODO: Restart Emulator", .{});
-            }
-        }
-
-        {
-            const w = @intToFloat(f32, gba_width * win_scale);
-            const h = @intToFloat(f32, gba_height * win_scale);
-
-            _ = zgui.begin(self.title, .{ .flags = .{ .no_resize = true, .always_auto_resize = true } });
-            defer zgui.end();
-
-            zgui.image(@intToPtr(*anyopaque, tex_id), .{ .w = w, .h = h, .uv0 = .{ 0, 1 }, .uv1 = .{ 1, 0 } });
-        }
-
-        {
-            _ = zgui.begin("Information", .{});
-            defer zgui.end();
-
-            {
-                var i: usize = 0;
-                while (i < 8) : (i += 1) {
-                    zgui.text("R{}: 0x{X:0>8}", .{ i, cpu.r[i] });
-
-                    zgui.sameLine(.{});
-
-                    const prefix = if (8 + i < 10) " " else "";
-                    zgui.text("{s}R{}: 0x{X:0>8}", .{ prefix, 8 + i, cpu.r[8 + i] });
-                }
-            }
-
-            zgui.separator();
-
-            widgets.psr("CPSR", cpu.cpsr);
-            widgets.psr("SPSR", cpu.spsr);
-
-            zgui.separator();
-
-            widgets.interrupts(" IE", cpu.bus.io.ie); // space is for padding
-            widgets.interrupts("IRQ", cpu.bus.io.irq);
-        }
-
-        {
-            _ = zgui.begin("Performance", .{});
-            defer zgui.end();
-
-            const tmp = blk: {
-                var buf: [0x400]u32 = undefined;
-                const len = self.state.fps_hist.copy(&buf);
-
-                break :blk .{ buf, len };
-            };
-            const values = tmp[0];
-            const len = tmp[1];
-
-            if (len == values.len) _ = self.state.fps_hist.pop();
-
-            const sorted = blk: {
-                var buf: @TypeOf(values) = undefined;
-
-                std.mem.copy(u32, buf[0..len], values[0..len]);
-                std.sort.sort(u32, buf[0..len], {}, std.sort.asc(u32));
-
-                break :blk buf;
-            };
-
-            const y_max = 2 * if (len != 0) @intToFloat(f64, sorted[len - 1]) else emu.frame_rate;
-            const x_max = @intToFloat(f64, values.len);
-
-            const y_args = .{ .flags = .{ .no_grid_lines = true } };
-            const x_args = .{ .flags = .{ .no_grid_lines = true, .no_tick_labels = true, .no_tick_marks = true } };
-
-            if (zgui.plot.beginPlot("Emulation FPS", .{ .w = 0.0, .flags = .{ .no_title = true, .no_frame = true } })) {
-                defer zgui.plot.endPlot();
-
-                zgui.plot.setupLegend(.{ .north = true, .east = true }, .{});
-                zgui.plot.setupAxis(.x1, x_args);
-                zgui.plot.setupAxis(.y1, y_args);
-                zgui.plot.setupAxisLimits(.y1, .{ .min = 0.0, .max = y_max, .cond = .always });
-                zgui.plot.setupAxisLimits(.x1, .{ .min = 0.0, .max = x_max, .cond = .always });
-                zgui.plot.setupFinish();
-
-                zgui.plot.plotLineValues("FPS", u32, .{ .v = values[0..len] });
-            }
-
-            const stats: struct { u32, u32, u32 } = blk: {
-                if (len == 0) break :blk .{ 0, 0, 0 };
-
-                const average = average: {
-                    var sum: u32 = 0;
-                    for (sorted[0..len]) |value| sum += value;
-
-                    break :average @intCast(u32, sum / len);
-                };
-                const median = sorted[len / 2];
-                const low = sorted[len / 100]; // 1% Low
-
-                break :blk .{ average, median, low };
-            };
-
-            zgui.text("Average: {:0>3} fps", .{stats[0]});
-            zgui.text(" Median: {:0>3} fps", .{stats[1]});
-            zgui.text(" 1% Low: {:0>3} fps", .{stats[2]});
-        }
-
-        {
-            _ = zgui.begin("Scheduler", .{});
-            defer zgui.end();
-
-            const scheduler = cpu.sched;
-
-            zgui.text("tick: {X:0>16}", .{scheduler.tick});
-            zgui.separator();
-
-            const Event = std.meta.Child(@TypeOf(scheduler.queue.items));
-
-            var items: [20]Event = undefined;
-            const len = scheduler.queue.len;
-
-            std.mem.copy(Event, &items, scheduler.queue.items);
-            std.sort.sort(Event, items[0..len], {}, widgets.eventDesc(Event));
-
-            for (items[0..len]) |event| {
-                zgui.text("{X:0>16} | {?}", .{ event.tick, event.kind });
-            }
-        }
-
-        {
-            zgui.showDemoWindow(null);
-        }
-    }
-
     pub fn run(self: *Self, cpu: *Arm7tdmi, scheduler: *Scheduler) !void {
-        const obj_ids = Self.genBufferObjects();
-        defer gl.deleteBuffers(3, @as(*const [3]c_uint, &obj_ids));
-
-        const emu_tex = Self.genGbaTexture(cpu.bus.ppu.framebuf.get(.Renderer));
-        const out_tex = Self.genOutTexture();
-        defer gl.deleteTextures(2, &[_]c_uint{ emu_tex, out_tex });
-
-        const fbo_id = try Self.genFrameBufObject(out_tex);
-        defer gl.deleteFramebuffers(1, &fbo_id);
-
-        var tracker = FpsTracker.init();
         var quit = std.atomic.Atomic(bool).init(false);
-        var pause = std.atomic.Atomic(bool).init(false);
+        var tracker = FpsTracker.init();
 
-        const thread = try std.Thread.spawn(.{}, emu.run, .{ &quit, &pause, cpu, scheduler, &tracker });
+        var buffer_ids = Self.generateBuffers();
+        defer {
+            gl.deleteBuffers(1, &buffer_ids[2]); // EBO
+            gl.deleteBuffers(1, &buffer_ids[1]); // VBO
+            gl.deleteVertexArrays(1, &buffer_ids[0]); // VAO
+        }
+        const vao_id = buffer_ids[0];
+
+        const tex_id = Self.generateTexture(cpu.bus.ppu.framebuf.get(.Renderer));
+        defer gl.deleteTextures(1, &tex_id);
+
+        const thread = try std.Thread.spawn(.{}, emu.run, .{ &quit, scheduler, cpu, &tracker });
         defer thread.join();
-        defer quit.store(true, .Monotonic); // Terminate Emulator Thread
+
+        var title_buf: [0x100]u8 = undefined;
 
         emu_loop: while (true) {
             var event: SDL.SDL_Event = undefined;
-
-            // Quit Signal from Dear Imgui
-            if (self.state.should_quit) break :emu_loop;
-
             while (SDL.SDL_PollEvent(&event) != 0) {
-                _ = zgui.backend.processEvent(&event);
-
                 switch (event.type) {
                     SDL.SDL_QUIT => break :emu_loop,
                     SDL.SDL_KEYDOWN => {
@@ -485,6 +214,12 @@ pub const Gui = struct {
                             SDL.SDLK_s => keyinput.shoulder_r.set(),
                             SDL.SDLK_RETURN => keyinput.start.set(),
                             SDL.SDLK_RSHIFT => keyinput.select.set(),
+                            SDL.SDLK_i => {
+                                comptime std.debug.assert(sample_format == SDL.AUDIO_U16);
+                                log.err("Sample Count: {}", .{cpu.bus.apu.sample_queue.len() / 2});
+                            },
+                            // SDL.SDLK_j => log.err("Scheduler Capacity: {} | Scheduler Event Count: {}", .{ scheduler.queue.capacity(), scheduler.queue.count() }),
+                            SDL.SDLK_k => {},
                             else => {},
                         }
 
@@ -494,36 +229,29 @@ pub const Gui = struct {
                 }
             }
 
-            // We Access non-atomic parts of the Emulator here
+            // Emulator has an internal Double Buffer
-            {
+            const framebuf = cpu.bus.ppu.framebuf.get(.Renderer);
-                pause.store(true, .Monotonic);
+            gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, gba_width, gba_height, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, framebuf.ptr);
-                defer pause.store(false, .Monotonic);
-
-                self.state.fps_hist.push(tracker.value()) catch {};
-
-                // Draw GBA Screen to Texture
-                {
-                    gl.bindFramebuffer(gl.FRAMEBUFFER, fbo_id);
-                    defer gl.bindFramebuffer(gl.FRAMEBUFFER, 0);
-
-                    const buf = cpu.bus.ppu.framebuf.get(.Renderer);
-                    gl.viewport(0, 0, gba_width, gba_height);
-                    self.drawGbaTexture(obj_ids, emu_tex, buf);
-                }
-
-                // Background Colour
-                const size = zgui.io.getDisplaySize();
-                gl.viewport(0, 0, @floatToInt(c_int, size[0]), @floatToInt(c_int, size[1]));
-                gl.clearColor(0, 0, 0, 1.0);
-                gl.clear(gl.COLOR_BUFFER_BIT);
-
-                zgui.backend.newFrame(width, height);
-                self.draw(out_tex, cpu);
-                zgui.backend.draw();
-            }
 
+            gl.useProgram(self.program_id);
+            gl.bindVertexArray(vao_id);
+            gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, null);
             SDL.SDL_GL_SwapWindow(self.window);
+
+            const dyn_title = std.fmt.bufPrintZ(&title_buf, "ZBA | {s} [Emu: {}fps] ", .{ self.title, tracker.value() }) catch unreachable;
+            SDL.SDL_SetWindowTitle(self.window, dyn_title.ptr);
         }
+
+        quit.store(true, .Monotonic); // Terminate Emulator Thread
+    }
+
+    pub fn deinit(self: *Self) void {
+        self.audio.deinit();
+        gl.deleteProgram(self.program_id);
+        SDL.SDL_GL_DeleteContext(self.ctx);
+        SDL.SDL_DestroyWindow(self.window);
+        SDL.SDL_Quit();
+        self.* = undefined;
     }
 
     fn glGetProcAddress(ctx: SDL.SDL_GLContext, proc: [:0]const u8) ?*anyopaque {
@@ -571,7 +299,15 @@ const Audio = struct {
         const T = *Apu;
         const apu = @ptrCast(T, @alignCast(@alignOf(T), userdata));
 
-        _ = SDL.SDL_AudioStreamGet(apu.stream, stream, len);
+        comptime std.debug.assert(sample_format == SDL.AUDIO_U16);
+        const sample_buf = @ptrCast([*]u16, @alignCast(@alignOf(u16), stream))[0 .. @intCast(u32, len) / @sizeOf(u16)];
+
+        var previous: u16 = 0x8000;
+        for (sample_buf) |*sample| {
+            if (apu.sample_queue.pop()) |value| previous = value;
+
+            sample.* = previous;
+        }
     }
 };
 
@@ -601,95 +337,3 @@ fn panic() noreturn {
     const str = @as(?[*:0]const u8, SDL.SDL_GetError()) orelse "unknown error";
     @panic(std.mem.sliceTo(str, 0));
 }
-
-const widgets = struct {
-    fn interrupts(comptime label: []const u8, int: anytype) void {
-        const h = 15.0;
-        const w = 9.0 * 2 + 3.5;
-        const ww = 9.0 * 3;
-
-        {
-            zgui.text(label ++ ":", .{});
-
-            zgui.sameLine(.{});
-            _ = zgui.selectable("VBL", .{ .w = w, .h = h, .selected = int.vblank.read() });
-
-            zgui.sameLine(.{});
-            _ = zgui.selectable("HBL", .{ .w = w, .h = h, .selected = int.hblank.read() });
-
-            zgui.sameLine(.{});
-            _ = zgui.selectable("VCT", .{ .w = w, .h = h, .selected = int.coincidence.read() });
-
-            {
-                zgui.sameLine(.{});
-                _ = zgui.selectable("TIM0", .{ .w = ww, .h = h, .selected = int.tim0.read() });
-
-                zgui.sameLine(.{});
-                _ = zgui.selectable("TIM1", .{ .w = ww, .h = h, .selected = int.tim1.read() });
-
-                zgui.sameLine(.{});
-                _ = zgui.selectable("TIM2", .{ .w = ww, .h = h, .selected = int.tim2.read() });
-
-                zgui.sameLine(.{});
-                _ = zgui.selectable("TIM3", .{ .w = ww, .h = h, .selected = int.tim3.read() });
-            }
-
-            zgui.sameLine(.{});
-            _ = zgui.selectable("SRL", .{ .w = w, .h = h, .selected = int.serial.read() });
-
-            {
-                zgui.sameLine(.{});
-                _ = zgui.selectable("DMA0", .{ .w = ww, .h = h, .selected = int.dma0.read() });
-
-                zgui.sameLine(.{});
-                _ = zgui.selectable("DMA1", .{ .w = ww, .h = h, .selected = int.dma1.read() });
-
-                zgui.sameLine(.{});
-                _ = zgui.selectable("DMA2", .{ .w = ww, .h = h, .selected = int.dma2.read() });
-
-                zgui.sameLine(.{});
-                _ = zgui.selectable("DMA3", .{ .w = ww, .h = h, .selected = int.dma3.read() });
-            }
-
-            zgui.sameLine(.{});
-            _ = zgui.selectable("KPD", .{ .w = w, .h = h, .selected = int.keypad.read() });
-
-            zgui.sameLine(.{});
-            _ = zgui.selectable("GPK", .{ .w = w, .h = h, .selected = int.game_pak.read() });
-        }
-    }
-
-    fn psr(comptime label: []const u8, register: anytype) void {
-        const Mode = @import("core/cpu.zig").Mode;
-
-        const maybe_mode = std.meta.intToEnum(Mode, register.mode.read()) catch null;
-        const mode = if (maybe_mode) |mode| mode.toString() else "???";
-        const w = 9.0;
-        const h = 15.0;
-
-        zgui.text(label ++ ": 0x{X:0>8}", .{register.raw});
-
-        zgui.sameLine(.{});
-        _ = zgui.selectable("N", .{ .w = w, .h = h, .selected = register.n.read() });
-
-        zgui.sameLine(.{});
-        _ = zgui.selectable("Z", .{ .w = w, .h = h, .selected = register.z.read() });
-
-        zgui.sameLine(.{});
-        _ = zgui.selectable("C", .{ .w = w, .h = h, .selected = register.c.read() });
-
-        zgui.sameLine(.{});
-        _ = zgui.selectable("V", .{ .w = w, .h = h, .selected = register.v.read() });
-
-        zgui.sameLine(.{});
-        zgui.text("{s}", .{mode});
-    }
-
-    fn eventDesc(comptime T: type) fn (void, T, T) bool {
-        return struct {
-            fn inner(_: void, left: T, right: T) bool {
-                return left.tick > right.tick;
-            }
-        }.inner;
-    }
-};

src/util.zig

@@ -5,8 +5,6 @@ const config = @import("config.zig");
 const Log2Int = std.math.Log2Int;
 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
@@ -125,7 +123,6 @@ pub const io = struct {
 
 pub const Logger = struct {
     const Self = @This();
-    const FmtArgTuple = std.meta.Tuple(&.{ u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32 });
 
     buf: std.io.BufferedWriter(4096 << 2, std.fs.File.Writer),
 
@@ -184,6 +181,8 @@ pub const Logger = struct {
     }
 };
 
+const FmtArgTuple = struct { u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32 };
+
 pub const audio = struct {
     const _io = @import("core/bus/io.zig");
 
@@ -277,46 +276,7 @@ fn HalfInt(comptime T: type) type {
     return std.meta.Int(type_info.Int.signedness, type_info.Int.bits >> 1);
 }
 
-/// Double Buffering Implementation
+const Mutex = std.Thread.Mutex;
-pub const FrameBuffer = struct {
-    const Self = @This();
-
-    layers: [2][]u8,
-    buf: []u8,
-    current: u1,
-
-    allocator: Allocator,
-
-    // TODO: Rename
-    const Device = enum { Emulator, Renderer };
-
-    pub fn init(allocator: Allocator, comptime len: comptime_int) !Self {
-        const buf = try allocator.alloc(u8, len * 2);
-        std.mem.set(u8, buf, 0);
-
-        return .{
-            // Front and Back Framebuffers
-            .layers = [_][]u8{ buf[0..][0..len], buf[len..][0..len] },
-            .buf = buf,
-            .current = 0,
-
-            .allocator = allocator,
-        };
-    }
-
-    pub fn deinit(self: *Self) void {
-        self.allocator.free(self.buf);
-        self.* = undefined;
-    }
-
-    pub fn swap(self: *Self) void {
-        self.current = ~self.current;
-    }
-
-    pub fn get(self: *Self, comptime dev: Device) []u8 {
-        return self.layers[if (dev == .Emulator) self.current else ~self.current];
-    }
-};
 
 pub fn RingBuffer(comptime T: type) type {
     return struct {
@@ -328,59 +288,67 @@ pub fn RingBuffer(comptime T: type) type {
 
         read: Index,
         write: Index,
+
         buf: []T,
 
+        mutex: Mutex,
+
         const Error = error{buffer_full};
 
         pub fn init(buf: []T) Self {
+            std.mem.set(T, buf, 0);
+
             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, .mutex = .{} };
-
-            return .{ .read = 0, .write = 0, .buf = buf };
         }
 
-        pub fn deinit(self: *Self, allocator: Allocator) void {
+        pub fn push(self: *Self, left: T, right: T) Error!void {
-            allocator.free(self.buf);
+            self.mutex.lock();
-            self.* = undefined;
+            defer self.mutex.unlock();
+
+            try self._push(left);
+            self._push(right) catch |e| {
+                self.write -= 1; // undo the previous write;
+                return e;
+            };
         }
 
-        pub fn push(self: *Self, value: T) Error!void {
+        pub fn pop(self: *Self) ?T {
+            self.mutex.lock();
+            defer self.mutex.unlock();
+
+            return self._pop();
+        }
+
+        pub fn len(self: *Self) Index {
+            self.mutex.lock();
+            defer self.mutex.unlock();
+
+            return self._len();
+        }
+
+        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 {
+        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
+        fn _len(self: *const Self) Index {
-        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) |*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;
+            return self._len() == self.buf.len;
         }
 
         fn isEmpty(self: *const Self) bool {
@@ -392,3 +360,25 @@ pub fn RingBuffer(comptime T: type) type {
         }
     };
 }
+
+test "RingBuffer" {
+    const Queue = RingBuffer(u8);
+
+    var buf: [4]u8 = undefined;
+    var queue = Queue.init(&buf);
+
+    try queue.push(1, 2);
+    try std.testing.expectEqual(@as(?u8, 1), queue.pop());
+
+    try queue.push(3, 4);
+    try std.testing.expectError(Queue.Error.buffer_full, queue.push(5, 6));
+    try std.testing.expectEqual(@as(?u8, 2), queue.pop());
+
+    try queue.push(7, 8);
+
+    try std.testing.expectEqual(@as(?u8, 3), queue.pop());
+    try std.testing.expectEqual(@as(?u8, 4), queue.pop());
+    try std.testing.expectEqual(@as(?u8, 7), queue.pop());
+    try std.testing.expectEqual(@as(?u8, 8), queue.pop());
+    try std.testing.expectEqual(@as(?u8, null), queue.pop());
+}