Implement SRAM (only saves on pause)

src/emulator/shrooms_vb_core.rs

@@ -62,6 +62,8 @@ extern "C" {
     fn vb_emulate(sim: *mut VB, cycles: *mut u32) -> c_int;
     #[link_name = "vbEmulateEx"]
     fn vb_emulate_ex(sims: *mut *mut VB, count: c_uint, cycles: *mut u32) -> c_int;
+    #[link_name = "vbGetCartRAM"]
+    fn vb_get_cart_ram(sim: *mut VB, size: *mut u32) -> *mut c_void;
     #[link_name = "vbGetCartROM"]
     fn vb_get_cart_rom(sim: *mut VB, size: *mut u32) -> *mut c_void;
     #[link_name = "vbGetPixels"]
@@ -87,6 +89,8 @@ extern "C" {
     fn vb_init(sim: *mut VB) -> *mut VB;
     #[link_name = "vbReset"]
     fn vb_reset(sim: *mut VB);
+    #[link_name = "vbSetCartRAM"]
+    fn vb_set_cart_ram(sim: *mut VB, sram: *mut c_void, size: u32) -> c_int;
     #[link_name = "vbSetCartROM"]
     fn vb_set_cart_rom(sim: *mut VB, rom: *mut c_void, size: u32) -> c_int;
     #[link_name = "vbSetFrameCallback"]
@@ -162,41 +166,58 @@ impl Sim {
         unsafe { vb_reset(self.sim) };
     }
 
-    pub fn load_rom(&mut self, rom: Vec<u8>) -> Result<()> {
-        self.unload_rom();
+    pub fn load_cart(&mut self, mut rom: Vec<u8>, mut sram: Vec<u8>) -> Result<()> {
+        self.unload_cart();
+
+        rom.shrink_to_fit();
+        sram.shrink_to_fit();
 
         let size = rom.len() as u32;
         let rom = Box::into_raw(rom.into_boxed_slice()).cast();
         let status = unsafe { vb_set_cart_rom(self.sim, rom, size) };
-        if status == 0 {
-            Ok(())
-        } else {
+        if status != 0 {
             let _: Vec<u8> =
                 unsafe { Vec::from_raw_parts(rom.cast(), size as usize, size as usize) };
-            Err(anyhow!("Invalid ROM size of {} bytes", size))
+            return Err(anyhow!("Invalid ROM size of {} bytes", size));
         }
+
+        let size = sram.len() as u32;
+        let sram = Box::into_raw(sram.into_boxed_slice()).cast();
+        let status = unsafe { vb_set_cart_ram(self.sim, sram, size) };
+        if status != 0 {
+            let _: Vec<u8> =
+                unsafe { Vec::from_raw_parts(sram.cast(), size as usize, size as usize) };
+            return Err(anyhow!("Invalid SRAM size of {} bytes", size));
+        }
+
+        Ok(())
     }
 
-    pub fn clone_rom(&self) -> Option<Vec<u8>> {
+    fn unload_cart(&mut self) {
         let mut size = 0;
         let rom = unsafe { vb_get_cart_rom(self.sim, &mut size) };
-        if rom.is_null() {
-            return None;
-        }
-        // SAFETY: rom definitely points to a valid array of `size` bytes
-        let slice: &[u8] = unsafe { slice::from_raw_parts(rom.cast(), size as usize) };
-        Some(slice.to_vec())
-    }
-
-    fn unload_rom(&mut self) -> Option<Vec<u8>> {
-        let mut size = 0;
-        let rom = unsafe { vb_get_cart_rom(self.sim, &mut size) };
-        if rom.is_null() {
-            return None;
-        }
         unsafe { vb_set_cart_rom(self.sim, ptr::null_mut(), 0) };
-        let vec = unsafe { Vec::from_raw_parts(rom.cast(), size as usize, size as usize) };
-        Some(vec)
+        if !rom.is_null() {
+            let _: Vec<u8> =
+                unsafe { Vec::from_raw_parts(rom.cast(), size as usize, size as usize) };
+        }
+
+        let sram = unsafe { vb_get_cart_ram(self.sim, &mut size) };
+        unsafe { vb_set_cart_ram(self.sim, ptr::null_mut(), 0) };
+        if !sram.is_null() {
+            let _: Vec<u8> =
+                unsafe { Vec::from_raw_parts(sram.cast(), size as usize, size as usize) };
+        }
+    }
+
+    pub fn read_sram(&mut self, buffer: &mut [u8]) {
+        let mut size = 0;
+        let sram = unsafe { vb_get_cart_ram(self.sim, &mut size) };
+        if sram.is_null() {
+            return;
+        }
+        let bytes = unsafe { slice::from_raw_parts(sram.cast(), size as usize) };
+        buffer.copy_from_slice(bytes);
     }
 
     pub fn link(&mut self, peer: &mut Sim) {