feat: add audio resampler

Also implement extremely naive audio sync

src/apu.zig

@@ -11,9 +11,6 @@ const AudioDeviceId = SDL.SDL_AudioDeviceID;
 const intToBytes = @import("util.zig").intToBytes;
 const log = std.log.scoped(.APU);
 
-const sample_rate = 32768;
-const sample_ticks = (1 << 24) / sample_rate;
-
 pub const Apu = struct {
     const Self = @This();
 
@@ -29,7 +26,8 @@ pub const Apu = struct {
     dma_cnt: io.DmaSoundControl,
     cnt: io.SoundControl,
 
-    dev: ?AudioDeviceId,
+    sampling_cycle: u2,
+    stream: *SDL.SDL_AudioStream,
     sched: *Scheduler,
 
     pub fn init(sched: *Scheduler) Self {
@@ -46,18 +44,16 @@ pub const Apu = struct {
             .cnt = .{ .raw = 0 },
             .bias = .{ .raw = 0x0200 },
 
-            .dev = null,
+            .sampling_cycle = 0b00,
+            .stream = SDL.SDL_NewAudioStream(SDL.AUDIO_F32, 2, 1 << 15, SDL.AUDIO_F32, 2, 48000) orelse unreachable,
             .sched = sched,
         };
-        sched.push(.SampleAudio, sched.now() + sample_ticks);
+
+        sched.push(.SampleAudio, sched.now() + apu.sampleTicks());
 
         return apu;
     }
 
-    pub fn attachAudioDevice(self: *Self, dev: AudioDeviceId) void {
-        self.dev = dev;
-    }
-
     pub fn setDmaCnt(self: *Self, value: u16) void {
         const new: io.DmaSoundControl = .{ .raw = value };
 
@@ -97,9 +93,28 @@ pub const Apu = struct {
         const left = (chA_left + chB_left) / 2;
         const right = (chA_right + chB_right) / 2;
 
-        if (self.dev) |dev| _ = SDL.SDL_QueueAudio(dev, &[2]f32{ left, right }, 2 * @sizeOf(f32));
+        if (self.sampling_cycle != self.bias.sampling_cycle.read()) {
+            // Sample Rate Changed, Create a new Resampler since i can't figure out how to change
+            // the parameters of the old one
+            const old = self.stream;
+            defer SDL.SDL_FreeAudioStream(old);
 
-        self.sched.push(.SampleAudio, self.sched.now() + sample_ticks - late);
+            self.sampling_cycle = self.bias.sampling_cycle.read();
+            self.stream = SDL.SDL_NewAudioStream(SDL.AUDIO_F32, 2, @intCast(c_int, self.sampleRate()), SDL.AUDIO_F32, 2, 48000) orelse unreachable;
+        }
+
+        while (SDL.SDL_AudioStreamAvailable(self.stream) > self.sampleRate() / 2) {} // Really Naive Audio Sync
+
+        _ = SDL.SDL_AudioStreamPut(self.stream, &[2]f32{ left, right }, 2 * @sizeOf(f32));
+        self.sched.push(.SampleAudio, self.sched.now() + self.sampleTicks() - late);
+    }
+
+    inline fn sampleTicks(self: *const Self) u64 {
+        return (1 << 24) / self.sampleRate();
+    }
+
+    inline fn sampleRate(self: *const Self) u64 {
+        return @as(u64, 1) << (15 + @as(u6, self.bias.sampling_cycle.read()));
     }
 
     pub fn handleTimerOverflow(self: *Self, cpu: *Arm7tdmi, tim_id: u3) void {

src/main.zig

@@ -5,6 +5,7 @@ const known_folders = @import("known_folders");
 
 const emu = @import("emu.zig");
 const Bus = @import("Bus.zig");
+const Apu = @import("apu.zig").Apu;
 const Arm7tdmi = @import("cpu.zig").Arm7tdmi;
 const Scheduler = @import("scheduler.zig").Scheduler;
 const FpsAverage = @import("util.zig").FpsAverage;
@@ -70,10 +71,6 @@ pub fn main() anyerror!void {
     _ = initSdl2();
     defer SDL.SDL_Quit();
 
-    // Initialize SDL Audio
-    const audio_dev = initAudio();
-    defer SDL.SDL_CloseAudioDevice(audio_dev);
-
     // Initialize Emulator
     var scheduler = Scheduler.init(alloc);
     defer scheduler.deinit();
@@ -81,10 +78,12 @@ pub fn main() anyerror!void {
     const paths = .{ .bios = bios_path, .rom = rom_path, .save = save_path };
     var cpu = try Arm7tdmi.init(alloc, &scheduler, paths);
     defer cpu.deinit();
-
-    cpu.bus.apu.attachAudioDevice(audio_dev);
     cpu.fastBoot();
 
+    // Initialize SDL Audio
+    const audio_dev = initAudio(&cpu.bus.apu);
+    defer SDL.SDL_CloseAudioDevice(audio_dev);
+
     const log_file: ?File = if (enable_logging) blk: {
         const file = try std.fs.cwd().createFile(if (is_binary) "zba.bin" else "zba.log", .{});
         cpu.useLogger(&file, is_binary);
@@ -238,19 +237,31 @@ fn createTexture(renderer: *SDL.SDL_Renderer, width: c_int, height: c_int) *SDL.
     ) orelse sdlPanic();
 }
 
-fn initAudio() SDL.SDL_AudioDeviceID {
+fn initAudio(apu: *Apu) SDL.SDL_AudioDeviceID {
     var have: SDL.SDL_AudioSpec = undefined;
-    var want = std.mem.zeroes(SDL.SDL_AudioSpec);
-    want.freq = 32768;
-    want.format = SDL.AUDIO_F32;
-    want.channels = 2;
-    want.samples = 0x100;
-    want.callback = null;
+    var want: SDL.SDL_AudioSpec = .{
+        .freq = 48000,
+        .format = SDL.AUDIO_F32,
+        .channels = 2,
+        .samples = 0x100,
+        .callback = audioCallback,
+        .userdata = apu,
+        .silence = undefined,
+        .size = undefined,
+        .padding = undefined,
+    };
 
     const dev = SDL.SDL_OpenAudioDevice(null, 0, &want, &have, 0);
     if (dev == 0) sdlPanic();
 
-    // Start Playback on the Audio evice
+    // Start Playback on the Audio device
     SDL.SDL_PauseAudioDevice(dev, 0);
     return dev;
 }
+
+export fn audioCallback(userdata: ?*anyopaque, stream: [*c]u8, len: c_int) void {
+    const apu = @ptrCast(*Apu, @alignCast(8, userdata));
+    const result = SDL.SDL_AudioStreamGet(apu.stream, stream, len);
+
+    if (result < 0) log.err("Audio Callback Underflow", .{});
+}