chore: add test for RingBuffer

src/config.zig

@@ -58,7 +58,10 @@ pub fn load(allocator: Allocator, file_path: []const u8) !void {
     const contents = try config_file.readToEndAlloc(allocator, try config_file.getEndPos());
     defer allocator.free(contents);
 
-    const table = try toml.parseContents(allocator, contents, null);
+    var parser = try toml.parseFile(allocator, file_path);
+    defer parser.deinit();
+
+    const table = try parser.parse();
     defer table.deinit();
 
     // TODO: Report unknown config options

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/apu/ToneSweep.zig

@@ -94,10 +94,9 @@ pub fn sound1CntL(self: *const Self) u8 {
 pub fn setSound1CntL(self: *Self, value: u8) void {
     const new = io.Sweep{ .raw = value };
 
-    if (self.sweep.direction.read() and !new.direction.read()) {
+    if (!new.direction.read()) {
-        // Sweep Negate bit has been cleared
+        // If at least one (1) sweep calculation has been made with
-        // If At least 1 Sweep Calculation has been made since
+        // the negate bit set (since last trigger), disable the channel
-        // the last trigger, the channel is immediately disabled
 
         if (self.sweep_dev.calc_performed) self.enabled = false;
     }

src/core/apu/device/Sweep.zig

@@ -31,7 +31,6 @@ pub fn tick(self: *Self, ch1: *ToneSweep) void {
     if (self.timer == 0) {
         const period = ch1.sweep.period.read();
         self.timer = if (period == 0) 8 else period;
-        if (!self.calc_performed) self.calc_performed = true;
 
         if (self.enabled and period != 0) {
             const new_freq = self.calculate(ch1.sweep, &ch1.enabled);
@@ -52,7 +51,10 @@ pub fn calculate(self: *Self, sweep: io.Sweep, ch_enable: *bool) u12 {
     const shadow_shifted = shadow >> sweep.shift.read();
     const decrease = sweep.direction.read();
 
-    const freq = if (decrease) shadow - shadow_shifted else shadow + shadow_shifted;
+    const freq = if (decrease) blk: {
+        self.calc_performed = true;
+        break :blk shadow - shadow_shifted;
+    } else shadow + shadow_shifted;
     if (freq > 0x7FF) ch_enable.* = false;
 
     return freq;

src/core/emu.zig

@@ -5,6 +5,7 @@ const config = @import("../config.zig");
 const Scheduler = @import("scheduler.zig").Scheduler;
 const Arm7tdmi = @import("cpu.zig").Arm7tdmi;
 const FpsTracker = @import("../util.zig").FpsTracker;
+const RingBuffer = @import("../util.zig").RingBuffer;
 
 const Timer = std.time.Timer;
 const Atomic = std.atomic.Atomic;
@@ -58,7 +59,7 @@ fn inner(comptime kind: RunKind, audio_sync: bool, quit: *Atomic(bool), schedule
 
             while (!quit.load(.Monotonic)) {
                 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();
             }
@@ -77,7 +78,7 @@ fn inner(comptime kind: RunKind, audio_sync: bool, quit: *Atomic(bool), schedule
                 // 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;
 
@@ -104,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/platform.zig

@@ -12,7 +12,7 @@ const FpsTracker = @import("util.zig").FpsTracker;
 const gba_width = @import("core/ppu.zig").width;
 const gba_height = @import("core/ppu.zig").height;
 
-pub const sample_rate = 1 << 15;
+pub const sample_rate = 1 << 16;
 pub const sample_format = SDL.AUDIO_U16;
 
 const default_title = "ZBA";
@@ -216,7 +216,7 @@ pub const Gui = struct {
                             SDL.SDLK_RSHIFT => keyinput.select.set(),
                             SDL.SDLK_i => {
                                 comptime std.debug.assert(sample_format == SDL.AUDIO_U16);
-                                log.err("Sample Count: {}", .{@intCast(u32, SDL.SDL_AudioStreamAvailable(cpu.bus.apu.stream)) / (2 * @sizeOf(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 => {},
@@ -299,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;
+        }
     }
 };
 

src/util.zig

@@ -275,3 +275,110 @@ fn HalfInt(comptime T: type) type {
 
     return std.meta.Int(type_info.Int.signedness, type_info.Int.bits >> 1);
 }
+
+const Mutex = std.Thread.Mutex;
+
+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,
+
+        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);
+
+            return .{ .read = 0, .write = 0, .buf = buf, .mutex = .{} };
+        }
+
+        pub fn push(self: *Self, left: T, right: T) Error!void {
+            self.mutex.lock();
+            defer self.mutex.unlock();
+
+            try self._push(left);
+            self._push(right) catch |e| {
+                self.write -= 1; // undo the previous write;
+                return e;
+            };
+        }
+
+        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;
+        }
+
+        fn _pop(self: *Self) ?T {
+            if (self.isEmpty()) return null;
+            defer self.read += 1;
+
+            return self.buf[self.mask(self.read)];
+        }
+
+        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);
+        }
+    };
+}
+
+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());
+}