feat: initial kind of working audio for CH 2

This a very work in progress situation that requires stability.
The most important part is the fact that it's possible for an external entity (SDL) to call an audio tick and get a volume.

frontends/sdl/src/audio.rs

+use boytacean::gb::{AudioProvider, GameBoy};
 use sdl2::{
-    audio::{AudioCallback, AudioDevice, AudioSpecDesired},
+    audio::{AudioCallback, AudioDevice, AudioSpec, AudioSpecDesired},
     AudioSubsystem, Sdl,
 };
+use std::sync::{Arc, Mutex};
 
 pub struct AudioWave {
-    phase_inc: f32,
+    /// Specification of the audion settings that have been put in place
+    /// for the playing of this audio wave.
+    spec: AudioSpec,
 
-    phase: f32,
+    /// The object that is going to be used as the provider of the audio
+    /// operation.
+    audio_provider: Arc<Mutex<Box<GameBoy>>>,
 
-    volume: f32,
-
-    /// The relative amount of time (as a percentage decimal) the low level
-    /// is going to be present during a period (cycle).
-    /// From [Wikipedia](https://en.wikipedia.org/wiki/Duty_cycle).
-    duty_cycle: f32,
+    /// The number of audio ticks that have passed since the beginning
+    /// of the audio playback, the value wraps around (avoids overflow).
+    ticks: usize,
 }
 
 impl AudioCallback for AudioWave {
     type Channel = f32;
 
     fn callback(&mut self, out: &mut [f32]) {
+        self.ticks = self.ticks.wrapping_add(out.len() as usize);
+
         for x in out.iter_mut() {
-            *x = if self.phase < (1.0 - self.duty_cycle) {
-                self.volume
-            } else {
-                -self.volume
-            };
-            self.phase = (self.phase + self.phase_inc) % 1.0;
+            *x = match self.audio_provider.lock() {
+                Ok(mut provider) => {
+                    let value = provider.tick_apu(self.spec.freq as u32) as f32 / 7.0;
+                    value
+                }
+                Err(_) => 0.0,
+            }
         }
     }
 }
