chore(apu): improve code organization
continuous-integration/drone/push Build is passing Details

This commit is contained in:
Rekai Nyangadzayi Musuka 2021-08-18 00:01:02 -05:00
parent 5d64e539a7
commit 360a9a7b65
4 changed files with 97 additions and 97 deletions

View File

@ -5,7 +5,7 @@ use types::ch1::{Sweep, SweepDirection};
use types::ch3::Volume as Ch3Volume; use types::ch3::Volume as Ch3Volume;
use types::ch4::{CounterWidth, Frequency as Ch4Frequency, PolynomialCounter}; use types::ch4::{CounterWidth, Frequency as Ch4Frequency, PolynomialCounter};
use types::common::{EnvelopeDirection, FrequencyHigh, SoundDuty, VolumeEnvelope}; use types::common::{EnvelopeDirection, FrequencyHigh, SoundDuty, VolumeEnvelope};
use types::fs::{FrameSequencer, FrameSequencerState}; use types::fs::{FrameSequencer, State as FrameSequencerState};
use types::{ChannelControl, SoundOutput}; use types::{ChannelControl, SoundOutput};
pub mod gen; pub mod gen;
@ -98,16 +98,16 @@ impl Apu {
self.sample_counter += SAMPLE_INCREMENT; self.sample_counter += SAMPLE_INCREMENT;
// Frame Sequencer (512Hz) // Frame Sequencer (512Hz)
if self.falling_edge(12, div) { if self.is_falling_edge(12, div) {
use FrameSequencerState::*; use FrameSequencerState::*;
match self.sequencer.state() { match self.sequencer.state() {
Length => self.handle_length(), Length => self.clock_length(),
LengthAndSweep => { LengthAndSweep => {
self.handle_length(); self.clock_length();
self.handle_sweep(); self.clock_sweep();
} }
Envelope => self.handle_envelope(), Envelope => self.clock_envelope(),
Nothing => {} Nothing => {}
} }
@ -116,16 +116,16 @@ impl Apu {
self.div_prev = Some(div); self.div_prev = Some(div);
self.ch1.clock(); self.ch1.tick();
self.ch2.clock(); self.ch2.tick();
self.ch3.clock(); self.ch3.tick();
self.ch4.clock(); self.ch4.tick();
if self.sample_counter >= SM83_CLOCK_SPEED { if self.sample_counter >= SM83_CLOCK_SPEED {
self.sample_counter %= SM83_CLOCK_SPEED; self.sample_counter %= SM83_CLOCK_SPEED;
if let Some(ref mut prod) = self.prod { if let Some(ref mut prod) = self.prod {
if prod.available_block() { if prod.available_blocking() {
// Sample the APU // Sample the APU
let ch1_amplitude = self.ch1.amplitude(); let ch1_amplitude = self.ch1.amplitude();
let ch1_left = self.ctrl.output.ch1_left() as u8 as f32 * ch1_amplitude; let ch1_left = self.ctrl.output.ch1_left() as u8 as f32 * ch1_amplitude;
@ -157,10 +157,6 @@ impl Apu {
} }
} }
pub fn set_producer(&mut self, prod: SampleProducer<f32>) {
self.prod = Some(prod);
}
/// 0xFF26 | NR52 - Sound On/Off /// 0xFF26 | NR52 - Sound On/Off
pub(crate) fn set_status(&mut self, byte: u8) { pub(crate) fn set_status(&mut self, byte: u8) {
self.ctrl.enabled = (byte >> 7) & 0x01 == 0x01; self.ctrl.enabled = (byte >> 7) & 0x01 == 0x01;
@ -183,6 +179,10 @@ impl Apu {
} }
} }
pub fn attach_producer(&mut self, prod: SampleProducer<f32>) {
self.prod = Some(prod);
}
fn reset(&mut self) { fn reset(&mut self) {
self.ch1.sweep = Default::default(); self.ch1.sweep = Default::default();
self.ch1.duty = Default::default(); self.ch1.duty = Default::default();
@ -216,7 +216,7 @@ impl Apu {
self.ch4.enabled = Default::default(); self.ch4.enabled = Default::default();
} }
fn clock_length(freq_hi: &FrequencyHigh, length_timer: &mut u16, enabled: &mut bool) { fn process_length(freq_hi: &FrequencyHigh, length_timer: &mut u16, enabled: &mut bool) {
if freq_hi.length_disable() && *length_timer > 0 { if freq_hi.length_disable() && *length_timer > 0 {
*length_timer -= 1; *length_timer -= 1;
@ -228,7 +228,7 @@ impl Apu {
} }
} }
fn clock_length_ch4(freq: &Ch4Frequency, length_timer: &mut u16, enabled: &mut bool) { fn ch4_process_length(freq: &Ch4Frequency, length_timer: &mut u16, enabled: &mut bool) {
if freq.length_disable() && *length_timer > 0 { if freq.length_disable() && *length_timer > 0 {
*length_timer -= 1; *length_timer -= 1;
@ -240,33 +240,33 @@ impl Apu {
} }
} }
fn handle_length(&mut self) { fn clock_length(&mut self) {
Self::clock_length( Self::process_length(
&self.ch1.freq_hi, &self.ch1.freq_hi,
&mut self.ch1.length_timer, &mut self.ch1.length_timer,
&mut self.ch1.enabled, &mut self.ch1.enabled,
); );
Self::clock_length( Self::process_length(
&self.ch2.freq_hi, &self.ch2.freq_hi,
&mut self.ch2.length_timer, &mut self.ch2.length_timer,
&mut self.ch2.enabled, &mut self.ch2.enabled,
); );
Self::clock_length( Self::process_length(
&self.ch3.freq_hi, &self.ch3.freq_hi,
&mut self.ch3.length_timer, &mut self.ch3.length_timer,
&mut self.ch3.enabled, &mut self.ch3.enabled,
); );
Self::clock_length_ch4( Self::ch4_process_length(
&self.ch4.freq, &self.ch4.freq,
&mut self.ch4.length_timer, &mut self.ch4.length_timer,
&mut self.ch4.enabled, &mut self.ch4.enabled,
); );
} }
fn handle_sweep(&mut self) { fn clock_sweep(&mut self) {
if self.ch1.sweep_timer != 0 { if self.ch1.sweep_timer != 0 {
self.ch1.sweep_timer -= 1; self.ch1.sweep_timer -= 1;
} }
@ -288,7 +288,7 @@ impl Apu {
} }
} }
fn clock_envelope(envelope: &VolumeEnvelope, period_timer: &mut u8, current_volume: &mut u8) { fn process_envelope(envelope: &VolumeEnvelope, period_timer: &mut u8, current_volume: &mut u8) {
use EnvelopeDirection::*; use EnvelopeDirection::*;
if envelope.period() != 0 { if envelope.period() != 0 {
@ -308,29 +308,29 @@ impl Apu {
} }
} }
fn handle_envelope(&mut self) { fn clock_envelope(&mut self) {
// Channels 1, 2 and 4 have Volume Envelopes // Channels 1, 2 and 4 have Volume Envelopes
Self::clock_envelope( Self::process_envelope(
&self.ch1.envelope, &self.ch1.envelope,
&mut self.ch1.period_timer, &mut self.ch1.period_timer,
&mut self.ch1.current_volume, &mut self.ch1.current_volume,
); );
Self::clock_envelope( Self::process_envelope(
&self.ch2.envelope, &self.ch2.envelope,
&mut self.ch2.period_timer, &mut self.ch2.period_timer,
&mut self.ch2.current_volume, &mut self.ch2.current_volume,
); );
Self::clock_envelope( Self::process_envelope(
&self.ch4.envelope, &self.ch4.envelope,
&mut self.ch4.period_timer, &mut self.ch4.period_timer,
&mut self.ch4.current_volume, &mut self.ch4.current_volume,
); );
} }
fn falling_edge(&self, bit: u8, div: u16) -> bool { fn is_falling_edge(&self, bit: u8, div: u16) -> bool {
match self.div_prev { match self.div_prev {
Some(p) => (p >> bit & 0x01) == 0x01 && (div >> bit & 0x01) == 0x00, Some(p) => (p >> bit & 0x01) == 0x01 && (div >> bit & 0x01) == 0x00,
None => false, None => false,
@ -416,26 +416,6 @@ pub(crate) struct Channel1 {
} }
impl Channel1 { impl Channel1 {
fn amplitude(&self) -> f32 {
if self.is_dac_enabled() && self.enabled {
let input = self.duty.wave_pattern().amplitude(self.duty_pos) * self.current_volume;
(input as f32 / 7.5) - 1.0
} else {
0.0
}
}
fn clock(&mut self) {
if self.freq_timer != 0 {
self.freq_timer -= 1;
}
if self.freq_timer == 0 {
self.freq_timer = (2048 - self.frequency()) * 4;
self.duty_pos = (self.duty_pos + 1) % 8;
}
}
/// 0xFF10 | NR10 - Channel 1 Sweep Register /// 0xFF10 | NR10 - Channel 1 Sweep Register
pub(crate) fn sweep(&self) -> u8 { pub(crate) fn sweep(&self) -> u8 {
u8::from(self.sweep) | 0x80 u8::from(self.sweep) | 0x80
@ -516,6 +496,26 @@ impl Channel1 {
} }
} }
fn tick(&mut self) {
if self.freq_timer != 0 {
self.freq_timer -= 1;
}
if self.freq_timer == 0 {
self.freq_timer = (2048 - self.frequency()) * 4;
self.duty_pos = (self.duty_pos + 1) % 8;
}
}
fn amplitude(&self) -> f32 {
if self.is_dac_enabled() && self.enabled {
let input = self.duty.wave_pattern().amplitude(self.duty_pos) * self.current_volume;
(input as f32 / 7.5) - 1.0
} else {
0.0
}
}
fn calc_sweep_freq(&mut self) -> u16 { fn calc_sweep_freq(&mut self) -> u16 {
use SweepDirection::*; use SweepDirection::*;
@ -574,26 +574,6 @@ pub(crate) struct Channel2 {
} }
impl Channel2 { impl Channel2 {
fn amplitude(&self) -> f32 {
if self.is_dac_enabled() && self.enabled {
let input = self.duty.wave_pattern().amplitude(self.duty_pos) * self.current_volume;
(input as f32 / 7.5) - 1.0
} else {
0.0
}
}
fn clock(&mut self) {
if self.freq_timer != 0 {
self.freq_timer -= 1;
}
if self.freq_timer == 0 {
self.freq_timer = (2048 - self.frequency()) * 4;
self.duty_pos = (self.duty_pos + 1) % 8;
}
}
/// 0xFF16 | NR21 - Channel 2 Sound length / Wave Pattern Duty /// 0xFF16 | NR21 - Channel 2 Sound length / Wave Pattern Duty
pub(crate) fn duty(&self) -> u8 { pub(crate) fn duty(&self) -> u8 {
u8::from(self.duty) | 0x3F u8::from(self.duty) | 0x3F
@ -649,6 +629,26 @@ impl Channel2 {
} }
} }
fn amplitude(&self) -> f32 {
if self.is_dac_enabled() && self.enabled {
let input = self.duty.wave_pattern().amplitude(self.duty_pos) * self.current_volume;
(input as f32 / 7.5) - 1.0
} else {
0.0
}
}
fn tick(&mut self) {
if self.freq_timer != 0 {
self.freq_timer -= 1;
}
if self.freq_timer == 0 {
self.freq_timer = (2048 - self.frequency()) * 4;
self.duty_pos = (self.duty_pos + 1) % 8;
}
}
fn frequency(&self) -> u16 { fn frequency(&self) -> u16 {
(self.freq_hi.freq_bits() as u16) << 8 | self.freq_lo as u16 (self.freq_hi.freq_bits() as u16) << 8 | self.freq_lo as u16
} }
@ -767,16 +767,7 @@ impl Channel3 {
} }
} }
fn amplitude(&self) -> f32 { fn tick(&mut self) {
if self.dac_enabled && self.enabled {
let input = self.read_sample(self.offset) >> self.volume.shift_count();
(input as f32 / 7.5) - 1.0
} else {
0.0
}
}
fn clock(&mut self) {
if self.freq_timer != 0 { if self.freq_timer != 0 {
self.freq_timer -= 1; self.freq_timer -= 1;
} }
@ -787,6 +778,15 @@ impl Channel3 {
} }
} }
fn amplitude(&self) -> f32 {
if self.dac_enabled && self.enabled {
let input = self.read_sample(self.offset) >> self.volume.shift_count();
(input as f32 / 7.5) - 1.0
} else {
0.0
}
}
fn read_sample(&self, index: u8) -> u8 { fn read_sample(&self, index: u8) -> u8 {
let i = (index / 2) as usize; let i = (index / 2) as usize;
@ -889,16 +889,7 @@ impl Channel4 {
} }
} }
fn amplitude(&self) -> f32 { fn tick(&mut self) {
if self.is_dac_enabled() && self.enabled {
let input = (!self.lf_shift & 0x01) as u8 * self.current_volume;
(input as f32 / 7.5) - 1.0
} else {
0.0
}
}
fn clock(&mut self) {
if self.freq_timer != 0 { if self.freq_timer != 0 {
self.freq_timer -= 1; self.freq_timer -= 1;
} }
@ -916,6 +907,15 @@ impl Channel4 {
} }
} }
fn amplitude(&self) -> f32 {
if self.is_dac_enabled() && self.enabled {
let input = (!self.lf_shift & 0x01) as u8 * self.current_volume;
(input as f32 / 7.5) - 1.0
} else {
0.0
}
}
fn is_dac_enabled(&self) -> bool { fn is_dac_enabled(&self) -> bool {
self.envelope.0 & 0xF8 != 0x00 self.envelope.0 & 0xF8 != 0x00
} }

View File

@ -48,7 +48,7 @@ impl<T> SampleProducer<T> {
self.inner.slots() > 2 self.inner.slots() > 2
} }
pub(crate) fn available_block(&self) -> bool { pub(crate) fn available_blocking(&self) -> bool {
loop { loop {
if self.inner.slots() > 2 { if self.inner.slots() > 2 {
break true; break true;

View File

@ -513,21 +513,21 @@ pub(super) mod fs {
#[derive(Debug)] #[derive(Debug)]
pub(crate) struct FrameSequencer { pub(crate) struct FrameSequencer {
step: u8, step: u8,
state: FrameSequencerState, state: State,
} }
impl Default for FrameSequencer { impl Default for FrameSequencer {
fn default() -> Self { fn default() -> Self {
Self { Self {
step: Default::default(), step: Default::default(),
state: FrameSequencerState::Length, state: State::Length,
} }
} }
} }
impl FrameSequencer { impl FrameSequencer {
pub(crate) fn next(&mut self) { pub(crate) fn next(&mut self) {
use FrameSequencerState::*; use State::*;
self.step = (self.step + 1) % 8; self.step = (self.step + 1) % 8;
self.state = match self.step { self.state = match self.step {
@ -539,18 +539,18 @@ pub(super) mod fs {
}; };
} }
pub(crate) fn state(&self) -> FrameSequencerState { pub(crate) fn state(&self) -> State {
self.state self.state
} }
pub(crate) fn reset(&mut self) { pub(crate) fn reset(&mut self) {
self.step = Default::default(); self.step = Default::default();
self.state = FrameSequencerState::Length; self.state = State::Length;
} }
} }
#[derive(Debug, Clone, Copy)] #[derive(Debug, Clone, Copy)]
pub(crate) enum FrameSequencerState { pub(crate) enum State {
Length, Length,
Nothing, Nothing,
LengthAndSweep, LengthAndSweep,

View File

@ -68,7 +68,7 @@ fn main() -> Result<()> {
let (_stream, stream_handle) = OutputStream::try_default().expect("Initialized Audio"); let (_stream, stream_handle) = OutputStream::try_default().expect("Initialized Audio");
let sink = Sink::try_new(&stream_handle)?; let sink = Sink::try_new(&stream_handle)?;
sink.append(cons); sink.append(cons);
game_boy.apu_mut().set_producer(prod); game_boy.apu_mut().attach_producer(prod);
std::thread::spawn(move || { std::thread::spawn(move || {
sink.sleep_until_end(); sink.sleep_until_end();