Add high-pass filter for sound

Author: LukasKalbertodt

core/src/env.rs

@@ -14,5 +14,9 @@ pub trait Peripherals {
     /// way to allow fast access.
     fn get_pressed_keys(&self) -> Keys;
 
-    fn offer_sound_sample(&mut self, f: impl FnOnce() -> f32);
+    /// Is called regularly by the emulator (without fixed frequency, but on
+    /// average above 100Mhz) to let the peripherals request an audio sample. It
+    /// can call `f` at its own sample rate. It has to provide the sample rate
+    /// to the function for certain audio filters within the emulator.
+    fn offer_sound_sample(&mut self, f: impl FnOnce(f32) -> f32);
 }

core/src/lib.rs

@@ -96,7 +96,9 @@ impl Emulator {
                 self.machine.dma_step();
 
                 self.machine.sound_controller.step();
-                peripherals.offer_sound_sample(|| self.machine.sound_controller.output());
+                peripherals.offer_sound_sample(|sample_rate| {
+                    self.machine.sound_controller.output(sample_rate)
+                });
             }
 
             // Handle input

core/src/machine/input.rs

@@ -161,7 +161,7 @@ mod test {
         }
 
         fn write_lcd_line(&mut self, _: u8, _: &[PixelColor; SCREEN_WIDTH]) {}
-        fn offer_sound_sample(&mut self, _: impl FnOnce() -> f32) {}
+        fn offer_sound_sample(&mut self, _: impl FnOnce(f32) -> f32) {}
     }
 
     #[test]

core/src/machine/sound.rs

@@ -34,6 +34,10 @@ pub(crate) struct SoundController {
     /// Hz). As the slowest clock we want to generate is 64Hz, this counter
     /// wraps at `1_048_576 / 64 = 16_384`.
     frame_sequencer: u32,
+
+    // For highpass filter.
+    last_filtered_out: f32,
+    last_unfiltered_out: f32,
 }
 
 impl SoundController {
@@ -55,6 +59,9 @@ impl SoundController {
             square2: SquareChannel2::new(),
             wave: WaveChannel::new(),
             frame_sequencer: 0,
+
+            last_filtered_out: 0.0,
+            last_unfiltered_out: 0.0,
         }
     }
 
@@ -151,9 +158,23 @@ impl SoundController {
         self.wave.step();
     }
 
-    pub(crate) fn output(&self) -> f32 {
-        // (self.counter as f32 * 2.0 * 3.1415926 / 2u16.pow(13) as f32).sin()
-        self.wave.output() + self.square2.output()
+    pub(crate) fn output(&mut self, sample_rate: f32) -> f32 {
+        // The high-pass filter needs a parameter alpha which determines how
+        // quickly the existing signal decays. This can be calculated from the
+        // sample rate and the cutoff frequency. The Gameboy's cutoff frequency
+        // is 60Hz according to https://github.com/bwhitman/pushpin/blob/master/src/gbsound.txt
+        //
+        // Resulting alpha for 60Hz is 0.9915, for 20Hz it's 0.9972.
+        const CUTOFF: f32 = 60.0;
+        let alpha = 1.0 / (2.0 * std::f32::consts::PI * 1.0 / sample_rate * CUTOFF + 1.0);
+
+        // We use a simple highpass filter to mainly remove the DC component.
+        let unfiltered_out = self.wave.output() + self.square2.output();
+        self.last_filtered_out = alpha * self.last_filtered_out
+            + alpha * (unfiltered_out - self.last_unfiltered_out);
+        self.last_unfiltered_out = unfiltered_out;
+
+        self.last_filtered_out
     }
 }
 

desktop/src/env.rs

@@ -39,6 +39,7 @@ pub(crate) struct Env {
     audio_buffer: AudioBuffer,
     cycles_till_next_sample: f64,
     _stream: cpal::Stream,
+    sample_rate: f32,
 
     /// A fixed (set in `new`) value determining how many emulation cycles pass
     /// per host audio sample (without turbo mode).
@@ -71,6 +72,7 @@ impl Env {
             pixels,
             audio_buffer,
             _stream: stream,
+            sample_rate: stream_config.sample_rate.0 as f32,
             cycles_till_next_sample,
             cycles_per_host_sample,
         })
@@ -108,9 +110,9 @@ impl Peripherals for Env {
         }
     }
 
-    fn offer_sound_sample(&mut self, f: impl FnOnce() -> f32) {
+    fn offer_sound_sample(&mut self, f: impl FnOnce(f32) -> f32) {
         if self.cycles_till_next_sample <= 0.0 {
-            self.audio_buffer.lock().unwrap().push(f());
+            self.audio_buffer.lock().unwrap().push(f(self.sample_rate));
             self.cycles_till_next_sample += self.cycles_per_host_sample;
         }
         self.cycles_till_next_sample -= 1.0;