src/apu.zig

@@ -11,6 +11,9 @@ const AudioDeviceId = SDL.SDL_AudioDeviceID;
 const intToBytes = @import("util.zig").intToBytes;
 const log = std.log.scoped(.APU);
 
+const sample_rate = 32768;
+const sample_ticks = 280896 * 60 / sample_rate;
+
 pub const Apu = struct {
     const Self = @This();
 
@@ -26,8 +29,7 @@ pub const Apu = struct {
     dma_cnt: io.DmaSoundControl,
     cnt: io.SoundControl,
 
-    sampling_cycle: u2,
-    stream: *SDL.SDL_AudioStream,
+    dev: ?AudioDeviceId,
     sched: *Scheduler,
 
     pub fn init(sched: *Scheduler) Self {
@@ -44,16 +46,18 @@ pub const Apu = struct {
             .cnt = .{ .raw = 0 },
             .bias = .{ .raw = 0x0200 },
 
-            .sampling_cycle = 0b00,
-            .stream = SDL.SDL_NewAudioStream(SDL.AUDIO_F32, 2, 1 << 15, SDL.AUDIO_F32, 2, 48000) orelse unreachable,
+            .dev = null,
             .sched = sched,
         };
-
-        sched.push(.SampleAudio, sched.now() + apu.sampleTicks());
+        sched.push(.SampleAudio, sched.now() + sample_ticks);
 
         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 };
 
@@ -93,28 +97,9 @@ pub const Apu = struct {
         const left = (chA_left + chB_left) / 2;
         const right = (chA_right + chB_right) / 2;
 
-        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);
+        if (self.dev) |dev| _ = SDL.SDL_QueueAudio(dev, &[2]f32{ left, right }, 2 * @sizeOf(f32));
 
-            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()));
+        self.sched.push(.SampleAudio, self.sched.now() + sample_ticks - late);
     }
 
     pub fn handleTimerOverflow(self: *Self, cpu: *Arm7tdmi, tim_id: u3) void {

src/main.zig

@@ -5,7 +5,6 @@ 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;
@@ -71,6 +70,10 @@ 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();
@@ -78,11 +81,9 @@ 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.fastBoot();
 
-    // Initialize SDL Audio
-    const audio_dev = initAudio(&cpu.bus.apu);
-    defer SDL.SDL_CloseAudioDevice(audio_dev);
+    cpu.bus.apu.attachAudioDevice(audio_dev);
+    cpu.fastBoot();
 
     const log_file: ?File = if (enable_logging) blk: {
         const file = try std.fs.cwd().createFile(if (is_binary) "zba.bin" else "zba.log", .{});
@@ -237,31 +238,19 @@ fn createTexture(renderer: *SDL.SDL_Renderer, width: c_int, height: c_int) *SDL.
     ) orelse sdlPanic();
 }
 
-fn initAudio(apu: *Apu) SDL.SDL_AudioDeviceID {
+fn initAudio() SDL.SDL_AudioDeviceID {
     var have: SDL.SDL_AudioSpec = undefined;
-    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,
-    };
+    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;
 
     const dev = SDL.SDL_OpenAudioDevice(null, 0, &want, &have, 0);
     if (dev == 0) sdlPanic();
 
-    // Start Playback on the Audio device
+    // Start Playback on the Audio evice
     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", .{});
-}