256 lines
8.1 KiB
Zig
256 lines
8.1 KiB
Zig
const std = @import("std");
|
|
const SDL = @import("sdl2");
|
|
const config = @import("../config.zig");
|
|
|
|
const Scheduler = @import("scheduler.zig").Scheduler;
|
|
const Arm7tdmi = @import("cpu.zig").Arm7tdmi;
|
|
const Tracker = @import("../util.zig").FpsTracker;
|
|
const Channel = @import("zba-util").Channel(Message, 0x100);
|
|
|
|
pub const Message = enum { Pause, Resume, Quit };
|
|
|
|
const Timer = std.time.Timer;
|
|
|
|
/// 4 Cycles in 1 dot
|
|
const cycles_per_dot = 4;
|
|
|
|
/// The GBA draws 228 Horizontal which each consist 308 dots
|
|
/// (note: not all lines are visible)
|
|
const cycles_per_frame = 228 * (308 * cycles_per_dot); //280896
|
|
|
|
/// The GBA ARM7TDMI runs at 2^24 Hz
|
|
const clock_rate = 1 << 24; // 16.78MHz
|
|
|
|
/// The # of nanoseconds a frame should take
|
|
const frame_period = (std.time.ns_per_s * cycles_per_frame) / clock_rate;
|
|
|
|
/// Exact Value: 59.7275005696Hz
|
|
/// The inverse of the frame period
|
|
pub const frame_rate: f64 = @intToFloat(f64, clock_rate) / cycles_per_frame;
|
|
|
|
const log = std.log.scoped(.Emulation);
|
|
|
|
const RunKind = enum {
|
|
Unlimited,
|
|
UnlimitedFPS,
|
|
Limited,
|
|
LimitedFPS,
|
|
};
|
|
|
|
pub fn run(cpu: *Arm7tdmi, scheduler: *Scheduler, tracker: *Tracker, rx: Channel.Receiver) 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, cpu, scheduler, tracker, rx);
|
|
} else {
|
|
inner(.UnlimitedFPS, audio_sync, cpu, scheduler, tracker, rx);
|
|
}
|
|
}
|
|
|
|
fn inner(comptime kind: RunKind, audio_sync: bool, cpu: *Arm7tdmi, scheduler: *Scheduler, tracker: ?*Tracker, rx: Channel.Receiver) void {
|
|
if (kind == .UnlimitedFPS or kind == .LimitedFPS) {
|
|
std.debug.assert(tracker != null);
|
|
log.info("FPS tracking enabled", .{});
|
|
}
|
|
|
|
var paused: bool = false;
|
|
|
|
switch (kind) {
|
|
.Unlimited, .UnlimitedFPS => {
|
|
log.info("Emulation w/out video sync", .{});
|
|
|
|
while (true) {
|
|
if (rx.recv()) |m| switch (m) {
|
|
.Quit => break,
|
|
.Resume, .Pause => paused = m == .Pause,
|
|
};
|
|
|
|
if (paused) continue;
|
|
|
|
runFrame(scheduler, cpu);
|
|
audioSync(audio_sync, cpu.bus.apu.stream, &cpu.bus.apu.is_buffer_full);
|
|
|
|
if (kind == .UnlimitedFPS) tracker.?.tick();
|
|
}
|
|
},
|
|
.Limited, .LimitedFPS => {
|
|
log.info("Emulation w/ video sync", .{});
|
|
var timer = Timer.start() catch @panic("failed to initalize std.timer.Timer");
|
|
var wake_time: u64 = frame_period;
|
|
|
|
while (true) {
|
|
if (rx.recv()) |m| switch (m) {
|
|
.Quit => break,
|
|
.Resume, .Pause => paused = m == .Pause,
|
|
};
|
|
|
|
if (paused) continue;
|
|
|
|
runFrame(scheduler, cpu);
|
|
const new_wake_time = videoSync(&timer, wake_time);
|
|
|
|
// Spin to make up the difference of OS scheduler innacuracies
|
|
// If we happen to also be syncing to audio, we choose to spin on
|
|
// 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);
|
|
if (!audio_sync) spinLoop(&timer, wake_time);
|
|
wake_time = new_wake_time;
|
|
|
|
if (kind == .LimitedFPS) tracker.?.tick();
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
pub fn runFrame(sched: *Scheduler, cpu: *Arm7tdmi) void {
|
|
const frame_end = sched.tick + cycles_per_frame;
|
|
|
|
while (sched.tick < frame_end) {
|
|
if (!cpu.stepDmaTransfer()) {
|
|
if (cpu.isHalted()) {
|
|
// Fast-forward to next Event
|
|
sched.tick = sched.nextTimestamp();
|
|
} else {
|
|
cpu.step();
|
|
}
|
|
}
|
|
|
|
if (sched.tick >= sched.nextTimestamp()) sched.handleEvent(cpu);
|
|
}
|
|
}
|
|
|
|
fn audioSync(audio_sync: bool, stream: *SDL.SDL_AudioStream, is_buffer_full: *bool) void {
|
|
comptime std.debug.assert(@import("../platform.zig").sample_format == SDL.AUDIO_U16);
|
|
const sample_size = 2 * @sizeOf(u16);
|
|
const max_buf_size: c_int = 0x400;
|
|
|
|
// Determine whether the APU is busy right at this moment
|
|
var still_full: bool = SDL.SDL_AudioStreamAvailable(stream) > sample_size * if (is_buffer_full.*) max_buf_size >> 1 else max_buf_size;
|
|
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;
|
|
|
|
// TODO: Refactor!!!!
|
|
// while (SDL.SDL_AudioStreamAvailable(stream) > sample_size * max_buf_size >> 1)
|
|
// std.atomic.spinLoopHint();
|
|
|
|
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 {
|
|
// Use the OS scheduler to put the emulation thread to sleep
|
|
const recalculated = sleep(timer, wake_time);
|
|
|
|
// If sleep() determined we need to adjust our wake up time, do so
|
|
// otherwise predict our next wake up time according to the frame period
|
|
return recalculated orelse wake_time + frame_period;
|
|
}
|
|
|
|
// TODO: Better sleep impl?
|
|
fn sleep(timer: *Timer, wake_time: u64) ?u64 {
|
|
const timestamp = timer.read();
|
|
|
|
// ns_late is non zero if we are late.
|
|
var ns_late = timestamp -| wake_time;
|
|
|
|
// If we're more than a frame late, skip the rest of this loop
|
|
// Recalculate what our new wake time should be so that we can
|
|
// get "back on track"
|
|
if (ns_late > frame_period) return timestamp + frame_period;
|
|
const sleep_for = frame_period - ns_late;
|
|
|
|
const step = 2 * std.time.ns_per_ms; // Granularity of 2ms
|
|
const times = sleep_for / step;
|
|
|
|
for (0..times) |_| {
|
|
std.time.sleep(step);
|
|
|
|
// Upon wakeup, check to see if this particular sleep was longer than expected
|
|
// if so we should exit early, but probably not skip a whole frame period
|
|
ns_late = timer.read() -| wake_time;
|
|
if (ns_late > frame_period) return null;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
fn spinLoop(timer: *Timer, wake_time: u64) void {
|
|
while (timer.read() < wake_time)
|
|
std.atomic.spinLoopHint();
|
|
}
|
|
|
|
pub const EmuThing = struct {
|
|
const Self = @This();
|
|
const Interface = @import("gdbstub").Emulator;
|
|
const Allocator = std.mem.Allocator;
|
|
|
|
cpu: *Arm7tdmi,
|
|
scheduler: *Scheduler,
|
|
|
|
pub fn init(cpu: *Arm7tdmi, scheduler: *Scheduler) Self {
|
|
return .{ .cpu = cpu, .scheduler = scheduler };
|
|
}
|
|
|
|
pub fn interface(self: *Self, allocator: Allocator) Interface {
|
|
return Interface.init(allocator, self);
|
|
}
|
|
|
|
pub fn read(self: *const Self, addr: u32) u8 {
|
|
return self.cpu.bus.dbgRead(u8, addr);
|
|
}
|
|
|
|
pub fn write(self: *Self, addr: u32, value: u8) void {
|
|
self.cpu.bus.dbgWrite(u8, addr, value);
|
|
}
|
|
|
|
pub fn registers(self: *const Self) *[16]u32 {
|
|
return &self.cpu.r;
|
|
}
|
|
|
|
pub fn cpsr(self: *const Self) u32 {
|
|
return self.cpu.cpsr.raw;
|
|
}
|
|
|
|
pub fn step(self: *Self) void {
|
|
const cpu = self.cpu;
|
|
const sched = self.scheduler;
|
|
|
|
// Is true when we have executed one (1) instruction
|
|
var did_step: bool = false;
|
|
|
|
// TODO: How can I make it easier to keep this in lock-step with runFrame?
|
|
while (!did_step) {
|
|
if (!cpu.stepDmaTransfer()) {
|
|
if (cpu.isHalted()) {
|
|
// Fast-forward to next Event
|
|
sched.tick = sched.queue.peek().?.tick;
|
|
} else {
|
|
cpu.step();
|
|
did_step = true;
|
|
}
|
|
}
|
|
|
|
if (sched.tick >= sched.nextTimestamp()) sched.handleEvent(cpu);
|
|
}
|
|
}
|
|
};
|
|
|
|
pub fn reset(cpu: *Arm7tdmi) void {
|
|
// @breakpoint();
|
|
cpu.sched.reset(); // Yes this is order sensitive, see the PPU reset for why
|
|
cpu.bus.reset();
|
|
cpu.reset();
|
|
}
|
|
|
|
pub fn replaceGamepak(cpu: *Arm7tdmi, file_path: []const u8) !void {
|
|
try cpu.bus.replaceGamepak(file_path);
|
|
reset(cpu);
|
|
}
|