@@ -37,7 +43,7 @@ pub struct Audio {
 }
 
 impl Audio {
-    pub fn new(sdl: &Sdl) -> Self {
+    pub fn new(sdl: &Sdl, audio_provider: Arc<Mutex<Box<GameBoy>>>) -> Self {
         let audio_subsystem = sdl.audio().unwrap();
 
         let desired_spec = AudioSpecDesired {
@@ -48,10 +54,9 @@ impl Audio {
 
         let device = audio_subsystem
             .open_playback(None, &desired_spec, |spec| AudioWave {
-                phase_inc: 440.0 / spec.freq as f32,
-                phase: 0.0,
-                volume: 0.25,
-                duty_cycle: 0.5,
+                spec: spec,
+                audio_provider: audio_provider,
+                ticks: 0,
             })
             .unwrap();
 

frontends/sdl/src/main.rs

@@ -6,13 +6,17 @@ pub mod graphics;
 
 use audio::Audio;
 use boytacean::{
-    gb::GameBoy,
+    gb::{AudioProvider, GameBoy},
     pad::PadKey,
     ppu::{PaletteInfo, PpuMode, DISPLAY_HEIGHT, DISPLAY_WIDTH},
 };
 use graphics::{surface_from_bytes, Graphics};
-use sdl2::{event::Event, keyboard::Keycode, pixels::PixelFormatEnum};
-use std::{cmp::max, time::SystemTime};
+use sdl2::{event::Event, keyboard::Keycode, pixels::PixelFormatEnum, Sdl};
+use std::{
+    cmp::max,
+    sync::{Arc, Mutex},
+    time::SystemTime,
+};
 
 /// The scale at which the screen is going to be drawn
 /// meaning the ratio between Game Boy resolution and
@@ -39,9 +43,9 @@ impl Default for Benchmark {
 }
 
 pub struct Emulator {
-    system: GameBoy,
-    graphics: Graphics,
-    audio: Audio,
+    system: Arc<Mutex<Box<GameBoy>>>,
+    graphics: Option<Graphics>,
+    audio: Option<Audio>,
     logic_frequency: u32,
     visual_frequency: f32,
     next_tick_time: f32,
@@ -51,20 +55,11 @@ pub struct Emulator {
 }
 
 impl Emulator {
-    pub fn new(system: GameBoy, screen_scale: f32) -> Self {
-        let sdl = sdl2::init().unwrap();
-        let graphics = Graphics::new(
-            &sdl,
-            TITLE,
-            DISPLAY_WIDTH as u32,
-            DISPLAY_HEIGHT as u32,
-            screen_scale,
-        );
-        let audio = Audio::new(&sdl);
+    pub fn new(system: Arc<Mutex<Box<GameBoy>>>) -> Self {
         Self {
             system,
-            graphics: graphics,
-            audio: audio,
+            graphics: None,
+            audio: None,
             logic_frequency: GameBoy::CPU_FREQ,
             visual_frequency: GameBoy::VISUAL_FREQ,
             next_tick_time: 0.0,
@@ -102,13 +97,40 @@ impl Emulator {
         }
     }
 
+    pub fn start(&mut self, screen_scale: f32, audio_provider: Arc<Mutex<Box<GameBoy>>>) {
+        let sdl = sdl2::init().unwrap();
+        self.start_graphics(&sdl, screen_scale);
+        self.start_audio(&sdl, audio_provider);
+    }
+
+    pub fn start_graphics(&mut self, sdl: &Sdl, screen_scale: f32) {
+        self.graphics = Some(Graphics::new(
+            &sdl,
+            TITLE,
+            DISPLAY_WIDTH as u32,
+            DISPLAY_HEIGHT as u32,
+            screen_scale,
+        ));
+    }
+
+    pub fn start_audio(&mut self, sdl: &Sdl, audio_provider: Arc<Mutex<Box<GameBoy>>>) {
+        self.audio = Some(Audio::new(sdl, audio_provider));
+    }
+
+    pub fn tick_audio(&mut self, freq: u32) -> u8 {
+        self.system.lock().unwrap().tick_apu(freq)
+    }
+
     pub fn load_rom(&mut self, path: &str) {
-        let rom = self.system.load_rom_file(path);
+        let mut system = self.system.lock().unwrap();
+        let rom = system.load_rom_file(path);
         println!(
             "========= Cartridge =========\n{}\n=============================",
             rom
         );
         self.graphics
+            .as_mut()
+            .unwrap()
             .window_mut()
             .set_title(format!("{} [{}]", TITLE, rom.title()).as_str())
             .unwrap();
@@ -123,7 +145,7 @@ impl Emulator {
         let initial = SystemTime::now();
 
         for _ in 0..count {
-            cycles += self.system.clock() as u32;
+            cycles += self.system.lock().unwrap().clock() as u32;
         }
 
         let delta = initial.elapsed().unwrap().as_millis() as f32 / 1000.0;
@@ -137,6 +159,8 @@ impl Emulator {
 
     pub fn toggle_palette(&mut self) {
         self.system
+            .lock()
+            .unwrap()
             .ppu()
             .set_palette_colors(self.palettes[self.palette_index].colors());
         self.palette_index = (self.palette_index + 1) % self.palettes.len();
@@ -146,15 +170,19 @@ impl Emulator {
         // updates the icon of the window to reflect the image
         // and style of the emulator
         let surface = surface_from_bytes(&data::ICON);
-        self.graphics.window_mut().set_icon(&surface);
+        self.graphics
+            .as_mut()
+            .unwrap()
+            .window_mut()
+            .set_icon(&surface);
 
         // creates an accelerated canvas to be used in the drawing
         // then clears it and presents it
-        self.graphics.canvas.present();
+        self.graphics.as_mut().unwrap().canvas.present();
 
         // creates a texture creator for the current canvas, required
         // for the creation of dynamic and static textures
-        let texture_creator = self.graphics.canvas.texture_creator();
+        let texture_creator = self.graphics.as_mut().unwrap().canvas.texture_creator();
 
         // creates the texture streaming that is going to be used
         // as the target for the pixel buffer
@@ -183,7 +211,7 @@ impl Emulator {
 
             // obtains an event from the SDL sub-system to be
             // processed under the current emulation context
-            while let Some(event) = self.graphics.event_pump.poll_event() {
+            while let Some(event) = self.graphics.as_mut().unwrap().event_pump.poll_event() {
                 match event {
                     Event::Quit { .. } => break 'main,
                     Event::KeyDown {
@@ -211,7 +239,7 @@ impl Emulator {
                         ..
                     } => {
                         if let Some(key) = key_to_pad(keycode) {
-                            self.system.key_press(key)
+                            self.system.lock().unwrap().key_press(key)
                         }
                     }
                     Event::KeyUp {
@@ -219,19 +247,19 @@ impl Emulator {
                         ..
                     } => {
                         if let Some(key) = key_to_pad(keycode) {
-                            self.system.key_lift(key)
+                            self.system.lock().unwrap().key_lift(key)
                         }
                     }
                     Event::DropFile { filename, .. } => {
-                        self.system.reset();
-                        self.system.load_boot_default();
+                        self.system.lock().unwrap().reset();
+                        self.system.lock().unwrap().load_boot_default();
                         self.load_rom(&filename);
                     }
                     _ => (),
                 }
             }
 
-            let current_time = self.graphics.timer_subsystem.ticks();
+            let current_time = self.graphics.as_mut().unwrap().timer_subsystem.ticks();
 
             if current_time >= self.next_tick_time_i {
                 // re-starts the counter cycles with the number of pending cycles
@@ -255,24 +283,29 @@ impl Emulator {
                         break;
                     }
 
-                    // runs the Game Boy clock, this operations should
-                    // include the advance of both the CPU and the PPU
-                    counter_cycles += self.system.clock() as u32;
-
-                    if self.system.ppu_mode() == PpuMode::VBlank
-                        && self.system.ppu_frame() != last_frame
                     {
-                        // obtains the frame buffer of the Game Boy PPU and uses it
-                        // to update the stream texture, that will latter be copied
-                        // to the canvas
-                        let frame_buffer = self.system.frame_buffer().as_ref();
-                        texture
-                            .update(None, frame_buffer, DISPLAY_WIDTH * 3)
-                            .unwrap();
-
-                        // obtains the index of the current PPU frame, this value
-                        // is going to be used to detect for new frame presence
-                        last_frame = self.system.ppu_frame();
+                        // obtains a locked reference to the system that is going to be
+                        // valid under the current block
+                        let mut system = self.system.lock().unwrap();
+
+                        // runs the Game Boy clock, this operations should
+                        // include the advance of both the CPU and the PPU
+                        counter_cycles += system.clock() as u32;
+
+                        if system.ppu_mode() == PpuMode::VBlank && system.ppu_frame() != last_frame
+                        {
+                            // obtains the frame buffer of the Game Boy PPU and uses it
+                            // to update the stream texture, that will latter be copied
+                            // to the canvas
+                            let frame_buffer = system.frame_buffer().as_ref();
+                            texture
+                                .update(None, frame_buffer, DISPLAY_WIDTH * 3)
+                                .unwrap();
+
+                            // obtains the index of the current PPU frame, this value
+                            // is going to be used to detect for new frame presence
+                            last_frame = system.ppu_frame();
+                        }
                     }
                 }
 
@@ -285,15 +318,20 @@ impl Emulator {
                     // clears the graphics canvas, making sure that no garbage
                     // pixel data remaining in the pixel buffer, not doing this would
                     // create visual glitches in OSs like Mac OS X
-                    self.graphics.canvas.clear();
+                    self.graphics.as_mut().unwrap().canvas.clear();
 
                     // copies the texture that was created for the frame (during
                     // the loop part of the tick) to the canvas
-                    self.graphics.canvas.copy(&texture, None, None).unwrap();
+                    self.graphics
+                        .as_mut()
+                        .unwrap()
+                        .canvas
+                        .copy(&texture, None, None)
+                        .unwrap();
 
                     // presents the canvas effectively updating the screen
                     // information presented to the user
-                    self.graphics.canvas.present();
+                    self.graphics.as_mut().unwrap().canvas.present();
                 }
 
                 // calculates the number of ticks that have elapsed since the
@@ -315,9 +353,13 @@ impl Emulator {
                 self.next_tick_time_i = self.next_tick_time.ceil() as u32;
             }
 
-            let current_time = self.graphics.timer_subsystem.ticks();
+            let current_time = self.graphics.as_mut().unwrap().timer_subsystem.ticks();
             let pending_time = self.next_tick_time_i.saturating_sub(current_time);
-            self.graphics.timer_subsystem.delay(pending_time);
+            self.graphics
+                .as_mut()
+                .unwrap()
+                .timer_subsystem
+                .delay(pending_time);
         }
     }
 }
@@ -325,12 +367,16 @@ impl Emulator {
 fn main() {
     // creates a new Game Boy instance and loads both the boot ROM
     // and the initial game ROM to "start the engine"
-    let mut game_boy = GameBoy::new();
-    game_boy.load_boot_default();
+    let game_boy = Arc::new(Mutex::new(Box::new(GameBoy::new())));
+    game_boy.try_lock().unwrap().as_mut().load_boot_default();
 
     // creates a new generic emulator structure loads the default
     // ROM file and starts running it
-    let mut emulator = Emulator::new(game_boy, SCREEN_SCALE);
+    let mut emulator = Emulator::new(game_boy);
+
+    let game_boy_ref = emulator.system.clone();
+
+    emulator.start(SCREEN_SCALE, game_boy_ref);
     emulator.load_rom("../../res/roms/pocket.gb");
     emulator.toggle_palette();
     emulator.run();

src/apu.rs

 use crate::warnln;
 
+const DUTY_TABLE: [[u8; 8]; 4] = [
+    [0, 0, 0, 0, 0, 0, 0, 1],
+    [1, 0, 0, 0, 0, 0, 0, 1],
+    [1, 0, 0, 0, 0, 1, 1, 1],
+    [0, 1, 1, 1, 1, 1, 1, 0],
+];
+
 pub struct Apu {
+    ch1_timer: u16,
+    ch1_sequence: u8,
+    ch1_output: u8,
     ch1_sweep_slope: u8,
     ch1_sweep_increase: bool,
     ch1_sweep_pace: u8,
@@ -13,6 +23,9 @@ pub struct Apu {
     ch1_sound_length: bool,
     ch1_enabled: bool,
 
+    ch2_timer: u16,
+    ch2_sequence: u8,
+    ch2_output: u8,
     ch2_length_timer: u8,
     ch2_wave_duty: u8,
     ch2_pace: u8,
@@ -26,6 +39,9 @@ pub struct Apu {
 impl Apu {
     pub fn new() -> Self {
         Self {
+            ch1_timer: 0,
+            ch1_sequence: 0,
+            ch1_output: 0,
             ch1_sweep_slope: 0x0,
             ch1_sweep_increase: false,
             ch1_sweep_pace: 0x0,
@@ -38,6 +54,9 @@ impl Apu {
             ch1_sound_length: false,
             ch1_enabled: false,
 
+            ch2_timer: 0,
+            ch2_sequence: 0,
+            ch2_output: 0,
             ch2_length_timer: 0x0,
             ch2_wave_duty: 0x0,
             ch2_pace: 0x0,
@@ -49,13 +68,10 @@ impl Apu {
         }
     }
 
-    pub fn clock(&mut self, cycles: u8) {
-        // @todo implement the clock and allow for the proper
-        // writing of the output buffer at a fixed frequency
-
-        
-
-
+    pub fn clock(&mut self, cycles: u8, freq: u32) {
+        for _ in 0..cycles {
+            self.cycle(freq);
+        }
     }
 
     pub fn read(&mut self, addr: u16) -> u8 {
@@ -127,4 +143,29 @@ impl Apu {
             _ => warnln!("Writing in unknown APU location 0x{:04x}", addr),
         }
     }
+
+    #[inline(always)]
+    pub fn cycle(&mut self, freq: u32) {
+        self.ch2_timer = self.ch2_timer.saturating_sub(1);
+        if self.ch2_timer == 0 {
+            let target_freq = 1048576.0 / (2048.0 - self.ch1_wave_length as f32);
+            self.ch2_timer = (freq as f32 / target_freq) as u16;
+            self.ch2_sequence = (self.ch2_sequence + 1) & 7;
+
+            if self.ch2_enabled {
+                self.ch2_output =
+                    if DUTY_TABLE[self.ch2_wave_duty as usize][self.ch2_sequence as usize] == 1 {
+                        self.ch2_volume
+                    } else {
+                        0
+                    };
+            } else {
+                self.ch2_output = 0;
+            }
+        }
+    }
+
+    pub fn output(&self) -> u8 {
+        self.ch2_output
+    }
 }

src/gb.rs

@@ -53,6 +53,10 @@ pub struct Registers {
     pub lyc: u8,
 }
 
+pub trait AudioProvider {
+    fn tick_apu(&mut self, freq: u32) -> u8;
+}
+
 #[cfg_attr(feature = "wasm", wasm_bindgen)]
 impl GameBoy {
     #[cfg_attr(feature = "wasm", wasm_bindgen(constructor))]
@@ -75,7 +79,6 @@ impl GameBoy {
     pub fn clock(&mut self) -> u8 {
         let cycles = self.cpu_clock();
         self.ppu_clock(cycles);
-        self.apu_clock(cycles);
         self.timer_clock(cycles);
         cycles
     }
@@ -96,8 +99,8 @@ impl GameBoy {
         self.ppu().clock(cycles)
     }
 
-    pub fn apu_clock(&mut self, cycles: u8) {
-        self.apu().clock(cycles)
+    pub fn apu_clock(&mut self, cycles: u8, freq: u32) {
+        self.apu().clock(cycles, freq)
     }
 
     pub fn timer_clock(&mut self, cycles: u8) {
@@ -372,6 +375,13 @@ pub fn hook_impl(info: &PanicInfo) {
     panic(message.as_str());
 }
 
+impl AudioProvider for GameBoy {
+    fn tick_apu(&mut self, freq: u32) -> u8 {
+        self.apu_clock(1, freq);
+        self.apu().output()
+    }
+}
+
 impl Default for GameBoy {
     fn default() -> Self {
         Self::new()