Support for Libretro

Related to #14 (closed)

frontends/libretro/src/lib.rs

 #![allow(clippy::uninlined_format_args)]
 
-use std::os::raw::{c_char, c_float, c_uint, c_void};
+use std::{
+    collections::HashMap,
+    ffi::CStr,
+    fmt::{self, Display, Formatter},
+    os::raw::{c_char, c_float, c_uint, c_void},
+    slice::from_raw_parts,
+};
 
 use boytacean::{
-    gb::GameBoy,
-    ppu::{DISPLAY_HEIGHT, DISPLAY_WIDTH, RGB1555_SIZE},
+    gb::{AudioProvider, GameBoy},
+    pad::PadKey,
+    ppu::{DISPLAY_HEIGHT, DISPLAY_WIDTH, FRAME_BUFFER_RGB155_SIZE, RGB1555_SIZE},
+    rom::Cartridge,
 };
 
 const RETRO_API_VERSION: u32 = 1;
@@ -19,7 +27,11 @@ const REGION_NTSC: u32 = 0;
 //const RETRO_MEMORY_SAVE_RAM: u32 = 0;
 //const RETRO_MEMORY_SYSTEM_RAM: u32 = 0;
 
+const RETRO_DEVICE_JOYPAD: usize = 1;
+
 static mut EMULATOR: Option<GameBoy> = None;
+static mut KEY_STATES: Option<HashMap<RetroJoypad, bool>> = None;
+static mut FRAME_BUFFER: [u8; FRAME_BUFFER_RGB155_SIZE] = [0x00; FRAME_BUFFER_RGB155_SIZE];
 
 static mut ENVIRONMENT_CALLBACK: Option<extern "C" fn(u32, *const c_void) -> bool> = None;
 static mut VIDEO_REFRESH_CALLBACK: Option<extern "C" fn(*const u8, c_uint, c_uint, usize)> = None;
@@ -30,6 +42,83 @@ static mut INPUT_STATE_CALLBACK: Option<
     extern "C" fn(port: u32, device: u32, index: u32, id: u32) -> i16,
 > = None;
 
