480 lines
17 KiB
Zig
480 lines
17 KiB
Zig
const std = @import("std");
|
|
const SDL = @import("sdl2");
|
|
const io = @import("bus/io.zig");
|
|
const util = @import("../util.zig");
|
|
|
|
const AudioDeviceId = SDL.SDL_AudioDeviceID;
|
|
|
|
const Arm7tdmi = @import("cpu.zig").Arm7tdmi;
|
|
const Scheduler = @import("scheduler.zig").Scheduler;
|
|
const ToneSweep = @import("apu/ToneSweep.zig");
|
|
const Tone = @import("apu/Tone.zig");
|
|
const Wave = @import("apu/Wave.zig");
|
|
const Noise = @import("apu/Noise.zig");
|
|
|
|
const SoundFifo = std.fifo.LinearFifo(u8, .{ .Static = 0x20 });
|
|
|
|
const intToBytes = @import("../util.zig").intToBytes;
|
|
const setHi = @import("../util.zig").setHi;
|
|
const setLo = @import("../util.zig").setLo;
|
|
|
|
const log = std.log.scoped(.APU);
|
|
|
|
pub const host_sample_rate = 1 << 15;
|
|
|
|
pub fn read(comptime T: type, apu: *const Apu, addr: u32) ?T {
|
|
const byte = @truncate(u8, addr);
|
|
|
|
return switch (T) {
|
|
u16 => switch (byte) {
|
|
0x60 => apu.ch1.sound1CntL(),
|
|
0x62 => apu.ch1.sound1CntH(),
|
|
0x64 => apu.ch1.sound1CntX(),
|
|
0x68 => apu.ch2.sound2CntL(),
|
|
0x6C => apu.ch2.sound2CntH(),
|
|
|
|
0x70 => apu.ch3.select.raw & 0xE0, // SOUND3CNT_L
|
|
0x72 => apu.ch3.sound3CntH(),
|
|
0x74 => apu.ch3.freq.raw & 0x4000, // SOUND3CNT_X
|
|
|
|
0x78 => apu.ch4.sound4CntL(),
|
|
0x7C => apu.ch4.sound4CntH(),
|
|
|
|
0x80 => apu.psg_cnt.raw & 0xFF77, // SOUNDCNT_L
|
|
0x82 => apu.dma_cnt.raw & 0x770F, // SOUNDCNT_H
|
|
0x84 => apu.soundCntX(),
|
|
0x88 => apu.bias.raw, // SOUNDBIAS
|
|
0x90...0x9F => apu.ch3.wave_dev.read(T, apu.ch3.select, addr),
|
|
else => util.io.read.undef(T, log, "Tried to perform a {} read to 0x{X:0>8}", .{ T, addr }),
|
|
},
|
|
u8 => switch (byte) {
|
|
0x60 => apu.ch1.sound1CntL(), // NR10
|
|
0x62 => apu.ch1.duty.raw, // NR11
|
|
0x63 => apu.ch1.envelope.raw, // NR12
|
|
0x68 => apu.ch2.duty.raw, // NR21
|
|
0x69 => apu.ch2.envelope.raw, // NR22
|
|
0x73 => apu.ch3.vol.raw, // NR32
|
|
0x79 => apu.ch4.envelope.raw, // NR42
|
|
0x7C => apu.ch4.poly.raw, // NR43
|
|
0x81 => @truncate(u8, apu.psg_cnt.raw >> 8), // NR51
|
|
0x84 => apu.soundCntX(),
|
|
0x89 => @truncate(u8, apu.bias.raw >> 8), // SOUNDBIAS_H
|
|
else => util.io.read.undef(T, log, "Tried to perform a {} read to 0x{X:0>8}", .{ T, addr }),
|
|
},
|
|
u32 => util.io.read.undef(T, log, "Tried to perform a {} read to 0x{X:0>8}", .{ T, addr }),
|
|
else => @compileError("APU: Unsupported read width"),
|
|
};
|
|
}
|
|
|
|
pub fn write(comptime T: type, apu: *Apu, addr: u32, value: T) void {
|
|
const byte = @truncate(u8, addr);
|
|
|
|
switch (T) {
|
|
u32 => switch (byte) {
|
|
0x60 => apu.ch1.setSound1Cnt(value),
|
|
0x64 => apu.ch1.setSound1CntX(&apu.fs, @truncate(u16, value)),
|
|
0x68 => apu.ch2.setSound2CntL(@truncate(u16, value)),
|
|
0x6C => apu.ch2.setSound2CntH(&apu.fs, @truncate(u16, value)),
|
|
0x70 => apu.ch3.setSound3Cnt(value),
|
|
0x74 => apu.ch3.setSound3CntX(&apu.fs, @truncate(u16, value)),
|
|
0x78 => apu.ch4.setSound4CntL(@truncate(u16, value)),
|
|
0x7C => apu.ch4.setSound4CntH(&apu.fs, @truncate(u16, value)),
|
|
|
|
0x80 => apu.setSoundCnt(value),
|
|
// WAVE_RAM
|
|
0x90...0x9F => apu.ch3.wave_dev.write(T, apu.ch3.select, addr, value),
|
|
0xA0 => apu.chA.push(value), // FIFO_A
|
|
0xA4 => apu.chB.push(value), // FIFO_B
|
|
else => util.io.write.undef(log, "Tried to write 0x{X:0>8}{} to 0x{X:0>8}", .{ value, T, addr }),
|
|
},
|
|
u16 => switch (byte) {
|
|
0x60 => apu.ch1.setSound1CntL(@truncate(u8, value)), // SOUND1CNT_L
|
|
0x62 => apu.ch1.setSound1CntH(value),
|
|
0x64 => apu.ch1.setSound1CntX(&apu.fs, value),
|
|
|
|
0x68 => apu.ch2.setSound2CntL(value),
|
|
0x6C => apu.ch2.setSound2CntH(&apu.fs, value),
|
|
|
|
0x70 => apu.ch3.setSound3CntL(@truncate(u8, value)),
|
|
0x72 => apu.ch3.setSound3CntH(value),
|
|
0x74 => apu.ch3.setSound3CntX(&apu.fs, value),
|
|
|
|
0x78 => apu.ch4.setSound4CntL(value),
|
|
0x7C => apu.ch4.setSound4CntH(&apu.fs, value),
|
|
|
|
0x80 => apu.psg_cnt.raw = value, // SOUNDCNT_L
|
|
0x82 => apu.setSoundCntH(value),
|
|
0x84 => apu.setSoundCntX(value >> 7 & 1 == 1),
|
|
0x88 => apu.bias.raw = value, // SOUNDBIAS
|
|
// WAVE_RAM
|
|
0x90...0x9F => apu.ch3.wave_dev.write(T, apu.ch3.select, addr, value),
|
|
else => util.io.write.undef(log, "Tried to write 0x{X:0>4}{} to 0x{X:0>8}", .{ value, T, addr }),
|
|
},
|
|
u8 => switch (byte) {
|
|
0x60 => apu.ch1.setSound1CntL(value),
|
|
0x62 => apu.ch1.setNr11(value),
|
|
0x63 => apu.ch1.setNr12(value),
|
|
0x64 => apu.ch1.setNr13(value),
|
|
0x65 => apu.ch1.setNr14(&apu.fs, value),
|
|
|
|
0x68 => apu.ch2.setNr21(value),
|
|
0x69 => apu.ch2.setNr22(value),
|
|
0x6C => apu.ch2.setNr23(value),
|
|
0x6D => apu.ch2.setNr24(&apu.fs, value),
|
|
|
|
0x70 => apu.ch3.setSound3CntL(value), // NR30
|
|
0x72 => apu.ch3.setNr31(value),
|
|
0x73 => apu.ch3.vol.raw = value, // NR32
|
|
0x74 => apu.ch3.setNr33(value),
|
|
0x75 => apu.ch3.setNr34(&apu.fs, value),
|
|
|
|
0x78 => apu.ch4.setNr41(value),
|
|
0x79 => apu.ch4.setNr42(value),
|
|
0x7C => apu.ch4.poly.raw = value, // NR 43
|
|
0x7D => apu.ch4.setNr44(&apu.fs, value),
|
|
|
|
0x80 => apu.setNr50(value),
|
|
0x81 => apu.setNr51(value),
|
|
0x82 => apu.setSoundCntH(setLo(u16, apu.dma_cnt.raw, value)),
|
|
0x83 => apu.setSoundCntH(setHi(u16, apu.dma_cnt.raw, value)),
|
|
0x84 => apu.setSoundCntX(value >> 7 & 1 == 1), // NR52
|
|
0x89 => apu.setSoundBiasH(value),
|
|
0x90...0x9F => apu.ch3.wave_dev.write(T, apu.ch3.select, addr, value),
|
|
else => util.io.write.undef(log, "Tried to write 0x{X:0>2}{} to 0x{X:0>8}", .{ value, T, addr }),
|
|
},
|
|
else => @compileError("APU: Unsupported write width"),
|
|
}
|
|
}
|
|
|
|
pub const Apu = struct {
|
|
const Self = @This();
|
|
|
|
ch1: ToneSweep,
|
|
ch2: Tone,
|
|
ch3: Wave,
|
|
ch4: Noise,
|
|
chA: DmaSound(.A),
|
|
chB: DmaSound(.B),
|
|
|
|
bias: io.SoundBias,
|
|
/// NR50, NR51
|
|
psg_cnt: io.ChannelVolumeControl,
|
|
dma_cnt: io.DmaSoundControl,
|
|
cnt: io.SoundControl,
|
|
|
|
sampling_cycle: u2,
|
|
|
|
stream: *SDL.SDL_AudioStream,
|
|
sched: *Scheduler,
|
|
|
|
fs: FrameSequencer,
|
|
capacitor: f32,
|
|
|
|
is_buffer_full: bool,
|
|
|
|
pub const Tick = enum { Length, Envelope, Sweep };
|
|
|
|
pub fn init(sched: *Scheduler) Self {
|
|
const apu: Self = .{
|
|
.ch1 = ToneSweep.init(sched),
|
|
.ch2 = Tone.init(sched),
|
|
.ch3 = Wave.init(sched),
|
|
.ch4 = Noise.init(sched),
|
|
.chA = DmaSound(.A).init(),
|
|
.chB = DmaSound(.B).init(),
|
|
|
|
.psg_cnt = .{ .raw = 0 },
|
|
.dma_cnt = .{ .raw = 0 },
|
|
.cnt = .{ .raw = 0 },
|
|
.bias = .{ .raw = 0x0200 },
|
|
|
|
.sampling_cycle = 0b00,
|
|
.stream = SDL.SDL_NewAudioStream(SDL.AUDIO_U16, 2, 1 << 15, SDL.AUDIO_U16, 2, host_sample_rate).?,
|
|
.sched = sched,
|
|
|
|
.capacitor = 0,
|
|
.fs = FrameSequencer.init(),
|
|
.is_buffer_full = false,
|
|
};
|
|
|
|
sched.push(.SampleAudio, apu.interval());
|
|
sched.push(.{ .ApuChannel = 0 }, @import("apu/signal/Square.zig").interval);
|
|
sched.push(.{ .ApuChannel = 1 }, @import("apu/signal/Square.zig").interval);
|
|
sched.push(.{ .ApuChannel = 2 }, @import("apu/signal/Wave.zig").interval);
|
|
sched.push(.{ .ApuChannel = 3 }, @import("apu/signal/Lfsr.zig").interval);
|
|
sched.push(.FrameSequencer, FrameSequencer.interval);
|
|
|
|
return apu;
|
|
}
|
|
|
|
fn reset(self: *Self) void {
|
|
self.ch1.reset();
|
|
self.ch2.reset();
|
|
self.ch3.reset();
|
|
self.ch4.reset();
|
|
}
|
|
|
|
/// SOUNDCNT
|
|
fn setSoundCnt(self: *Self, value: u32) void {
|
|
self.psg_cnt.raw = @truncate(u16, value);
|
|
self.setSoundCntH(@truncate(u16, value >> 16));
|
|
}
|
|
|
|
/// SOUNDCNT_H
|
|
pub fn setSoundCntH(self: *Self, value: u16) void {
|
|
const new: io.DmaSoundControl = .{ .raw = value };
|
|
|
|
// Reinitializing instead of resetting is fine because
|
|
// the FIFOs I'm using are stack allocated and 0x20 bytes big
|
|
if (new.chA_reset.read()) self.chA.fifo = SoundFifo.init();
|
|
if (new.chB_reset.read()) self.chB.fifo = SoundFifo.init();
|
|
|
|
self.dma_cnt = new;
|
|
}
|
|
|
|
/// NR52
|
|
pub fn setSoundCntX(self: *Self, value: bool) void {
|
|
self.cnt.apu_enable.write(value);
|
|
|
|
if (value) {
|
|
self.fs.step = 0; // Reset Frame Sequencer
|
|
|
|
// Reset Square Wave Offsets
|
|
self.ch1.square.pos = 0;
|
|
self.ch2.square.pos = 0;
|
|
|
|
// Reset Wave Device Offsets
|
|
self.ch3.wave_dev.offset = 0;
|
|
} else {
|
|
self.reset();
|
|
}
|
|
}
|
|
|
|
/// NR52
|
|
pub fn soundCntX(self: *const Self) u8 {
|
|
const apu_enable: u8 = @boolToInt(self.cnt.apu_enable.read());
|
|
|
|
const ch1_enable: u8 = @boolToInt(self.ch1.enabled);
|
|
const ch2_enable: u8 = @boolToInt(self.ch2.enabled);
|
|
const ch3_enable: u8 = @boolToInt(self.ch3.enabled);
|
|
const ch4_enable: u8 = @boolToInt(self.ch4.enabled);
|
|
|
|
return apu_enable << 7 | ch4_enable << 3 | ch3_enable << 2 | ch2_enable << 1 | ch1_enable;
|
|
}
|
|
|
|
/// NR50
|
|
pub fn setNr50(self: *Self, byte: u8) void {
|
|
self.psg_cnt.raw = (self.psg_cnt.raw & 0xFF00) | byte;
|
|
}
|
|
|
|
/// NR51
|
|
pub fn setNr51(self: *Self, byte: u8) void {
|
|
self.psg_cnt.raw = @as(u16, byte) << 8 | (self.psg_cnt.raw & 0xFF);
|
|
}
|
|
|
|
pub fn setSoundBiasH(self: *Self, byte: u8) void {
|
|
self.bias.raw = (@as(u16, byte) << 8) | (self.bias.raw & 0xFF);
|
|
}
|
|
|
|
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;
|
|
|
|
// SOUNDCNT_L Channel Enable flags
|
|
const ch_left: u4 = self.psg_cnt.ch_left.read();
|
|
const ch_right: u4 = self.psg_cnt.ch_right.read();
|
|
|
|
// Determine SOUNDCNT_H volume modifications
|
|
const gba_vol: u4 = switch (self.dma_cnt.ch_vol.read()) {
|
|
0b00 => 2,
|
|
0b01 => 1,
|
|
else => 0,
|
|
};
|
|
|
|
// Add all PSG channels together
|
|
left += if (ch_left & 1 == 1) @as(i16, self.ch1.sample) else 0;
|
|
left += if (ch_left >> 1 & 1 == 1) @as(i16, self.ch2.sample) else 0;
|
|
left += if (ch_left >> 2 & 1 == 1) @as(i16, self.ch3.sample) else 0;
|
|
left += if (ch_left >> 3 == 1) @as(i16, self.ch4.sample) else 0;
|
|
|
|
right += if (ch_right & 1 == 1) @as(i16, self.ch1.sample) else 0;
|
|
right += if (ch_right >> 1 & 1 == 1) @as(i16, self.ch2.sample) else 0;
|
|
right += if (ch_right >> 2 & 1 == 1) @as(i16, self.ch3.sample) else 0;
|
|
right += if (ch_right >> 3 == 1) @as(i16, self.ch4.sample) else 0;
|
|
|
|
// Multiply by master channel volume
|
|
left *= 1 + @as(i16, self.psg_cnt.left_vol.read());
|
|
right *= 1 + @as(i16, self.psg_cnt.right_vol.read());
|
|
|
|
// Apply GBA volume modifications to PSG Channels
|
|
left >>= gba_vol;
|
|
right >>= gba_vol;
|
|
|
|
const chA_sample = self.chA.amplitude() << if (self.dma_cnt.chA_vol.read()) @as(u4, 2) else 1;
|
|
const chB_sample = self.chB.amplitude() << if (self.dma_cnt.chB_vol.read()) @as(u4, 2) else 1;
|
|
|
|
left += if (self.dma_cnt.chA_left.read()) chA_sample else 0;
|
|
left += if (self.dma_cnt.chB_left.read()) chB_sample else 0;
|
|
|
|
right += if (self.dma_cnt.chA_right.read()) chA_sample else 0;
|
|
right += if (self.dma_cnt.chB_right.read()) chB_sample else 0;
|
|
|
|
// Add SOUNDBIAS
|
|
// FIXME: Is SOUNDBIAS 9-bit or 10-bit?
|
|
const bias = @as(i16, self.bias.level.read()) << 1;
|
|
left += bias;
|
|
right += bias;
|
|
|
|
const clamped_left = std.math.clamp(@bitCast(u16, left), std.math.minInt(u11), std.math.maxInt(u11));
|
|
const clamped_right = std.math.clamp(@bitCast(u16, right), std.math.minInt(u11), std.math.maxInt(u11));
|
|
|
|
// Extend to 16-bit signed audio samples
|
|
const ext_left = (clamped_left << 5) | (clamped_left >> 6);
|
|
const ext_right = (clamped_right << 5) | (clamped_right >> 6);
|
|
|
|
// FIXME: This rarely happens
|
|
if (self.sampling_cycle != self.bias.sampling_cycle.read()) self.replaceSDLResampler();
|
|
|
|
_ = 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), SDL.AUDIO_U16, 2, host_sample_rate).?;
|
|
}
|
|
|
|
fn interval(self: *const Self) u64 {
|
|
return (1 << 24) / Self.sampleRate(self.bias.sampling_cycle.read());
|
|
}
|
|
|
|
fn sampleRate(cycle: u2) u64 {
|
|
return @as(u64, 1) << (15 + @as(u6, cycle));
|
|
}
|
|
|
|
pub fn onSequencerTick(self: *Self, late: u64) void {
|
|
self.fs.tick();
|
|
|
|
switch (self.fs.step) {
|
|
7 => self.tick(.Envelope), // Clock Envelope
|
|
0, 4 => self.tick(.Length), // Clock Length
|
|
2, 6 => {
|
|
// Clock Length and Sweep
|
|
self.tick(.Length);
|
|
self.tick(.Sweep);
|
|
},
|
|
1, 3, 5 => {},
|
|
}
|
|
|
|
self.sched.push(.FrameSequencer, ((1 << 24) / 512) -| late);
|
|
}
|
|
|
|
fn tick(self: *Self, comptime kind: Tick) void {
|
|
self.ch1.tick(kind);
|
|
|
|
switch (kind) {
|
|
.Length => {
|
|
self.ch2.tick(kind);
|
|
self.ch3.tick(kind);
|
|
self.ch4.tick(kind);
|
|
},
|
|
.Envelope => {
|
|
self.ch2.tick(kind);
|
|
self.ch4.tick(kind);
|
|
},
|
|
.Sweep => {}, // Already handled above (only for Ch1)
|
|
}
|
|
}
|
|
|
|
pub fn onDmaAudioSampleRequest(self: *Self, cpu: *Arm7tdmi, tim_id: u3) void {
|
|
if (!self.cnt.apu_enable.read()) return;
|
|
|
|
if (@boolToInt(self.dma_cnt.chA_timer.read()) == tim_id) {
|
|
self.chA.updateSample();
|
|
if (self.chA.len() <= 15) cpu.bus.dma[1].requestAudio(0x0400_00A0);
|
|
}
|
|
|
|
if (@boolToInt(self.dma_cnt.chB_timer.read()) == tim_id) {
|
|
self.chB.updateSample();
|
|
if (self.chB.len() <= 15) cpu.bus.dma[2].requestAudio(0x0400_00A4);
|
|
}
|
|
}
|
|
};
|
|
|
|
pub fn DmaSound(comptime kind: DmaSoundKind) type {
|
|
return struct {
|
|
const Self = @This();
|
|
|
|
fifo: SoundFifo,
|
|
kind: DmaSoundKind,
|
|
sample: i8,
|
|
|
|
fn init() Self {
|
|
return .{
|
|
.fifo = SoundFifo.init(),
|
|
.kind = kind,
|
|
.sample = 0,
|
|
};
|
|
}
|
|
|
|
pub fn push(self: *Self, value: u32) void {
|
|
self.fifo.write(&intToBytes(u32, value)) catch |e| log.err("{} Error: {}", .{ kind, e });
|
|
}
|
|
|
|
pub fn len(self: *const Self) usize {
|
|
return self.fifo.readableLength();
|
|
}
|
|
|
|
pub fn updateSample(self: *Self) void {
|
|
if (self.fifo.readItem()) |sample| self.sample = @bitCast(i8, sample);
|
|
}
|
|
|
|
pub fn amplitude(self: *const Self) i16 {
|
|
return @as(i16, self.sample);
|
|
}
|
|
};
|
|
}
|
|
|
|
const DmaSoundKind = enum {
|
|
A,
|
|
B,
|
|
};
|
|
|
|
pub const FrameSequencer = struct {
|
|
const interval = (1 << 24) / 512;
|
|
const Self = @This();
|
|
|
|
step: u3,
|
|
|
|
pub fn init() Self {
|
|
return .{ .step = 0 };
|
|
}
|
|
|
|
pub fn tick(self: *Self) void {
|
|
self.step +%= 1;
|
|
}
|
|
|
|
pub fn isLengthNext(self: *const Self) bool {
|
|
return (self.step +% 1) & 1 == 0; // Steps, 0, 2, 4, and 6 clock length
|
|
}
|
|
|
|
pub fn isEnvelopeNext(self: *const Self) bool {
|
|
return (self.step +% 1) == 7;
|
|
}
|
|
};
|