aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/apu.rs414
1 files changed, 414 insertions, 0 deletions
diff --git a/src/apu.rs b/src/apu.rs
new file mode 100644
index 0000000..57525bf
--- /dev/null
+++ b/src/apu.rs
@@ -0,0 +1,414 @@
+#![allow(dead_code)]
+use mos6502;
+
+pub trait Speaker {
+ fn queue(&mut self, sample: u16);
+ fn push(&mut self);
+}
+
+const CPU_SAMPLE_FREQ: u32 = 240;
+pub const AUDIO_SAMPLE_FREQ: u32 = 44100;
+
+const LEN_TABLE: [u8; 32] = [
+ 10, 254, 20, 2, 40, 4, 80, 6, 160, 8, 60, 10, 14, 12, 26, 14,
+ 12, 16, 24, 18, 48, 20, 96, 22, 192, 24, 72, 26, 16, 28, 32, 30,
+];
+
+const DUTY_TABLE: [u8; 4] = [
+ 0b00000010,
+ 0b00000110,
+ 0b00011110,
+ 0b11111001,
+];
+
+const PULSE_TABLE: [u16; 31] = [
+ 0x0000, 0x02f8, 0x05df, 0x08b4, 0x0b78, 0x0e2b,
+ 0x10cf, 0x1363, 0x15e9, 0x1860, 0x1ac9, 0x1d25,
+ 0x1f75, 0x21b7, 0x23ee, 0x2618, 0x2837, 0x2a4c,
+ 0x2c55, 0x2e54, 0x3049, 0x3234, 0x3416, 0x35ee,
+ 0x37be, 0x3985, 0x3b43, 0x3cf9, 0x3ea7, 0x404d,
+ 0x41ec
+];
+
+const TND_TABLE: [u16; 203] = [
+ 0x0000, 0x01b7, 0x036a, 0x051a, 0x06c6, 0x086f,
+ 0x0a15, 0x0bb7, 0x0d56, 0x0ef2, 0x108a, 0x121f,
+ 0x13b1, 0x1540, 0x16cc, 0x1855, 0x19da, 0x1b5d,
+ 0x1cdd, 0x1e59, 0x1fd3, 0x214a, 0x22be, 0x2430,
+ 0x259e, 0x270a, 0x2874, 0x29da, 0x2b3e, 0x2c9f,
+ 0x2dfe, 0x2f5a, 0x30b4, 0x320b, 0x335f, 0x34b2,
+ 0x3601, 0x374f, 0x389a, 0x39e2, 0x3b29, 0x3c6d,
+ 0x3dae, 0x3eee, 0x402b, 0x4166, 0x429f, 0x43d6,
+ 0x450a, 0x463d, 0x476d, 0x489c, 0x49c8, 0x4af2,
+ 0x4c1b, 0x4d41, 0x4e65, 0x4f87, 0x50a8, 0x51c6,
+ 0x52e3, 0x53fe, 0x5517, 0x562e, 0x5743, 0x5856,
+ 0x5968, 0x5a78, 0x5b86, 0x5c93, 0x5d9d, 0x5ea6,
+ 0x5fae, 0x60b3, 0x61b7, 0x62ba, 0x63bb, 0x64ba,
+ 0x65b7, 0x66b3, 0x67ae, 0x68a7, 0x699e, 0x6a94,
+ 0x6b88, 0x6c7b, 0x6d6d, 0x6e5d, 0x6f4b, 0x7038,
+ 0x7124, 0x720e, 0x72f7, 0x73de, 0x74c4, 0x75a9,
+ 0x768c, 0x776e, 0x784f, 0x792e, 0x7a0d, 0x7ae9,
+ 0x7bc5, 0x7c9f, 0x7d78, 0x7e50, 0x7f26, 0x7ffc,
+ 0x80d0, 0x81a3, 0x8274, 0x8345, 0x8414, 0x84e2,
+ 0x85af, 0x867b, 0x8746, 0x880f, 0x88d8, 0x899f,
+ 0x8a65, 0x8b2b, 0x8bef, 0x8cb2, 0x8d74, 0x8e35,
+ 0x8ef4, 0x8fb3, 0x9071, 0x912e, 0x91ea, 0x92a4,
+ 0x935e, 0x9417, 0x94cf, 0x9586, 0x963c, 0x96f0,
+ 0x97a4, 0x9857, 0x990a, 0x99bb, 0x9a6b, 0x9b1a,
+ 0x9bc9, 0x9c76, 0x9d23, 0x9dcf, 0x9e7a, 0x9f24,
+ 0x9fcd, 0xa075, 0xa11c, 0xa1c3, 0xa269, 0xa30e,
+ 0xa3b2, 0xa455, 0xa4f7, 0xa599, 0xa63a, 0xa6da,
+ 0xa779, 0xa818, 0xa8b5, 0xa952, 0xa9ef, 0xaa8a,
+ 0xab25, 0xabbe, 0xac58, 0xacf0, 0xad88, 0xae1f,
+ 0xaeb5, 0xaf4a, 0xafdf, 0xb073, 0xb107, 0xb199,
+ 0xb22b, 0xb2bd, 0xb34d, 0xb3dd, 0xb46c, 0xb4fb,
+ 0xb589, 0xb616, 0xb6a3, 0xb72f, 0xb7ba, 0xb845,
+ 0xb8cf, 0xb958, 0xb9e1, 0xba69, 0xbaf1, 0xbb78,
+ 0xbbfe, 0xbc84, 0xbd09, 0xbd8d, 0xbe11
+];
+
+struct Sampler {
+ ticks_remain: u32,
+ ticks_now: u32,
+ ticks_unit: u32,
+ ticks_all: u32,
+ ticks_extra: u32,
+ ticks_extra_all: u32,
+}
+
+impl Sampler {
+ fn new(freq1: u32, freq2: u32) -> Self {
+ let unit = freq1 / freq2;
+ let extra = freq1 - unit * freq2;
+ Sampler {
+ ticks_remain: freq1 - extra,
+ ticks_now: 0,
+ ticks_unit: unit,
+ ticks_all: freq1 - extra,
+ ticks_extra: extra,
+ ticks_extra_all: extra
+ }
+ }
+
+ fn tick(&mut self) -> (bool, bool) {
+ let unit = self.ticks_unit;
+ if self.ticks_now == 0 {
+ self.ticks_now = unit;
+ self.ticks_remain -= unit;
+ if self.ticks_remain == 0 {
+ /* compensate to last exactly 1 sec */
+ self.ticks_now += self.ticks_remain;
+ /* reload for the next second */
+ self.ticks_remain = self.ticks_all;
+ self.ticks_extra = self.ticks_extra_all;
+ }
+ if self.ticks_extra > 0 {
+ self.ticks_extra -= 1;
+ self.ticks_now += 1;
+ }
+ }
+ self.ticks_now -= 1;
+ (self.ticks_now == 0, self.ticks_remain == self.ticks_all)
+ }
+}
+
+pub struct Pulse {
+ /* envelope */
+ env_period: u8,
+ env_lvl: u8,
+ decay_lvl: u8,
+ env_start: bool,
+ env_loop: bool,
+ env_const: bool,
+ env_vol: u8,
+ /* sweep */
+ swp_count: u8,
+ swp_period: u8,
+ swp_lvl: u8,
+ swp_en: bool,
+ swp_neg: bool,
+ swp_rld: bool,
+ muted: bool,
+ /* length counter */
+ len_lvl: u8,
+ /* timer */
+ timer_period: u16,
+ timer_lvl: u16,
+ /* sequencer */
+ seq_wave: u8,
+ seq_cnt: u8,
+ /* channel */
+ enabled: bool,
+ comple: bool,
+}
+
+impl Pulse {
+ fn tick_env(&mut self) {
+ /* should be clocked by frame counter */
+ if !self.env_start {
+ if self.env_lvl == 0 {
+ self.env_lvl = self.env_period;
+ if self.decay_lvl == 0 {
+ if self.env_loop {
+ self.decay_lvl = 15;
+ }
+ } else {
+ self.decay_lvl -= 1;
+ }
+ } else {
+ self.env_lvl -= 1;
+ }
+ } else {
+ self.decay_lvl = 15;
+ self.env_start = false;
+ self.env_lvl = self.env_period;
+ }
+ }
+
+ fn tick_sweep(&mut self) {
+ let mut reload = self.swp_rld;
+ if self.swp_lvl == 0 {
+ reload = true;
+ let p = self.timer_period;
+ let mut delta = p >> self.swp_count;
+ if self.swp_neg {
+ delta = !delta;
+ if self.comple { delta += 1; } /* two's complement */
+ }
+ p.wrapping_add(delta);
+ self.muted = self.timer_period < 8 || (self.timer_period >> 11 != 0);
+ if !self.muted && self.swp_en && self.swp_count != 0 {
+ self.timer_period = p;
+ }
+ } else {
+ self.swp_lvl -= 1;
+ }
+ if reload {
+ self.swp_lvl = self.swp_period;
+ self.swp_rld = false;
+ }
+ }
+
+ fn disable(&mut self) {
+ self.len_lvl = 0;
+ self.enabled = false;
+ }
+
+ fn enable(&mut self) { self.enabled = true }
+
+ fn tick_length(&mut self) {
+ if self.len_lvl > 0 && !self.env_loop {
+ self.len_lvl -= 1
+ }
+ }
+
+ fn tick_timer(&mut self) {
+ if self.timer_lvl == 0 {
+ self.timer_lvl = self.timer_period;
+ if self.seq_cnt == 7 {
+ self.seq_cnt = 0
+ } else {
+ self.seq_cnt += 1
+ }
+ } else {
+ self.timer_lvl -= 1
+ }
+ }
+
+ fn get_len(&self) -> u8 { self.len_lvl }
+ fn set_duty(&mut self, b: u8) { self.seq_wave = DUTY_TABLE[b as usize] }
+ fn set_loop(&mut self, b: bool) { self.env_loop = b }
+ fn set_const(&mut self, b: bool) { self.env_const = b }
+ fn set_env_period(&mut self, p: u8) { self.env_period = p } /* 4 bits */
+ fn set_env_vol(&mut self, p: u8) { self.env_vol = p }
+ fn set_sweep(&mut self, d: u8) {
+ self.swp_en = (d >> 7) == 1;
+ self.swp_period = (d >> 4) & 7;
+ self.swp_neg = d & 0x8 == 0x8;
+ self.swp_count = d & 7;
+ self.swp_rld = true;
+ }
+
+ fn set_timer_period(&mut self, p: u16) {
+ self.muted = p < 8;
+ self.timer_period = p;
+ }
+
+ fn set_len(&mut self, d: u8) {
+ if self.enabled {
+ self.len_lvl = LEN_TABLE[d as usize]
+ }
+ }
+
+ pub fn write_reg1(&mut self, data: u8) {
+ self.set_duty(data >> 6);
+ self.set_loop(data & 0x20 == 0x20);
+ self.set_const(data & 0x10 == 0x10);
+ self.set_env_period(data & 0xf);
+ self.set_env_vol(data & 0xf);
+ self.env_start = true;
+ }
+
+ pub fn write_reg2(&mut self, data: u8) { self.set_sweep(data) }
+
+ pub fn write_reg3(&mut self, data: u8) {
+ self.timer_period = (self.timer_period & 0xff00) | data as u16
+ }
+
+ pub fn write_reg4(&mut self, data: u8) {
+ self.set_len(data >> 3);
+ self.timer_period = (self.timer_period & 0x00ff) | ((data as u16 & 7) << 8);
+ self.seq_cnt = 0;
+ self.env_start = true;
+ }
+
+ pub fn output(&self) -> u8 {
+ let env = if self.env_const { self.env_vol } else { self.decay_lvl };
+ let swp = !self.muted;
+ let seq = (self.seq_wave >> self.seq_cnt) & 1 == 1;
+ let len = self.len_lvl > 0;
+ if swp && seq && len { env } else { 0 }
+ }
+
+ pub fn new(comple: bool) -> Self {
+ Pulse {env_period: 0, env_lvl: 0, decay_lvl: 0,
+ env_start: false, env_loop: false, env_const: false, env_vol: 0,
+ swp_count: 0, swp_period: 0, swp_lvl: 0,
+ swp_en: false, swp_neg: false, swp_rld: false, muted: true,
+ len_lvl: 0, timer_period: 0, timer_lvl: 0,
+ seq_wave: 0, seq_cnt: 0, enabled: false, comple}
+ }
+}
+
+pub struct APU<'a> {
+ pub pulse1: Pulse,
+ pub pulse2: Pulse,
+ frame_lvl: u8,
+ frame_mode: bool, /* true for 5-step mode */
+ frame_inh: bool,
+ frame_int: bool,
+ cpu_sampler: Sampler,
+ audio_sampler: Sampler,
+ cycle_even: bool,
+ spkr: &'a mut Speaker
+}
+
+impl<'a> APU<'a> {
+ fn tick_env(&mut self) {
+ self.pulse1.tick_env();
+ self.pulse2.tick_env();
+ }
+
+ fn tick_len_swp(&mut self) {
+ self.pulse1.tick_length();
+ self.pulse1.tick_sweep();
+ self.pulse2.tick_length();
+ self.pulse2.tick_sweep();
+ }
+
+ pub fn new(spkr: &'a mut Speaker) -> Self {
+ APU {
+ pulse1: Pulse::new(false), pulse2: Pulse::new(true),
+ frame_lvl: 0, frame_mode: false, frame_int: false, frame_inh: false,
+ cpu_sampler: Sampler::new(mos6502::CPU_FREQ, CPU_SAMPLE_FREQ),
+ audio_sampler: Sampler::new(mos6502::CPU_FREQ, AUDIO_SAMPLE_FREQ),
+ cycle_even: false,
+ spkr
+ }
+ }
+
+ pub fn output(&self) -> u16 {
+ let pulse_out = PULSE_TABLE[(self.pulse1.output() +
+ self.pulse2.output()) as usize];
+ let tnd_out = TND_TABLE[0];
+ pulse_out + tnd_out
+ }
+
+ pub fn read_status(&mut self) -> u8 {
+ let res = if self.pulse1.get_len() > 0 { 1 } else { 0 } |
+ (if self.pulse1.get_len() > 0 { 1 } else { 0 }) << 1 |
+ (if self.frame_int { 1 } else { 0 }) << 6;
+ if self.frame_lvl != 3 {
+ self.frame_int = false; /* clear interrupt flag */
+ }
+ res
+ }
+
+ pub fn write_status(&mut self, data: u8) {
+ match data & 0x1 {
+ 0 => self.pulse1.disable(),
+ _ => self.pulse1.enable()
+ }
+ match data & 0x2 {
+ 0 => self.pulse2.disable(),
+ _ => self.pulse2.enable()
+ }
+ }
+
+ pub fn write_frame_counter(&mut self, data: u8) {
+ self.frame_inh = data & 0x40 == 1;
+ self.frame_mode = data >> 7 == 1;
+ }
+
+ pub fn tick_timer(&mut self) {
+ if self.cycle_even {
+ self.pulse1.tick_timer();
+ self.pulse2.tick_timer();
+ }
+ }
+
+ fn tick_frame_counter(&mut self) -> bool {
+ let f = self.frame_lvl;
+ match self.frame_mode {
+ false => {
+ match f {
+ 0 | 2 => self.tick_env(),
+ 1 => {
+ self.tick_env();
+ self.tick_len_swp();
+ },
+ _ => {
+ self.tick_env();
+ self.tick_len_swp();
+ if !self.frame_inh {
+ self.frame_int = true;
+ }
+ },
+ };
+ self.frame_lvl = if f == 3 { 0 } else { f + 1 }
+ },
+ true => {
+ match f {
+ 0 | 2 => self.tick_env(),
+ 1 | 4 => {
+ self.tick_env();
+ self.tick_len_swp();
+ },
+ _ => ()
+ }
+ self.frame_lvl = if f == 4 { 0 } else { f + 1 }
+ }
+ }
+ self.frame_int
+ }
+
+ pub fn tick(&mut self) -> bool {
+ let mut irq = false;
+ if let (true, _) = self.cpu_sampler.tick() {
+ irq = self.tick_frame_counter();
+ //print!("+");
+ }
+ if let (true, sec) = self.audio_sampler.tick() {
+ let sample = self.output();
+ self.spkr.queue(sample);
+ //print!(".");
+ if sec {
+ self.spkr.push();
+ //println!("ok");
+ }
+ }
+ self.tick_timer();
+ self.cycle_even = !self.cycle_even;
+ irq
+ }
+}