APU: reduce allocation by re-using old audio buffers

Only give reference to the user, as they don't need the actual Vec

mizu-core/src/apu.rs

@@ -17,13 +17,45 @@ use wave_channel::WaveChannel;
 /// The main buffer `all` is the summation of all of the other buffers/channels.
 /// If you want a combination of different channels, you can just add them together.
 /// All volume control is done before pushing to the buffers.
-pub struct AudioBuffers {
-    pub pulse1: Vec<f32>,
-    pub pulse2: Vec<f32>,
-    pub wave: Vec<f32>,
-    pub noise: Vec<f32>,
+pub struct AudioBuffers<'a> {
+    pulse1: &'a mut Vec<f32>,
+    pulse2: &'a mut Vec<f32>,
+    wave: &'a mut Vec<f32>,
+    noise: &'a mut Vec<f32>,
 
-    pub all: Vec<f32>,
+    all: &'a mut Vec<f32>,
+}
+
+impl AudioBuffers<'_> {
+    pub fn pulse1(&self) -> &[f32] {
+        self.pulse1
+    }
+
+    pub fn pulse2(&self) -> &[f32] {
+        self.pulse2
+    }
+
+    pub fn wave(&self) -> &[f32] {
+        self.wave
+    }
+
+    pub fn noise(&self) -> &[f32] {
+        self.noise
+    }
+
+    pub fn all(&self) -> &[f32] {
+        self.all
+    }
+}
+
+impl Drop for AudioBuffers<'_> {
+    fn drop(&mut self) {
+        self.pulse1.clear();
+        self.pulse2.clear();
+        self.wave.clear();
+        self.noise.clear();
+        self.all.clear();
+    }
 }
 
 bitflags! {
@@ -353,14 +385,14 @@ impl Apu {
         (p2 << 4) | p1
     }
 
-    pub fn get_buffers(&mut self) -> AudioBuffers {
+    pub fn get_buffers(&mut self) -> AudioBuffers<'_> {
         AudioBuffers {
-            pulse1: std::mem::take(&mut self.pulse1_buffers),
-            pulse2: std::mem::take(&mut self.pulse2_buffers),
-            wave: std::mem::take(&mut self.wave_buffers),
-            noise: std::mem::take(&mut self.noise_buffers),
+            pulse1: &mut self.pulse1_buffers,
+            pulse2: &mut self.pulse2_buffers,
+            wave: &mut self.wave_buffers,
+            noise: &mut self.noise_buffers,
 
-            all: std::mem::take(&mut self.buffer),
+            all: &mut self.buffer,
         }
     }
 

mizu-core/src/lib.rs

@@ -187,6 +187,8 @@ impl GameBoy {
     }
 
     /// Return the audio buffer of the APU at the current state.
+    ///
+    /// We use `&mut` as it will also reset the buffers after using them
     pub fn audio_buffers(&mut self) -> AudioBuffers {
         self.bus.audio_buffers()
     }

mizu-core/src/memory.rs

@@ -318,7 +318,7 @@ impl Bus {
         self.ppu.raw_screen_buffer()
     }
 
-    pub fn audio_buffers(&mut self) -> AudioBuffers {
+    pub fn audio_buffers(&mut self) -> AudioBuffers<'_> {
         self.apu.get_buffers()
     }
 

src/main.rs

@@ -179,17 +179,19 @@ impl GameboyFront {
 
             self.gameboy.clock_for_frame();
 
-            let buffers = self.gameboy.audio_buffers();
-
-            if let Some(audio_player) = self.audio_player.as_mut() {
-                let audio_buffer = match self.audio_output {
-                    AudioBufferOutput::All => buffers.all,
-                    AudioBufferOutput::Pulse1 => buffers.pulse1,
-                    AudioBufferOutput::Pulse2 => buffers.pulse2,
-                    AudioBufferOutput::Wave => buffers.wave,
-                    AudioBufferOutput::Noise => buffers.noise,
-                };
-                audio_player.queue(&audio_buffer);
+            {
+                let buffers = self.gameboy.audio_buffers();
+
+                if let Some(audio_player) = self.audio_player.as_mut() {
+                    let audio_buffer = match self.audio_output {
+                        AudioBufferOutput::All => buffers.all(),
+                        AudioBufferOutput::Pulse1 => buffers.pulse1(),
+                        AudioBufferOutput::Pulse2 => buffers.pulse2(),
+                        AudioBufferOutput::Wave => buffers.wave(),
+                        AudioBufferOutput::Noise => buffers.noise(),
+                    };
+                    audio_player.queue(audio_buffer);
+                }
             }
 
             self.window.clear(Color::BLACK);