You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

172 lines
7.4 KiB

use super::envelope::Envelope;
const DUTY_CYCLE_SEQUENCES: [[u8; 8]; 4] = [
[0, 1, 0, 0, 0, 0, 0, 0],
[0, 1, 1, 0, 0, 0, 0, 0],
[0, 1, 1, 1, 1, 0, 0, 0],
[1, 0, 0, 1, 1, 1, 1, 1],
];
#[derive(serde::Serialize, serde::Deserialize, Clone)]
pub struct Square {
pub sample: u16, // output value that gets sent to the mixer
pub enabled: bool,
constant_volume_flag: bool, // (0: use volume from envelope; 1: use constant volume)
first_channel: bool, // hack to detect timing difference in clock_sweep()
timer: u16,
timer_period: u16,
duty_cycle: [u8; 8], // "sequencer", set to one of the lines in DUTY_CYCLE_SEQUENCES
duty_counter: usize, // current index within the duty_cycle
pub length_counter: u8,
target_period: u16,
sweep_period: u16,
sweep_counter: u16,
shift_count: u8,
sweep_enabled: bool,
sweep_negate: bool,
sweep_reload: bool,
pub envelope: Envelope,
}
impl Square {
pub fn new(first_channel: bool) -> Self {
Square {
sample: 0,
enabled: false,
constant_volume_flag: false,
first_channel: first_channel,
timer: 0,
timer_period: 0,
duty_cycle: DUTY_CYCLE_SEQUENCES[0],
duty_counter: 0,
length_counter: 0,
target_period: 0,
sweep_period: 0,
sweep_counter: 0,
shift_count: 0,
sweep_enabled: false,
sweep_negate: false,
sweep_reload: false,
envelope: Envelope::new(),
}
}
pub fn clock(&mut self) {
// The sequencer is clocked by an 11-bit timer. Given the timer value t = HHHLLLLLLLL formed by timer high and timer low, this timer is updated every APU cycle
// (i.e., every second CPU cycle), and counts t, t-1, ..., 0, t, t-1, ..., clocking the waveform generator when it goes from 0 to t.
if self.timer == 0 {
self.timer = self.timer_period;
self.duty_counter = (self.duty_counter + 1) % 8;
} else {
self.timer -= 1;
}
// Update volume for this channel
// The mixer receives the current envelope volume except when
self.sample = if self.duty_cycle[self.duty_counter] == 0 // the sequencer output is zero, or
|| self.timer_period > 0x7FF // overflow from the sweep unit's adder is silencing the channel,
|| self.length_counter == 0 // the length counter is zero, or
|| self.timer_period < 8
// the timer has a value less than eight.
{
0
} else if self.constant_volume_flag {
self.envelope.period
} else {
self.envelope.decay_counter
};
}
pub fn clock_length_counter(&mut self) {
if !(self.length_counter == 0 || self.envelope.length_counter_halt) {
self.length_counter -= 1;
}
}
pub fn clock_sweep(&mut self) {
self.calculate_target_period();
// When the frame counter sends a half-frame clock (at 120 or 96 Hz), two things happen.
// If the divider's counter is zero, the sweep is enabled, and the sweep unit is not muting the channel: The pulse's period is adjusted.
if self.sweep_counter == 0
&& self.sweep_enabled
&& !(self.timer_period < 8 || self.target_period > 0x7FF)
{
self.timer_period = self.target_period;
}
// If the divider's counter is zero or the reload flag is true: The counter is set to P and the reload flag is cleared. Otherwise, the counter is decremented.
if self.sweep_counter == 0 || self.sweep_reload {
self.sweep_counter = self.sweep_period;
self.sweep_reload = false;
if self.sweep_enabled {
self.timer_period = self.target_period;
} // This fixes the DK walking sound. Why? Not reflected in documentation.
} else {
self.sweep_counter -= 1;
}
}
// Whenever the current period changes for any reason, whether by $400x writes or by sweep, the target period also changes.
pub fn calculate_target_period(&mut self) {
// The sweep unit continuously calculates each channel's target period in this way:
// A barrel shifter shifts the channel's 11-bit raw timer period right by the shift count, producing the change amount.
let change = self.timer_period >> self.shift_count;
// If the negate flag is true, the change amount is made negative.
// The target period is the sum of the current period and the change amount.
if self.sweep_negate {
self.target_period = self.timer_period - change;
// The two pulse channels have their adders' carry inputs wired differently,
// which produces different results when each channel's change amount is made negative:
// Pulse 1 adds the ones' complement (-c - 1). Making 20 negative produces a change amount of -21.
// Pulse 2 adds the two's complement (-c). Making 20 negative produces a change amount of -20.
if self.first_channel && self.target_period >= 1 {
self.target_period -= 1;
}
} else {
self.target_period = self.timer_period + change;
}
}
// $4000/$4004
pub fn write_duty(&mut self, value: u8) {
// The duty cycle is changed (see table below), but the sequencer's current position isn't affected.
self.duty_cycle = DUTY_CYCLE_SEQUENCES[(value >> 6) as usize];
self.envelope.length_counter_halt = value & (1 << 5) != 0;
self.constant_volume_flag = value & (1 << 4) != 0;
self.envelope.period = value as u16 & 0b1111;
}
// $4001/$4005
pub fn write_sweep(&mut self, value: u8) {
self.sweep_enabled = value >> 7 == 1;
self.sweep_period = ((value as u16 >> 4) & 0b111) + 1;
self.sweep_negate = value & 0b1000 != 0;
self.shift_count = value & 0b111;
self.sweep_reload = true;
}
// $4002/$4006
pub fn write_timer_low(&mut self, value: u8) {
self.timer_period &= 0b00000111_00000000; // mask off everything but high 3 bits of 11-bit timer
self.timer_period |= value as u16; // apply low 8 bits
self.calculate_target_period();
}
// $4003/$4007
pub fn write_timer_high(&mut self, value: u8) {
// LLLL.Lttt Pulse channel 1 length counter load and timer (write)
// TODO: thought the below meant that the length counter was only set if the channel was enabled, but apparently not as not having it fixes start game noise in DK.
// When the enabled bit is cleared (via $4015), the length counter is forced to 0 and cannot be changed until enabled is set again (the length counter's previous value is lost).
if self.enabled {
self.length_counter = super::LENGTH_COUNTER_TABLE[value as usize >> 3];
}
let timer_high = value as u16 & 0b0000_0111;
self.timer_period &= 0b11111000_11111111; // mask off high 3 bits of 11-bit timer
self.timer_period |= timer_high << 8; // apply high timer bits in their place
self.calculate_target_period();
// The sequencer is immediately restarted at the first value of the current sequence. The envelope is also restarted. The period divider is not reset.
self.duty_counter = 0;
self.envelope.start = true;
}
}