update cargo packages

* transferpak support

* more

* more

Cargo.lock

@@ -485,9 +485,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.13"
+version = "1.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7777341816418c02e033934a09f20dc0ccaf65a5201ef8a450ae0105a573fda"
+checksum = "0c3d1b2e905a3a7b00a6141adb0e4c0bb941d11caf55349d863942a1cc44e3c9"
 dependencies = [
  "jobserver",
  "libc",
@@ -567,9 +567,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.28"
+version = "4.5.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e77c3243bd94243c03672cb5154667347c457ca271254724f9f393aee1c05ff"
+checksum = "8acebd8ad879283633b343856142139f2da2317c96b05b4dd6181c61e2480184"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -577,9 +577,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.27"
+version = "4.5.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b26884eb4b57140e4d2d93652abfa49498b938b3c9179f9fc487b0acc3edad7"
+checksum = "f6ba32cbda51c7e1dfd49acc1457ba1a7dec5b64fe360e828acb13ca8dc9c2f9"
 dependencies = [
  "anstream",
  "anstyle",
@@ -1107,9 +1107,9 @@ dependencies = [
 
 [[package]]
 name = "equivalent"
-version = "1.0.1"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
 name = "errno"
@@ -1482,7 +1482,7 @@ dependencies = [
 
 [[package]]
 name = "gopher64"
-version = "1.0.5"
+version = "1.0.7"
 dependencies = [
  "bindgen",
  "cc",
@@ -2221,9 +2221,9 @@ checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
 [[package]]
 name = "miniz_oxide"
-version = "0.8.3"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8402cab7aefae129c6977bb0ff1b8fd9a04eb5b51efc50a70bea51cda0c7924"
+checksum = "b3b1c9bd4fe1f0f8b387f6eb9eb3b4a1aa26185e5750efb9140301703f62cd1b"
 dependencies = [
  "adler2",
  "simd-adler32",
@@ -2922,9 +2922,9 @@ dependencies = [
 
 [[package]]
 name = "quinn-udp"
-version = "0.5.9"
+version = "0.5.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c40286217b4ba3a71d644d752e6a0b71f13f1b6a2c5311acfcbe0c2418ed904"
+checksum = "e46f3055866785f6b92bc6164b76be02ca8f2eb4b002c0354b28cf4c119e5944"
 dependencies = [
  "cfg_aliases",
  "libc",
@@ -3123,15 +3123,14 @@ dependencies = [
 
 [[package]]
 name = "ring"
-version = "0.17.8"
+version = "0.17.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d"
+checksum = "e75ec5e92c4d8aede845126adc388046234541629e76029599ed35a003c7ed24"
 dependencies = [
  "cc",
  "cfg-if",
  "getrandom 0.2.15",
  "libc",
- "spin",
  "untrusted",
  "windows-sys 0.52.0",
 ]
@@ -3184,9 +3183,9 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.22"
+version = "0.23.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fb9263ab4eb695e42321db096e3b8fbd715a59b154d5c88d82db2175b681ba7"
+checksum = "47796c98c480fce5406ef69d1c76378375492c3b0a0de587be0c1d9feb12f395"
 dependencies = [
  "once_cell",
  "ring",
@@ -3435,9 +3434,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.13.2"
+version = "1.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
+checksum = "7fcf8323ef1faaee30a44a340193b1ac6814fd9b7b4e88e9d4519a3e4abe1cfd"
 
 [[package]]
 name = "smithay-client-toolkit"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "gopher64"
-version = "1.0.5"
+version = "1.0.7"
 edition = "2021"
 rust-version = "1.82"
 
@@ -29,7 +29,7 @@ tungstenite = "0.26"
 socket2 = "0.5"
 fatfs = "0.3"
 postcard = { version = "1.1", features = ["use-std"] }
-clap = { version = "4.4", features = ["derive"] }
+clap = { version = "4.5", features = ["derive"] }
 reqwest = { version = "0.12", default-features = false, features = ["http2","rustls-tls","charset","json"] }
 
 [build-dependencies]

parallel-rdp/interface.cpp

@@ -141,10 +141,17 @@ bool sdl_event_filter(void *userdata, SDL_Event *event)
 	{
 		wsi_platform->do_resize();
 	}
-	else if (event->type == SDL_EVENT_KEY_DOWN)
+	else if (event->type == SDL_EVENT_KEY_UP)
 	{
 		switch (event->key.scancode)
 		{
+		case SDL_SCANCODE_RETURN:
+			if (event->key.mod & SDL_KMOD_ALT)
+			{
+				fullscreen = !fullscreen;
+				SDL_SetWindowFullscreen(window, fullscreen);
+			}
+			break;
 		case SDL_SCANCODE_ESCAPE:
 			if (fullscreen)
 				callback.emu_running = false;
@@ -245,8 +252,8 @@ void rdp_close()
 
 static void calculate_viewport(float *x, float *y, float *width, float *height)
 {
-	const int32_t display_width = 320;
-	const int32_t display_height = 240;
+	const int32_t display_width = gfx_info.PAL ? 384 : 320;
+	const int32_t display_height = gfx_info.PAL ? 288 : 240;
 
 	int w, h;
 	SDL_GetWindowSize(window, &w, &h);

parallel-rdp/interface.hpp

@@ -16,6 +16,7 @@ extern "C"
 		uint32_t *DPC_START_REG;
 		uint32_t *DPC_END_REG;
 		uint32_t *DPC_STATUS_REG;
+		bool PAL;
 	} GFX_INFO;
 
 	typedef struct

parallel-rdp/wsi_platform.cpp

@@ -61,7 +61,6 @@ void SDL_WSIPlatform::poll_input()
 
 void SDL_WSIPlatform::poll_input_async(Granite::InputTrackerHandler *handler)
 {
-	SDL_PumpEvents();
 }
 
 void SDL_WSIPlatform::set_window(SDL_Window *_window)

src/device.rs

@@ -66,7 +66,6 @@ pub fn run_game(rom_contents: Vec<u8>, device: &mut Device) {
 
     ui::storage::init(&mut device.ui, &device.cart.rom);
     ui::storage::load_saves(&mut device.ui, &mut device.netplay);
-    cart::rom::load_rom_save(device);
 
     cpu::run(device);
 
@@ -358,6 +357,7 @@ impl Device {
                         pc: 0,
                     },
                     broken: false,
+                    running: false,
                     halted: false,
                     sync_point: false,
                     cycle_counter: 0,
@@ -437,6 +437,12 @@ impl Device {
                 count_per_scanline: 0,
                 limiter: None,
                 vi_counter: 0,
+                last_origin: 0,
+                internal_frame_counter: 0,
+                min_wait_time: std::time::Duration::from_secs(1),
+                frame_time: 0.0,
+                limit_freq: 2,
+                limit_freq_check: std::time::Instant::now(),
             },
             vru_window: controller::vru::VruWindow {
                 window_notifier: None,

src/device/cart/rom.rs

@@ -3,17 +3,29 @@ use sha2::{Digest, Sha256};
 
 const CART_MASK: usize = 0xFFFFFFF;
 
+fn read_cart_word(device: &mut device::Device, address: usize) -> u32 {
+    let mut data: [u8; 4] = device.cart.rom[address..address + 4].try_into().unwrap();
+    for i in 0..4 {
+        if device
+            .ui
+            .saves
+            .romsave
+            .0
+            .contains_key(&(address as u32 + i))
+        {
+            data[i as usize] = device.ui.saves.romsave.0[&(address as u32 + i)];
+        }
+    }
+    u32::from_be_bytes(data)
+}
+
 pub fn read_mem_fast(
     device: &mut device::Device,
     address: u64,
     _access_size: device::memory::AccessSize,
 ) -> u32 {
     let masked_address = address as usize & CART_MASK;
-    u32::from_be_bytes(
-        device.cart.rom[masked_address..masked_address + 4]
-            .try_into()
-            .unwrap(),
-    )
+    read_cart_word(device, masked_address)
 }
 
 pub fn read_mem(
@@ -29,29 +41,22 @@ pub fn read_mem(
         device.cart.latch
     } else {
         let masked_address = address as usize & CART_MASK;
-        u32::from_be_bytes(
-            device.cart.rom[masked_address..masked_address + 4]
-                .try_into()
-                .unwrap(),
-        )
+        read_cart_word(device, masked_address)
     }
 }
 
 pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u32) {
     if device.cart.sc64.cfg[device::cart::sc64::SC64_ROM_WRITE_ENABLE as usize] != 0 {
         let masked_address = address as usize & CART_MASK;
-        let mut data = u32::from_be_bytes(
-            device.cart.rom[masked_address..masked_address + 4]
-                .try_into()
-                .unwrap(),
-        );
+        let mut data = read_cart_word(device, masked_address);
         device::memory::masked_write_32(&mut data, value, mask);
-        device.cart.rom[masked_address..masked_address + 4].copy_from_slice(&data.to_be_bytes());
-        for i in 0..4 {
-            device.ui.saves.romsave.0.insert(
-                (masked_address + i) as u32,
-                device.cart.rom[masked_address + i],
-            );
+        for (i, item) in data.to_be_bytes().iter().enumerate() {
+            device
+                .ui
+                .saves
+                .romsave
+                .0
+                .insert((masked_address + i) as u32, *item);
         }
         device.ui.saves.romsave.1 = true;
     }
@@ -80,15 +85,10 @@ pub fn dma_read(
 
         for i in 0..length {
             if cart_addr + i < device.cart.rom.len() as u32 {
-                device.cart.rom[(cart_addr + i) as usize] =
-                    device.rdram.mem[(dram_addr + i) as usize ^ device.byte_swap];
-
-                device
-                    .ui
-                    .saves
-                    .romsave
-                    .0
-                    .insert(cart_addr + i, device.cart.rom[(cart_addr + i) as usize]);
+                device.ui.saves.romsave.0.insert(
+                    cart_addr + i,
+                    device.rdram.mem[(dram_addr + i) as usize ^ device.byte_swap],
+                );
 
                 device.ui.saves.romsave.1 = true;
             }
@@ -110,7 +110,11 @@ pub fn dma_write(
     let mut i = dram_addr;
     let mut j = cart_addr;
     while i < dram_addr + length && j < device.cart.rom.len() as u32 {
-        device.rdram.mem[i as usize ^ device.byte_swap] = device.cart.rom[j as usize];
+        if device.ui.saves.romsave.0.contains_key(&j) {
+            device.rdram.mem[i as usize ^ device.byte_swap] = device.ui.saves.romsave.0[&j];
+        } else {
+            device.rdram.mem[i as usize ^ device.byte_swap] = device.cart.rom[j as usize];
+        }
         i += 1;
         j += 1;
     }
@@ -135,15 +139,6 @@ pub fn init(device: &mut device::Device, rom_file: Vec<u8>) {
     }
 }
 
-pub fn load_rom_save(device: &mut device::Device) {
-    if device.ui.saves.romsave.0.is_empty() {
-        return;
-    }
-    for (key, value) in device.ui.saves.romsave.0.iter() {
-        device.cart.rom[*key as usize] = *value
-    }
-}
-
 fn set_system_region(device: &mut device::Device, country: u8) {
     let pal_codes: [u8; 8] = [b'D', b'F', b'I', b'P', b'S', b'U', b'X', b'Y'];
     for i in pal_codes {

src/device/controller.rs

@@ -2,6 +2,7 @@ use crate::{device, netplay, savestates, ui};
 
 pub mod mempak;
 pub mod rumble;
+pub mod transferpak;
 pub mod vru;
 
 pub const JCMD_STATUS: u8 = 0x00;
@@ -24,6 +25,7 @@ pub enum PakType {
     None = 0,
     MemPak = 1,
     RumblePak = 2,
+    TransferPak = 3,
 }
 
 #[derive(Copy, Clone, serde::Serialize, serde::Deserialize)]
@@ -159,29 +161,41 @@ fn data_crc(device: &device::Device, data_offset: usize, size: usize) -> u8 {
 pub fn pak_switch_event(device: &mut device::Device) {
     for (i, channel) in device.pif.channels.iter_mut().enumerate() {
         if channel.change_pak != PakType::None {
-            if channel.change_pak == PakType::RumblePak {
-                if device.netplay.is_none() {
-                    device::ui::input::set_rumble(&mut device.ui, i, 0);
-                } else if device.netplay.as_ref().unwrap().player_number as usize == i {
-                    device::ui::input::set_rumble(&mut device.ui, 0, 0);
-                }
+            //stop rumble if it is on
+            if device.netplay.is_none() {
+                device::ui::input::set_rumble(&mut device.ui, i, 0);
+            } else if device.netplay.as_ref().unwrap().player_number as usize == i {
+                device::ui::input::set_rumble(&mut device.ui, 0, 0);
+            }
 
-                let handler = device::controller::PakHandler {
+            let new_pak_type = match channel.change_pak {
+                PakType::MemPak => PakType::RumblePak,
+                PakType::RumblePak => PakType::MemPak,
+                _ => {
+                    panic!("Invalid pak type");
+                }
+            };
+
+            if new_pak_type == PakType::MemPak {
+                channel.pak_handler = Some(device::controller::PakHandler {
                     read: device::controller::mempak::read,
                     write: device::controller::mempak::write,
-                    pak_type: device::controller::PakType::MemPak,
-                };
-                channel.pak_handler = Some(handler);
-                ui::audio::play_pak_switch(&mut device.ui, PakType::MemPak);
-            } else if channel.change_pak == PakType::MemPak {
-                let handler = device::controller::PakHandler {
+                    pak_type: new_pak_type,
+                });
+            } else if new_pak_type == PakType::RumblePak {
+                channel.pak_handler = Some(device::controller::PakHandler {
                     read: device::controller::rumble::read,
                     write: device::controller::rumble::write,
-                    pak_type: device::controller::PakType::RumblePak,
-                };
-                channel.pak_handler = Some(handler);
-                ui::audio::play_pak_switch(&mut device.ui, PakType::RumblePak);
+                    pak_type: new_pak_type,
+                });
+            } else if new_pak_type == PakType::TransferPak {
+                channel.pak_handler = Some(device::controller::PakHandler {
+                    read: device::controller::transferpak::read,
+                    write: device::controller::transferpak::write,
+                    pak_type: new_pak_type,
+                });
             }
+            ui::audio::play_pak_switch(&mut device.ui, new_pak_type);
             channel.change_pak = PakType::None;
         }
     }

src/device/controller/transferpak.rs

@@ -0,0 +1,19 @@
+use crate::device;
+
+pub fn read(
+    _device: &mut device::Device,
+    _channel: usize,
+    _address: u16,
+    _data: usize,
+    _size: usize,
+) {
+}
+
+pub fn write(
+    _device: &mut device::Device,
+    _channel: usize,
+    _address: u16,
+    _data: usize,
+    _size: usize,
+) {
+}

src/device/is_viewer.rs

@@ -21,9 +21,10 @@ pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u3
         let length = (value & mask) as u64;
         let data = std::str::from_utf8(
             &device.cart.is_viewer_buffer[0x20_usize..(0x20 + length) as usize],
-        )
-        .unwrap();
-        print!("{}", data);
+        );
+        if data.is_ok() {
+            print!("{}", data.unwrap());
+        }
     } else {
         let mut data = u32::from_be_bytes(
             device.cart.is_viewer_buffer[masked_address..masked_address + 4]

src/device/rdp.rs

@@ -53,7 +53,9 @@ pub fn read_regs_dpc(
     address: u64,
     _access_size: device::memory::AccessSize,
 ) -> u32 {
-    device::cop0::add_cycles(device, 20);
+    if !device.rsp.cpu.running {
+        device::cop0::add_cycles(device, 20);
+    }
     let reg = (address & 0xFFFF) >> 2;
     match reg as u32 {
         DPC_STATUS_REG => {
@@ -116,6 +118,7 @@ fn run_rdp(device: &mut device::Device) {
     let timer = ui::video::process_rdp_list();
     device.rdp.regs_dpc[DPC_STATUS_REG as usize] |=
         DPC_STATUS_START_GCLK | DPC_STATUS_PIPE_BUSY | DPC_STATUS_CMD_BUSY;
+    device.rdp.regs_dpc[DPC_PIPEBUSY_REG as usize] = 0xFFFFFF;
 
     if timer != 0 {
         if device.save_state {
@@ -203,6 +206,7 @@ fn update_dpc_status(device: &mut device::Device, w: u32) {
 pub fn init(device: &mut device::Device) {
     device.rdp.regs_dpc[DPC_STATUS_REG as usize] |=
         DPC_STATUS_START_GCLK | DPC_STATUS_PIPE_BUSY | DPC_STATUS_CBUF_READY;
+    device.rdp.regs_dpc[DPC_PIPEBUSY_REG as usize] = 0xFFFFFF;
 }
 
 pub fn rdp_interrupt_event(device: &mut device::Device) {

src/device/rsp_cpu.rs

@@ -34,6 +34,7 @@ pub struct Cpu {
     pub pipeline_full: bool,
     pub branch_state: BranchState,
     pub broken: bool,
+    pub running: bool,
     pub halted: bool,
     pub sync_point: bool,
     pub cycle_counter: u64,
@@ -125,6 +126,7 @@ pub fn in_delay_slot_taken(device: &device::Device) -> bool {
 pub fn run(device: &mut device::Device) -> u64 {
     device.rsp.cpu.broken = false;
     device.rsp.cpu.cycle_counter = 0;
+    device.rsp.cpu.running = true;
     while !device.rsp.cpu.sync_point {
         device.rsp.cpu.instruction_type = InstructionType::Su;
         device.rsp.cpu.gpr[0] = 0; // gpr 0 is read only
@@ -186,6 +188,7 @@ pub fn run(device: &mut device::Device) -> u64 {
             }
         }
     }
+    device.rsp.cpu.running = false;
     (device.rsp.cpu.cycle_counter as f64 * 1.5) as u64 // converting RCP clock to CPU clock
 }
 
@@ -288,70 +291,70 @@ pub fn map_instructions(device: &mut device::Device) {
     ];
 
     device.rsp.cpu.special_instrs = [
-        device::rsp_su_instructions::sll,      // 0
-        device::rsp_su_instructions::reserved, // 1
-        device::rsp_su_instructions::srl,      // 2
-        device::rsp_su_instructions::sra,      // 3
-        device::rsp_su_instructions::sllv,     // 4
-        device::rsp_su_instructions::reserved, // 5
-        device::rsp_su_instructions::srlv,     // 6
-        device::rsp_su_instructions::srav,     // 7
-        device::rsp_su_instructions::jr,       // 8
-        device::rsp_su_instructions::jalr,     // 9
-        device::rsp_su_instructions::reserved, // 10
-        device::rsp_su_instructions::reserved, // 11
-        device::rsp_su_instructions::reserved, // 12
-        device::rsp_su_instructions::break_,   // 13
-        device::rsp_su_instructions::reserved, // 14
-        device::rsp_su_instructions::reserved, // 15
-        device::rsp_su_instructions::reserved, // 16
-        device::rsp_su_instructions::reserved, // 17
-        device::rsp_su_instructions::reserved, // 18
-        device::rsp_su_instructions::reserved, // 19
-        device::rsp_su_instructions::reserved, // 20
-        device::rsp_su_instructions::reserved, // 21
-        device::rsp_su_instructions::reserved, // 22
-        device::rsp_su_instructions::reserved, // 23
-        device::rsp_su_instructions::reserved, // 24
-        device::rsp_su_instructions::reserved, // 25
-        device::rsp_su_instructions::reserved, // 26
-        device::rsp_su_instructions::reserved, // 27
-        device::rsp_su_instructions::reserved, // 28
-        device::rsp_su_instructions::reserved, // 29
-        device::rsp_su_instructions::reserved, // 30
-        device::rsp_su_instructions::reserved, // 31
-        device::rsp_su_instructions::add,      // 32
-        device::rsp_su_instructions::addu,     // 33
-        device::rsp_su_instructions::sub,      // 34
-        device::rsp_su_instructions::subu,     // 35
-        device::rsp_su_instructions::and,      // 36
-        device::rsp_su_instructions::or,       // 37
-        device::rsp_su_instructions::xor,      // 38
-        device::rsp_su_instructions::nor,      // 39
-        device::rsp_su_instructions::reserved, // 40
-        device::rsp_su_instructions::reserved, // 41
-        device::rsp_su_instructions::slt,      // 42
-        device::rsp_su_instructions::sltu,     // 43
-        device::rsp_su_instructions::reserved, // 44
-        device::rsp_su_instructions::reserved, // 45
-        device::rsp_su_instructions::reserved, // 46
-        device::rsp_su_instructions::reserved, // 47
-        device::rsp_su_instructions::reserved, // 48
-        device::rsp_su_instructions::reserved, // 49
-        device::rsp_su_instructions::reserved, // 50
-        device::rsp_su_instructions::reserved, // 51
-        device::rsp_su_instructions::reserved, // 52
-        device::rsp_su_instructions::reserved, // 53
-        device::rsp_su_instructions::reserved, // 54
-        device::rsp_su_instructions::reserved, // 55
-        device::rsp_su_instructions::reserved, // 56
-        device::rsp_su_instructions::reserved, // 57
-        device::rsp_su_instructions::reserved, // 58
-        device::rsp_su_instructions::reserved, // 59
-        device::rsp_su_instructions::reserved, // 60
-        device::rsp_su_instructions::reserved, // 61
-        device::rsp_su_instructions::reserved, // 62
-        device::rsp_su_instructions::reserved, // 63
+        device::rsp_su_instructions::sll,              // 0
+        device::rsp_su_instructions::special_reserved, // 1
+        device::rsp_su_instructions::srl,              // 2
+        device::rsp_su_instructions::sra,              // 3
+        device::rsp_su_instructions::sllv,             // 4
+        device::rsp_su_instructions::special_reserved, // 5
+        device::rsp_su_instructions::srlv,             // 6
+        device::rsp_su_instructions::srav,             // 7
+        device::rsp_su_instructions::jr,               // 8
+        device::rsp_su_instructions::jalr,             // 9
+        device::rsp_su_instructions::special_reserved, // 10
+        device::rsp_su_instructions::special_reserved, // 11
+        device::rsp_su_instructions::special_reserved, // 12
+        device::rsp_su_instructions::break_,           // 13
+        device::rsp_su_instructions::special_reserved, // 14
+        device::rsp_su_instructions::special_reserved, // 15
+        device::rsp_su_instructions::special_reserved, // 16
+        device::rsp_su_instructions::special_reserved, // 17
+        device::rsp_su_instructions::special_reserved, // 18
+        device::rsp_su_instructions::special_reserved, // 19
+        device::rsp_su_instructions::special_reserved, // 20
+        device::rsp_su_instructions::special_reserved, // 21
+        device::rsp_su_instructions::special_reserved, // 22
+        device::rsp_su_instructions::special_reserved, // 23
+        device::rsp_su_instructions::special_reserved, // 24
+        device::rsp_su_instructions::special_reserved, // 25
+        device::rsp_su_instructions::special_reserved, // 26
+        device::rsp_su_instructions::special_reserved, // 27
+        device::rsp_su_instructions::special_reserved, // 28
+        device::rsp_su_instructions::special_reserved, // 29
+        device::rsp_su_instructions::special_reserved, // 30
+        device::rsp_su_instructions::special_reserved, // 31
+        device::rsp_su_instructions::add,              // 32
+        device::rsp_su_instructions::addu,             // 33
+        device::rsp_su_instructions::sub,              // 34
+        device::rsp_su_instructions::subu,             // 35
+        device::rsp_su_instructions::and,              // 36
+        device::rsp_su_instructions::or,               // 37
+        device::rsp_su_instructions::xor,              // 38
+        device::rsp_su_instructions::nor,              // 39
+        device::rsp_su_instructions::special_reserved, // 40
+        device::rsp_su_instructions::special_reserved, // 41
+        device::rsp_su_instructions::slt,              // 42
+        device::rsp_su_instructions::sltu,             // 43
+        device::rsp_su_instructions::special_reserved, // 44
+        device::rsp_su_instructions::special_reserved, // 45
+        device::rsp_su_instructions::special_reserved, // 46
+        device::rsp_su_instructions::special_reserved, // 47
+        device::rsp_su_instructions::special_reserved, // 48
+        device::rsp_su_instructions::special_reserved, // 49
+        device::rsp_su_instructions::special_reserved, // 50
+        device::rsp_su_instructions::special_reserved, // 51
+        device::rsp_su_instructions::special_reserved, // 52
+        device::rsp_su_instructions::special_reserved, // 53
+        device::rsp_su_instructions::special_reserved, // 54
+        device::rsp_su_instructions::special_reserved, // 55
+        device::rsp_su_instructions::special_reserved, // 56
+        device::rsp_su_instructions::special_reserved, // 57
+        device::rsp_su_instructions::special_reserved, // 58
+        device::rsp_su_instructions::special_reserved, // 59
+        device::rsp_su_instructions::special_reserved, // 60
+        device::rsp_su_instructions::special_reserved, // 61
+        device::rsp_su_instructions::special_reserved, // 62
+        device::rsp_su_instructions::special_reserved, // 63
     ];
 
     device.rsp.cpu.regimm_instrs = [

src/device/rsp_interface.rs

@@ -267,7 +267,9 @@ pub fn read_regs(
     address: u64,
     _access_size: device::memory::AccessSize,
 ) -> u32 {
-    device::cop0::add_cycles(device, 20);
+    if !device.rsp.cpu.running {
+        device::cop0::add_cycles(device, 20);
+    }
     let reg = (address & 0xFFFF) >> 2;
     match reg as u32 {
         SP_DMA_BUSY_REG | SP_DMA_FULL_REG => {
@@ -292,7 +294,6 @@ pub fn read_regs(
             let value = device.rsp.regs[reg as usize];
             if value == 1 {
                 device.rsp.cpu.sync_point = true;
-                device.rsp.cpu.cycle_counter += 4; // needed for DK64
             }
             device.rsp.regs[reg as usize] = 1;
             value

src/device/rsp_su_instructions.rs

@@ -552,6 +552,7 @@ pub fn bgezal(device: &mut device::Device, opcode: u32) {
 }
 
 pub fn mfc0(device: &mut device::Device, opcode: u32) {
+    device.rsp.cpu.cycle_counter += 2;
     if rd(opcode) < device::rsp_interface::SP_REGS_COUNT {
         device.rsp.cpu.gpr[rt(opcode) as usize] = device::rsp_interface::read_regs(
             device,
@@ -1204,6 +1205,9 @@ pub fn stv(device: &mut device::Device, opcode: u32) {
     }
 }
 
-pub fn reserved(_device: &mut device::Device, _opcode: u32) {
-    panic!("rsp su reserved")
+pub fn special_reserved(device: &mut device::Device, opcode: u32) {
+    device.rsp.cpu.gpr[rd(opcode) as usize] =
+        device.rsp.cpu.gpr[rs(opcode) as usize] >> (device.rsp.cpu.gpr[rs(opcode) as usize] & 31)
 }
+
+pub fn reserved(_device: &mut device::Device, _opcode: u32) {}

src/device/vi.rs

@@ -2,7 +2,7 @@ use crate::{device, netplay, ui};
 use governor::clock::Clock;
 
 const VI_STATUS_REG: u32 = 0;
-//const VI_ORIGIN_REG: u32 = 1;
+const VI_ORIGIN_REG: u32 = 1;
 //const VI_WIDTH_REG: u32 = 2;
 //const VI_V_INTR_REG: u32 = 3;
 const VI_CURRENT_REG: u32 = 4;
@@ -27,26 +27,39 @@ pub struct Vi {
     pub limiter: Option<governor::DefaultDirectRateLimiter>,
     pub count_per_scanline: u64,
     pub vi_counter: u64,
+    pub last_origin: u32,
+    pub internal_frame_counter: u64,
+    pub min_wait_time: std::time::Duration,
+    pub frame_time: f64,
+    pub limit_freq: u64,
+    #[serde(skip)]
+    #[serde(default = "std::time::Instant::now")]
+    pub limit_freq_check: std::time::Instant,
 }
 
-//static mut FRAME_COUNTER: u64 = 0;
-
-const LIMIT_BUFFER: u64 = 3;
+const MAX_LIMIT_FREQ: u64 = 3;
 
 pub fn set_expected_refresh_rate(device: &mut device::Device) {
     let expected_refresh_rate = device.vi.clock as f64
         / (device.vi.regs[VI_V_SYNC_REG as usize] + 1) as f64
         / ((device.vi.regs[VI_H_SYNC_REG as usize] & 0xFFF) + 1) as f64
         * 2.0;
+    device.vi.frame_time = 1.0 / expected_refresh_rate;
     device.vi.delay = (device.cpu.clock_rate as f64 / expected_refresh_rate) as u64;
     device.vi.count_per_scanline =
         device.vi.delay / (device.vi.regs[VI_V_SYNC_REG as usize] + 1) as u64;
 
+    create_limiter(device);
+}
+
+fn create_limiter(device: &mut device::Device) {
     let quota = governor::Quota::with_period(std::time::Duration::from_secs_f64(
-        (1.0 / expected_refresh_rate) * LIMIT_BUFFER as f64,
+        device.vi.frame_time * device.vi.limit_freq as f64,
     ))
     .unwrap();
-    device.vi.limiter = Some(governor::RateLimiter::direct(quota))
+    device.vi.limiter = Some(governor::RateLimiter::direct(quota));
+    let _ = device.vi.limiter.as_ref().unwrap().check();
+    //println!("new limit freq: {}", device.vi.limit_freq);
 }
 
 fn set_vertical_interrupt(device: &mut device::Device) {
@@ -109,6 +122,13 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
                 set_expected_refresh_rate(device);
             }
         }
+        VI_ORIGIN_REG => {
+            device::memory::masked_write_32(&mut device.vi.regs[reg as usize], value, mask);
+            if device.vi.regs[reg as usize] != device.vi.last_origin {
+                device.vi.last_origin = device.vi.regs[reg as usize];
+                device.vi.internal_frame_counter += 1;
+            }
+        }
         _ => {
             device::memory::masked_write_32(&mut device.vi.regs[reg as usize], value, mask);
         }
@@ -117,15 +137,8 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
 }
 
 pub fn vertical_interrupt_event(device: &mut device::Device) {
-    ui::video::update_screen();
     ui::video::check_callback(device);
 
-    /*
-        unsafe {
-            FRAME_COUNTER += 1;
-        }
-    */
-
     let mut enable_speed_limiter = true;
     if device.netplay.is_some() {
         netplay::send_sync_check(device);
@@ -133,9 +146,18 @@ pub fn vertical_interrupt_event(device: &mut device::Device) {
     }
 
     device.vi.vi_counter += 1;
-    if device.vi.vi_counter % LIMIT_BUFFER == 0 && enable_speed_limiter {
+    if device.vi.vi_counter % device.vi.limit_freq == 0 && enable_speed_limiter {
         speed_limiter(device);
     }
+    ui::video::update_screen();
+
+    /*
+    let vis = if device.cart.pal { 50 } else { 60 };
+    if device.vi.vi_counter % vis == 0 {
+        println!("FPS: {}", device.vi.internal_frame_counter);
+        device.vi.internal_frame_counter = 0;
+    }
+    */
 
     /* toggle vi field if in interlaced mode */
     device.vi.field ^= (device.vi.regs[VI_STATUS_REG as usize] >> 6) & 0x1;
@@ -155,27 +177,40 @@ pub fn init(device: &mut device::Device) {
     } else {
         device.vi.clock = 48681812
     }
-    /*
-    std::thread::spawn(move || {
-        let mut last_count = 0;
-        loop {
-            unsafe {
-                println!("{:?}", FRAME_COUNTER - last_count);
-                last_count = FRAME_COUNTER;
-            }
-            std::thread::sleep(std::time::Duration::from_secs(1));
-        }
-    });
-    */
 }
 
-fn speed_limiter(device: &device::Device) {
+fn speed_limiter(device: &mut device::Device) {
     let result = device.vi.limiter.as_ref().unwrap().check();
     if result.is_err() {
         let outcome = result.unwrap_err();
         let dur = outcome.wait_time_from(governor::clock::DefaultClock::default().now());
         spin_sleep::sleep(dur);
+        if dur < device.vi.min_wait_time {
+            device.vi.min_wait_time = dur;
+        }
 
         let _ = device.vi.limiter.as_ref().unwrap().check();
+    } else {
+        device.vi.min_wait_time = std::time::Duration::from_secs(0);
+    }
+
+    if std::time::Instant::now()
+        .duration_since(device.vi.limit_freq_check)
+        .as_secs_f64()
+        > 1.0
+    {
+        if device.vi.min_wait_time.as_secs_f64() == 0.0 && device.vi.limit_freq < MAX_LIMIT_FREQ {
+            device.vi.limit_freq += 1;
+            create_limiter(device);
+        } else if device.vi.min_wait_time.as_secs_f64() > device.vi.frame_time
+            && device.vi.limit_freq > 1
+        {
+            device.vi.limit_freq -= 1;
+            create_limiter(device);
+        }
+
+        //println!("limit freq: {}", device.vi.limit_freq);
+        device.vi.min_wait_time = std::time::Duration::from_secs(1);
+        device.vi.limit_freq_check = std::time::Instant::now();
     }
 }

src/ui.rs

@@ -132,6 +132,7 @@ impl Ui {
             pak_audio: audio::PakAudio {
                 mempak: include_bytes!("../data/mempak.wav").to_vec(),
                 rumblepak: include_bytes!("../data/rumblepak.wav").to_vec(),
+                transferpak: include_bytes!("../data/transferpak.wav").to_vec(),
             },
             window: std::ptr::null_mut(),
             audio_stream: std::ptr::null_mut(),

src/ui/audio.rs

@@ -4,6 +4,7 @@ use crate::ui;
 pub struct PakAudio {
     pub mempak: Vec<u8>,
     pub rumblepak: Vec<u8>,
+    pub transferpak: Vec<u8>,
 }
 
 pub fn init(ui: &mut ui::Ui, frequency: u64) {
@@ -76,6 +77,8 @@ pub fn play_pak_switch(ui: &mut ui::Ui, pak: device::controller::PakType) {
         sound = &ui.pak_audio.rumblepak;
     } else if pak == device::controller::PakType::MemPak {
         sound = &ui.pak_audio.mempak;
+    } else if pak == device::controller::PakType::TransferPak {
+        sound = &ui.pak_audio.transferpak;
     } else {
         return;
     }

src/ui/input.rs

@@ -334,10 +334,20 @@ pub fn get(ui: &mut ui::Ui, channel: usize) -> (u32, bool) {
     let mut keys = 0;
     let controller = ui.controllers[channel].game_controller;
     let joystick = ui.controllers[channel].joystick;
+
+    let alt_pressed = unsafe {
+        // ignore key presses if ALT is pressed
+        *ui.keyboard_state
+            .offset(i32::from(sdl3_sys::scancode::SDL_SCANCODE_LALT) as isize)
+            || *ui
+                .keyboard_state
+                .offset(i32::from(sdl3_sys::scancode::SDL_SCANCODE_RALT) as isize)
+    };
+
     for i in 0..14 {
         if profile_name != "default" || channel == 0 {
             let profile_key = profile.keys[i];
-            if profile_key.0 {
+            if profile_key.0 && !alt_pressed {
                 keys |= (unsafe { *ui.keyboard_state.offset(profile_key.1 as isize) } as u32) << i;
             }
         }
@@ -513,9 +523,14 @@ pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
                 if event_type == u32::from(sdl3_sys::events::SDL_EVENT_WINDOW_CLOSE_REQUESTED) {
                     close_controllers(open_joysticks, open_controllers);
                     return;
-                } else if event_type == u32::from(sdl3_sys::events::SDL_EVENT_KEY_DOWN) {
-                    new_keys[*value] = (true, i32::from(unsafe { event.key.scancode }));
-                    key_set = true
+                } else if event_type == u32::from(sdl3_sys::events::SDL_EVENT_KEY_UP) {
+                    if unsafe {
+                        event.key.scancode != sdl3_sys::scancode::SDL_SCANCODE_LALT
+                            && event.key.scancode != sdl3_sys::scancode::SDL_SCANCODE_RALT
+                    } {
+                        new_keys[*value] = (true, i32::from(unsafe { event.key.scancode }));
+                        key_set = true
+                    }
                 } else if event_type == u32::from(sdl3_sys::events::SDL_EVENT_GAMEPAD_BUTTON_DOWN) {
                     if !open_controllers.is_empty() {
                         new_controller_buttons[*value] =
@@ -705,7 +720,7 @@ pub fn init(ui: &mut ui::Ui) {
     let mut taken = [false; 4];
     for i in 0..4 {
         let controller_assignment = &ui.config.input.controller_assignment[i];
-        if controller_assignment.is_some() {
+        if controller_assignment.is_some() && ui.config.input.controller_enabled[i] {
             let mut joystick_id = 0;
             let assigned_path = controller_assignment.as_ref().unwrap();
 

src/ui/video.rs

@@ -14,15 +14,24 @@ pub fn init(device: &mut device::Device) {
     } else {
         flags |= sdl3_sys::video::SDL_WINDOW_RESIZABLE;
     }
+    flags |= sdl3_sys::video::SDL_WINDOW_INPUT_FOCUS;
 
-    device.ui.window =
-        unsafe { sdl3_sys::video::SDL_CreateWindow(title.as_ptr(), 640, 480, flags) };
+    let mut window_width = 640;
+    let mut window_height = 480;
+    if device.cart.pal {
+        window_width = 768;
+        window_height = 576;
+    }
+    device.ui.window = unsafe {
+        sdl3_sys::video::SDL_CreateWindow(title.as_ptr(), window_width, window_height, flags)
+    };
     if device.ui.window.is_null() {
         panic!("Could not create window");
     }
     if !unsafe { sdl3_sys::video::SDL_ShowWindow(device.ui.window) } {
         panic!("Could not show window");
     }
+    unsafe { sdl3_sys::everything::SDL_HideCursor() };
 
     let gfx_info = GFX_INFO {
         RDRAM: device.rdram.mem.as_mut_ptr(),
@@ -32,6 +41,7 @@ pub fn init(device: &mut device::Device) {
         DPC_START_REG: &mut device.rdp.regs_dpc[device::rdp::DPC_START_REG as usize],
         DPC_END_REG: &mut device.rdp.regs_dpc[device::rdp::DPC_END_REG as usize],
         DPC_STATUS_REG: &mut device.rdp.regs_dpc[device::rdp::DPC_STATUS_REG as usize],
+        PAL: device.cart.pal,
     };
 
     unsafe {
@@ -66,6 +76,7 @@ pub fn load_state(device: &mut device::Device) {
         DPC_START_REG: &mut device.rdp.regs_dpc[device::rdp::DPC_START_REG as usize],
         DPC_END_REG: &mut device.rdp.regs_dpc[device::rdp::DPC_END_REG as usize],
         DPC_STATUS_REG: &mut device.rdp.regs_dpc[device::rdp::DPC_STATUS_REG as usize],
+        PAL: device.cart.pal,
     };
     unsafe {
         rdp_new_processor(gfx_info, device.ui.config.video.upscale);