apu.rs

            if self.ch4_width_mode {
                self.ch4_lfsr &= 0xbf;
                self.ch4_lfsr |= if result { 0x40 } else { 0x00 };
            }

            self.ch4_output = if result { self.ch4_volume } else { 0 };
        } else {
            self.ch4_output = 0;
        }

        self.ch4_timer +=
            ((CH4_DIVISORS[self.ch4_divisor as usize] as u16) << self.ch4_clock_shift) as i32;
    }

    #[inline(always)]
    fn trigger_ch1(&mut self) {
        self.ch1_timer = ((2048 - self.ch1_wave_length) << 2) as i16;
        self.ch1_envelope_sequence = 0;
        self.ch1_sweep_sequence = 0;

        if self.ch1_length_timer == 0 {
            self.ch1_length_timer = 64;
            if self.ch1_length_enabled && self.sequencer_step % 2 == 1 {
                self.tick_length(Channel::Ch1);
            }
        }
    }

    #[inline(always)]
    fn trigger_ch2(&mut self) {
        self.ch2_timer = ((2048 - self.ch2_wave_length) << 2) as i16;
        self.ch2_envelope_sequence = 0;

        if self.ch2_length_timer == 0 {
            self.ch2_length_timer = 64;
            if self.ch2_length_enabled && self.sequencer_step % 2 == 1 {
                self.tick_length(Channel::Ch2);
            }
        }
    }

    #[inline(always)]
    fn trigger_ch3(&mut self) {
        self.ch3_timer = 3;
        self.ch3_position = 0;

        if self.ch3_length_timer == 0 {
            self.ch3_length_timer = 256;
            if self.ch3_length_enabled && self.sequencer_step % 2 == 1 {
                self.tick_length(Channel::Ch3);
            }
        }
    }

    #[inline(always)]
    fn trigger_ch4(&mut self) {
        self.ch4_timer =
            ((CH4_DIVISORS[self.ch4_divisor as usize] as u16) << self.ch4_clock_shift) as i32;
        self.ch4_lfsr = 0x7ff1;
        self.ch4_envelope_sequence = 0;

        if self.ch4_length_timer == 0 {
            self.ch4_length_timer = 64;
            if self.ch4_length_enabled && self.sequencer_step % 2 == 1 {
                self.tick_length(Channel::Ch4);
            }
        }
    }
}

impl Default for Apu {
    fn default() -> Self {
        Self::new(44100, 2, 1.0, GameBoy::CPU_FREQ)
    }
}

#[cfg(test)]
mod tests {
    use super::Apu;

    #[test]
    fn test_trigger_ch1() {
        let mut apu = Apu {
            ch1_wave_length: 1024,
            ..Default::default()
        };
        apu.trigger_ch1();

        assert_eq!(apu.ch1_timer, 4096);
        assert_eq!(apu.ch1_envelope_sequence, 0);
        assert_eq!(apu.ch1_sweep_sequence, 0);
    }

    #[test]
    fn test_trigger_ch2() {
        let mut apu = Apu {
            ch2_wave_length: 1024,
            ..Default::default()
        };
        apu.trigger_ch2();

        assert_eq!(apu.ch2_timer, 4096);
        assert_eq!(apu.ch2_envelope_sequence, 0);
    }

    #[test]
    fn test_trigger_ch3() {
        let mut apu = Apu {
            ch3_wave_length: 1024,
            ..Default::default()
        };
        apu.trigger_ch3();

        assert_eq!(apu.ch3_timer, 3);
        assert_eq!(apu.ch3_position, 0);
    }

    #[test]
    fn test_trigger_ch4() {
        let mut apu = Apu {
            ch4_divisor: 3,
            ch4_clock_shift: 2,
            ..Default::default()
        };
        apu.trigger_ch4();

        assert_eq!(apu.ch4_timer, 192);
        assert_eq!(apu.ch4_lfsr, 0x7ff1);
        assert_eq!(apu.ch4_envelope_sequence, 0);
    }
}