+const RETRO_DEVICE_ID_JOYPAD_B: isize = 0;
+const RETRO_DEVICE_ID_JOYPAD_Y: isize = 1;
+const RETRO_DEVICE_ID_JOYPAD_SELECT: isize = 2;
+const RETRO_DEVICE_ID_JOYPAD_START: isize = 3;
+const RETRO_DEVICE_ID_JOYPAD_UP: isize = 4;
+const RETRO_DEVICE_ID_JOYPAD_DOWN: isize = 5;
+const RETRO_DEVICE_ID_JOYPAD_LEFT: isize = 6;
+const RETRO_DEVICE_ID_JOYPAD_RIGHT: isize = 7;
+const RETRO_DEVICE_ID_JOYPAD_A: isize = 8;
+const RETRO_DEVICE_ID_JOYPAD_X: isize = 9;
+const RETRO_DEVICE_ID_JOYPAD_L: isize = 10;
+const RETRO_DEVICE_ID_JOYPAD_R: isize = 11;
+const RETRO_DEVICE_ID_JOYPAD_L2: isize = 12;
+const RETRO_DEVICE_ID_JOYPAD_R2: isize = 13;
+const RETRO_DEVICE_ID_JOYPAD_L3: isize = 14;
+const RETRO_DEVICE_ID_JOYPAD_R3: isize = 15;
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+pub enum RetroJoypad {
+    RetroDeviceIdJoypadY = RETRO_DEVICE_ID_JOYPAD_B,
+    RetroDeviceIdJoypadB = RETRO_DEVICE_ID_JOYPAD_Y,
+    RetroDeviceIdJoypadSelect = RETRO_DEVICE_ID_JOYPAD_SELECT,
+    RetroDeviceIdJoypadStart = RETRO_DEVICE_ID_JOYPAD_START,
+    RetroDeviceIdJoypadUp = RETRO_DEVICE_ID_JOYPAD_UP,
+    RetroDeviceIdJoypadDown = RETRO_DEVICE_ID_JOYPAD_DOWN,
+    RetroDeviceIdJoypadLeft = RETRO_DEVICE_ID_JOYPAD_LEFT,
+    RetroDeviceIdJoypadRight = RETRO_DEVICE_ID_JOYPAD_RIGHT,
+    RetroDeviceIdJoypadA = RETRO_DEVICE_ID_JOYPAD_A,
+    RetroDeviceIdJoypadX = RETRO_DEVICE_ID_JOYPAD_X,
+    RetroDeviceIdJoypadL = RETRO_DEVICE_ID_JOYPAD_L,
+    RetroDeviceIdJoypadR = RETRO_DEVICE_ID_JOYPAD_R,
+    RetroDeviceIdJoypadL2 = RETRO_DEVICE_ID_JOYPAD_L2,
+    RetroDeviceIdJoypadR2 = RETRO_DEVICE_ID_JOYPAD_R2,
+    RetroDeviceIdJoypadL3 = RETRO_DEVICE_ID_JOYPAD_L3,
+    RetroDeviceIdJoypadR3 = RETRO_DEVICE_ID_JOYPAD_R3,
+}
+
+impl RetroJoypad {
+    pub fn description(&self) -> &'static str {
+        match self {
+            RetroJoypad::RetroDeviceIdJoypadY => "Y",
+            RetroJoypad::RetroDeviceIdJoypadB => "B",
+            RetroJoypad::RetroDeviceIdJoypadSelect => "Select",
+            RetroJoypad::RetroDeviceIdJoypadStart => "Start",
+            RetroJoypad::RetroDeviceIdJoypadUp => "Up",
+            RetroJoypad::RetroDeviceIdJoypadDown => "Down",
+            RetroJoypad::RetroDeviceIdJoypadLeft => "Left",
+            RetroJoypad::RetroDeviceIdJoypadRight => "Right",
+            RetroJoypad::RetroDeviceIdJoypadA => "A",
+            RetroJoypad::RetroDeviceIdJoypadX => "X",
+            RetroJoypad::RetroDeviceIdJoypadL => "L",
+            RetroJoypad::RetroDeviceIdJoypadR => "R",
+            RetroJoypad::RetroDeviceIdJoypadL2 => "L2",
+            RetroJoypad::RetroDeviceIdJoypadR2 => "R2",
+            RetroJoypad::RetroDeviceIdJoypadL3 => "L3",
+            RetroJoypad::RetroDeviceIdJoypadR3 => "R3",
+        }
+    }
+}
+
+impl Display for RetroJoypad {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.description())
+    }
+}
+
+const KEYS: [RetroJoypad; 8] = [
+    RetroJoypad::RetroDeviceIdJoypadUp,
+    RetroJoypad::RetroDeviceIdJoypadDown,
+    RetroJoypad::RetroDeviceIdJoypadLeft,
+    RetroJoypad::RetroDeviceIdJoypadRight,
+    RetroJoypad::RetroDeviceIdJoypadStart,
+    RetroJoypad::RetroDeviceIdJoypadSelect,
+    RetroJoypad::RetroDeviceIdJoypadA,
+    RetroJoypad::RetroDeviceIdJoypadB,
+];
+
 #[repr(C)]
 pub struct RetroGameInfo {
     pub path: *const c_char,
@@ -76,7 +165,7 @@ pub unsafe extern "C" fn retro_init() {
     println!("retro_init()");
     unsafe {
         EMULATOR = Some(GameBoy::new(None));
-        EMULATOR.as_mut().unwrap().load(true);
+        KEY_STATES = Some(HashMap::new());
     }
 }
 
@@ -88,6 +177,8 @@ pub extern "C" fn retro_deinit() {
 #[no_mangle]
 pub extern "C" fn retro_reset() {
     println!("retro_reset()");
+    let emulator = unsafe { EMULATOR.as_mut().unwrap() };
+    emulator.reload();
 }
 
 #[no_mangle]
@@ -120,8 +211,8 @@ pub unsafe extern "C" fn retro_get_system_av_info(info: *mut RetroSystemAvInfo)
     unsafe {
         (*info).geometry.base_width = DISPLAY_WIDTH as u32;
         (*info).geometry.base_height = DISPLAY_HEIGHT as u32;
-        (*info).geometry.max_width = DISPLAY_WIDTH as u32 * 32;
-        (*info).geometry.max_height = DISPLAY_HEIGHT as u32 * 32;
+        (*info).geometry.max_width = DISPLAY_WIDTH as u32 * 64;
+        (*info).geometry.max_height = DISPLAY_HEIGHT as u32 * 64;
         (*info).geometry.aspect_ratio = DISPLAY_WIDTH as f32 / DISPLAY_HEIGHT as f32;
         (*info).timing.fps = GameBoy::VISUAL_FREQ as f64;
         (*info).timing.sample_rate = EMULATOR.as_ref().unwrap().audio_sampling_rate() as f64;
@@ -200,9 +291,13 @@ pub extern "C" fn retro_set_controller_port_device() {
 #[no_mangle]
 pub extern "C" fn retro_run() {
     let emulator = unsafe { EMULATOR.as_mut().unwrap() };
+    let sample_batch_cb = unsafe { AUDIO_SAMPLE_BATCH_CALLBACK.as_ref().unwrap() };
+    let channels = emulator.audio_channels();
 
     let mut counter_cycles = 0_u32;
-    let cycle_limit = 4194304 / 60; //@TODO this is super tricky
+    let cycle_limit = (GameBoy::CPU_FREQ as f32 * emulator.multiplier() as f32
+        / GameBoy::VISUAL_FREQ)
+        .round() as u32;
 
     loop {
         // limits the number of ticks to the typical number
@@ -216,13 +311,51 @@ pub extern "C" fn retro_run() {
         // include the advance of both the CPU, PPU, APU
         // and any other frequency based component of the system
         counter_cycles += emulator.clock() as u32;
+
+        // obtains the audio buffer reference and queues it
+        // in a batch manner using the audio callback at the
+        // the end of the operation clears the buffer
+        let audio_buffer = emulator
+            .audio_buffer()
+            .iter()
+            .map(|v| *v as i16 * 256)
+            .collect::<Vec<i16>>();
+
+        sample_batch_cb(
+            audio_buffer.as_ptr(),
+            audio_buffer.len() / channels as usize,
+        );
+        emulator.clear_audio_buffer();
     }
 
-    let frame_buffer = emulator.frame_buffer_rgb1555();
+    unsafe {
+        INPUT_POLL_CALLBACK.as_ref().unwrap()();
+        let key_states = KEY_STATES.as_mut().unwrap();
+        for key in KEYS {
+            let key_pad = retro_key_to_pad(key).unwrap();
+            let current = INPUT_STATE_CALLBACK.as_ref().unwrap()(
+                0,
+                RETRO_DEVICE_JOYPAD as u32,
+                0,
+                key as u32,
+            ) > 0;
+            let previous = key_states.get(&key).unwrap_or(&false);
+            if current != *previous {
+                if current {
+                    emulator.key_press(key_pad);
+                } else {
+                    emulator.key_lift(key_pad);
+                }
+            }
+            key_states.insert(key, current);
+        }
+    }
 
+    let frame_buffer = emulator.frame_buffer_rgb1555();
     unsafe {
+        FRAME_BUFFER.copy_from_slice(&frame_buffer);
         VIDEO_REFRESH_CALLBACK.unwrap()(
-            frame_buffer.as_ptr(),
+            FRAME_BUFFER.as_ptr(),
             DISPLAY_WIDTH as u32,
             DISPLAY_HEIGHT as u32,
             DISPLAY_WIDTH * RGB1555_SIZE,
@@ -243,8 +376,15 @@ pub extern "C" fn retro_get_region() -> u32 {
 pub unsafe extern "C" fn retro_load_game(game: *const RetroGameInfo) -> bool {
     println!("retro_load_game()");
     unsafe {
-        let data_buffer = std::slice::from_raw_parts((*game).data as *const u8, (*game).size);
-        EMULATOR.as_mut().unwrap().load_rom(data_buffer, None);
+        let instance = EMULATOR.as_mut().unwrap();
+        let data_buffer = from_raw_parts((*game).data as *const u8, (*game).size);
+        let file_path_c = CStr::from_ptr((*game).path);
+        let file_path = file_path_c.to_str().unwrap();
+        let mode = Cartridge::from_file(file_path).gb_mode();
+        instance.set_mode(mode);
+        instance.reset();
+        instance.load(true);
+        instance.load_rom(data_buffer, None);
     }
     true
 }
@@ -290,3 +430,17 @@ pub extern "C" fn retro_cheat_reset() {
 pub extern "C" fn retro_cheat_set() {
     println!("retro_cheat_set()");
 }
+
+fn retro_key_to_pad(retro_key: RetroJoypad) -> Option<PadKey> {
+    match retro_key {
+        RetroJoypad::RetroDeviceIdJoypadUp => Some(PadKey::Up),
+        RetroJoypad::RetroDeviceIdJoypadDown => Some(PadKey::Down),
+        RetroJoypad::RetroDeviceIdJoypadLeft => Some(PadKey::Left),
+        RetroJoypad::RetroDeviceIdJoypadRight => Some(PadKey::Right),
+        RetroJoypad::RetroDeviceIdJoypadStart => Some(PadKey::Start),
+        RetroJoypad::RetroDeviceIdJoypadSelect => Some(PadKey::Select),
+        RetroJoypad::RetroDeviceIdJoypadA => Some(PadKey::A),
+        RetroJoypad::RetroDeviceIdJoypadB => Some(PadKey::B),
+        _ => None,
+    }
+}