thirdpartymirrors/N64ModernRuntime
1
0
Fork 0
mirror of https://github.com/N64Recomp/N64ModernRuntime.git synced 2026-04-22 10:02:08 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

cleanup + write pfs files to save directory

Browse source
This commit is contained in:
Garrett Smith 2026-01-22 22:09:31 -08:00
parent cb0a22cdaf
commit 8d997fcb86
8 changed files with 461 additions and 439 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
ultramodern/CMakeLists.txt
View file

@ -14,6 +14,7 @@ add_library(ultramodern STATIC
"${CMAKE_CURRENT_SOURCE_DIR}/src/input.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/src/input.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/mesgqueue.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/src/mesgqueue.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/misc_ultra.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/src/misc_ultra.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/pfs.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/renderer_context.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/src/renderer_context.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/rsp.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/src/rsp.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/save.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/src/save.cpp"

5
ultramodern/include/ultramodern/input.hpp
View file

@ -58,6 +58,11 @@ namespace ultramodern {
void set_callbacks(const callbacks_t& callbacks); void set_callbacks(const callbacks_t& callbacks);
} }
input::connected_device_info_t get_connected_device_info(int channel);
int get_max_controllers();
} }
#endif #endif

2
ultramodern/include/ultramodern/save.hpp
View file

@ -34,6 +34,8 @@ namespace ultramodern {
size_t get_save_size(SaveType save_type); size_t get_save_size(SaveType save_type);
std::filesystem::path get_save_base_path();
std::filesystem::path get_save_file_path(); std::filesystem::path get_save_file_path();
bool eeprom_allowed(); bool eeprom_allowed();

42
ultramodern/include/ultramodern/ultra64.h
View file

@ -74,6 +74,38 @@ typedef u64 OSTime;
#define OS_EVENT_THREADSTATUS 13 /* CPU thread status: used by rmon */ #define OS_EVENT_THREADSTATUS 13 /* CPU thread status: used by rmon */
#define OS_EVENT_PRENMI 14 /* Pre NMI interrupt */ #define OS_EVENT_PRENMI 14 /* Pre NMI interrupt */
/* Controller errors */
#define CONT_NO_RESPONSE_ERROR 0x8
#define CONT_OVERRUN_ERROR 0x4
#define CONT_RANGE_ERROR -1
#define CONT_FRAME_ERROR 0x2
#define CONT_COLLISION_ERROR 0x1
/* Controller type */
#define CONT_TYPE_NORMAL 0x0005
#define CONT_TYPE_MOUSE 0x0002
#define CONT_TYPE_VOICE 0x0100
/* File System error number */
#define PFS_ERR_NOPACK 1 /* no memory card is plugged or */
#define PFS_ERR_NEW_PACK 2 /* ram pack has been changed to a different one */
#define PFS_ERR_INCONSISTENT 3 /* need to run Pfschecker*/
#define PFS_ERR_CONTRFAIL CONT_OVERRUN_ERROR
#define PFS_ERR_INVALID 5 /* invalid parameter or file not exist*/
#define PFS_ERR_BAD_DATA 6 /* the data read from pack are bad*/
#define PFS_DATA_FULL 7 /* no free pages on ram pack*/
#define PFS_DIR_FULL 8 /* no free directories on ram pack*/
#define PFS_ERR_EXIST 9 /* file exists*/
#define PFS_ERR_ID_FATAL 10 /* dead ram pack */
#define PFS_ERR_DEVICE 11 /* wrong device type*/
#define PFS_ERR_NO_GBCART 12 /* no gb cartridge (64GB-PAK) */
#define PFS_ERR_NEW_GBCART 13 /* gb cartridge may be changed */
/* File System size */
#define PFS_INODE_SIZE_PER_PAGE 128 #define PFS_INODE_SIZE_PER_PAGE 128
#define PFS_FILE_NAME_LEN 16 #define PFS_FILE_NAME_LEN 16
#define PFS_FILE_EXT_LEN 4 #define PFS_FILE_EXT_LEN 4
@ -81,10 +113,20 @@ typedef u64 OSTime;
#define PFS_ONE_PAGE 8 /* blocks */ #define PFS_ONE_PAGE 8 /* blocks */
#define PFS_MAX_BANKS 62 #define PFS_MAX_BANKS 62
/* File System flag */
#define PFS_READ 0 #define PFS_READ 0
#define PFS_WRITE 1 #define PFS_WRITE 1
#define PFS_CREATE 2 #define PFS_CREATE 2
/* File System status */
#define PFS_INITIALIZED 0x1
#define PFS_CORRUPTED 0x2
#define PFS_ID_BROKEN 0x4
#define PFS_MOTOR_INITIALIZED 0x8
#define PFS_GBPAK_INITIALIZED 0x10
#define M_GFXTASK 1 #define M_GFXTASK 1
#define M_AUDTASK 2 #define M_AUDTASK 2
#define M_VIDTASK 3 #define M_VIDTASK 3

435
ultramodern/src/input.cpp
View file

@ -1,42 +1,31 @@
#include <cassert> #include <cassert>
#include <cstdlib>
#include <format>
#include "ultramodern/input.hpp" #include "ultramodern/input.hpp"
#include "ultramodern/ultra64.h" #include "ultramodern/ultra64.h"
#include "ultramodern/ultramodern.hpp" #include "ultramodern/ultramodern.hpp"
#include "controller_pak.hpp"
#define PFS_ERR_NOPACK 1 // no device inserted #define MAXCONTROLLERS 4
#define PFS_ERR_NEW_PACK 2 /* ram pack has been changed to a different one */
#define PFS_ERR_INCONSISTENT 3 /* need to run Pfschecker*/
#define PFS_ERR_CONTRFAIL 4 // data transmission failure
#define PFS_ERR_INVALID 5 // invalid parameter or invalid file
#define PFS_ERR_BAD_DATA 6 /* the data read from pack are bad*/
#define PFS_DATA_FULL 7 /* no free pages on ram pack*/
#define PFS_DIR_FULL 8 /* no free directories on ram pack*/
#define PFS_ERR_EXIST 9 /* file exists*/
#define PFS_ERR_ID_FATAL 10 /* dead ram pack */
#define PFS_ERR_DEVICE 11 // different type of device inserted
#define PFS_ERR_NO_GBCART 12 /* no gb cartridge (64GB-PAK) */
#define PFS_ERR_NEW_GBCART 13 /* gb cartridge may be changed */
#define PFS_INITIALIZED 1 static int max_controllers = 0;
#define PFS_CORRUPTED 2
#define PFS_ID_BROKEN 4
#define PFS_MOTOR_INITIALIZED 8
#define PFS_GBPAK_INITIALIZED 16
#define ARRLEN(x) (sizeof(x) / sizeof((x)[0]))
#define MAX_FILES 16
#define TRACE_ENTRY() fprintf(stderr, "PAK_ENTRY(%s)\n", __func__);
static ultramodern::input::callbacks_t input_callbacks {}; static ultramodern::input::callbacks_t input_callbacks {};
int ultramodern::get_max_controllers() {
return max_controllers;
}
void ultramodern::input::set_callbacks(const callbacks_t& callbacks) { void ultramodern::input::set_callbacks(const callbacks_t& callbacks) {
input_callbacks = callbacks; input_callbacks = callbacks;
} }
ultramodern::input::connected_device_info_t ultramodern::get_connected_device_info(int channel) {
ultramodern::input::connected_device_info_t device_info{};
if (input_callbacks.get_connected_device_info != nullptr) {
device_info = input_callbacks.get_connected_device_info(channel);
}
return device_info;
}
static std::chrono::high_resolution_clock::time_point input_poll_time; static std::chrono::high_resolution_clock::time_point input_poll_time;
static void update_poll_time() { static void update_poll_time() {
@ -49,16 +38,6 @@ void ultramodern::measure_input_latency() {
#endif #endif
} }
#define MAXCONTROLLERS 4
#define CONT_NO_RESPONSE_ERROR 0x8
#define CONT_TYPE_NORMAL 0x0005
#define CONT_TYPE_MOUSE 0x0002
#define CONT_TYPE_VOICE 0x0100
static int max_controllers = 0;
/* Plain controller */ /* Plain controller */
static u16 get_controller_type(ultramodern::input::Device device_type) { static u16 get_controller_type(ultramodern::input::Device device_type) {
@ -85,12 +64,7 @@ static void __osContGetInitData(u8* pattern, OSContStatus *data) {
*pattern = 0x00; *pattern = 0x00;
for (int controller = 0; controller < max_controllers; controller++) { for (int controller = 0; controller < max_controllers; controller++) {
ultramodern::input::connected_device_info_t device_info{}; const auto device_info = ultramodern::get_connected_device_info(controller);
if (input_callbacks.get_connected_device_info != nullptr) {
device_info = input_callbacks.get_connected_device_info(controller);
}
if (device_info.connected_device != ultramodern::input::Device::None) { if (device_info.connected_device != ultramodern::input::Device::None) {
// Mark controller as present // Mark controller as present
@ -187,11 +161,7 @@ extern "C" s32 osMotorInit(RDRAM_ARG PTR(OSMesgQueue) mq_, PTR(OSPfs) pfs_, int
pfs->activebank = 0xFF; pfs->activebank = 0xFF;
pfs->status = 0; pfs->status = 0;
ultramodern::input::connected_device_info_t device_info{}; const auto device_info = ultramodern::get_connected_device_info(channel);
if (input_callbacks.get_connected_device_info != nullptr) {
device_info = input_callbacks.get_connected_device_info(channel);
}
if (device_info.connected_device != ultramodern::input::Device::Controller) { if (device_info.connected_device != ultramodern::input::Device::Controller) {
return PFS_ERR_CONTRFAIL; return PFS_ERR_CONTRFAIL;
} }
@ -228,376 +198,3 @@ extern "C" s32 __osMotorAccess(RDRAM_ARG PTR(OSPfs) pfs_, s32 flag) {
return 0; return 0;
} }
/* ControllerPak */
static s32 __osPfsGetStatus(RDRAM_ARG PTR(OSMesgQueue) queue, int channel) {
ultramodern::input::connected_device_info_t device_info{};
if (input_callbacks.get_connected_device_info != nullptr) {
device_info = input_callbacks.get_connected_device_info(channel);
}
if (device_info.connected_device != ultramodern::input::Device::Controller) {
return PFS_ERR_CONTRFAIL;
}
if (device_info.connected_pak == ultramodern::input::Pak::None) {
return PFS_ERR_NOPACK;
}
if (device_info.connected_pak != ultramodern::input::Pak::ControllerPak) {
return PFS_ERR_DEVICE;
}
// If a header file doesn't exist, create it.
ControllerPak pak;
if (!std::filesystem::exists("controllerPak_header.sav")) {
pak.header.open("controllerPak_header.sav", std::ios::binary | std::ios::in | std::ios::out | std::ios::trunc);
pak.header.close();
}
fprintf(stderr, "__osPfsGetStatus OK\n");
return 0;
}
extern "C" s32 osPfsInitPak(RDRAM_ARG PTR(OSMesgQueue) mq_, PTR(OSPfs) pfs_, int channel) {
TRACE_ENTRY()
OSPfs* pfs = TO_PTR(OSPfs, pfs_);
const auto status = __osPfsGetStatus(PASS_RDRAM mq_, channel);
if (status != 0) {
return status;
}
pfs->queue = mq_;
pfs->channel = channel;
pfs->status = 0;
const s32 ret = osPfsChecker(PASS_RDRAM pfs_);
pfs->status |= PFS_INITIALIZED;
return 0;
}
extern "C" s32 osPfsRepairId(RDRAM_ARG PTR(OSPfs) pfs) {
TRACE_ENTRY()
return 0;
}
extern "C" s32 osPfsInit(RDRAM_ARG PTR(OSMesgQueue) mq_, PTR(OSPfs) pfs_, int channel) {
TRACE_ENTRY()
OSPfs* pfs = TO_PTR(OSPfs, pfs_);
const auto status = __osPfsGetStatus(PASS_RDRAM mq_, channel);
if (status != 0) {
return status;
}
pfs->queue = mq_;
pfs->channel = channel;
pfs->status = 0;
pfs->activebank = -1;
const s32 ret = osPfsChecker(PASS_RDRAM pfs_);
pfs->status |= PFS_INITIALIZED;
return 0;
}
extern "C" s32 osPfsReFormat(RDRAM_ARG PTR(OSPfs) pfs, PTR(OSMesgQueue) mq_, int channel) {
TRACE_ENTRY()
return 0;
}
extern "C" s32 osPfsChecker(RDRAM_ARG PTR(OSPfs) pfs) {
TRACE_ENTRY()
return 0;
}
extern "C" s32 osPfsAllocateFile(RDRAM_ARG PTR(OSPfs) pfs, u16 company_code, u32 game_code, u8* game_name, u8* ext_name, int nbytes, PTR(s32) file_no_) {
TRACE_ENTRY()
s32* file_no = TO_PTR(s32, file_no_);
if ((company_code == 0) || (game_code == 0)) {
return PFS_ERR_INVALID;
}
/* Search for a free slot */
u8 free_file_index = 0;
for (size_t i = 0; i < MAX_FILES; i++) {
ControllerPakHdr hdr{};
Pfs_PakHeader_Read(hdr, i);
if ((hdr.company_code == 0) || (hdr.game_code == 0)) {
free_file_index = i;
break;
}
}
if (free_file_index == MAX_FILES) {
return PFS_DIR_FULL;
}
Pfs_PakHeader_Write(nbytes, game_code, company_code, ext_name, game_name, free_file_index);
/* Create empty file */
ControllerPak pak;
const auto filename = std::format("controllerPak_file_{}.sav", free_file_index);
pak.file.open(filename, std::ios::binary | std::ios::in | std::ios::out | std::ios::trunc);
nbytes = (nbytes + 31) & ~31;
std::vector<u8> zero_block(nbytes, 0);
pak.file.seekp(0, std::ios::beg);
pak.file.write((char*)zero_block.data(), nbytes);
pak.file.close();
*file_no = free_file_index;
return 0;
}
extern "C" s32 osPfsFindFile(RDRAM_ARG PTR(OSPfs) pfs_, u16 company_code, u32 game_code, u8* game_name, u8* ext_name, PTR(s32) file_no_) {
TRACE_ENTRY()
OSPfs* pfs = TO_PTR(OSPfs, pfs_);
s32* file_no = TO_PTR(s32, file_no_);
for (size_t i = 0; i < MAX_FILES; i++) {
ControllerPakHdr hdr{};
Pfs_PakHeader_Read(hdr, i);
if ((hdr.company_code == 0) || (hdr.game_code == 0)) {
continue;
} else {
if ((game_code == hdr.game_code) && (company_code == hdr.company_code)) {
for (size_t i = 0; i < ARRLEN(hdr.game_name); i++) {
if (game_name[i] != hdr.game_name[i]) {
break;
}
}
for (size_t i = 0; i < ARRLEN(hdr.ext_name); i++) {
if (ext_name[i] != hdr.ext_name[i]) {
break;
}
}
// File found
*file_no = i;
return 0;
}
}
}
return PFS_ERR_INVALID;
}
extern "C" s32 osPfsDeleteFile(RDRAM_ARG PTR(OSPfs) pfs_, u16 company_code, u32 game_code, u8* game_name, u8* ext_name) {
TRACE_ENTRY()
if (company_code == 0 || game_code == 0) {
return PFS_ERR_INVALID;
}
ControllerPak pak;
for (int i = 0; i < MAX_FILES; i++) {
ControllerPakHdr hdr{};
Pfs_PakHeader_Read(hdr, i);
if ((hdr.company_code == 0) || (hdr.game_code == 0)) {
continue;
} else {
if ((game_code == hdr.game_code) && (company_code == hdr.company_code)) {
int gncount = 0;
int encount = 0;
for (size_t i = 0; i < ARRLEN(hdr.game_name); i++) {
if (game_name[i] == hdr.game_name[i]) {
gncount++;
}
}
for (size_t i = 0; i < ARRLEN(hdr.ext_name); i++) {
if (ext_name[i] == hdr.ext_name[i]) {
encount++;
}
}
if ((gncount != 16) || encount != 4) {
continue;
}
// File found
pak.header.open("controllerPak_header.sav", std::ios::binary | std::ios::in | std::ios::out);
if (!pak.header.good()) {
assert(false);
}
if (!pak.header.is_open()) {
assert(false);
}
u32 seek = i * sizeof(OSPfsState);
// Zero out the header for this file.
std::vector<u8> zero_block(sizeof(OSPfsState), 0);
pak.header.seekp(seek + 0x0, std::ios::beg);
pak.header.write((char*)zero_block.data(), sizeof(OSPfsState));
pak.header.close();
std::filesystem::remove(std::format("controllerPak_file_{}.sav", i));
return 0;
}
}
}
return PFS_ERR_INVALID;
}
extern "C" s32 osPfsReadWriteFile(RDRAM_ARG PTR(OSPfs) pfs_, s32 file_no, u8 flag, int offset, int size_in_bytes, u8* data_buffer) {
TRACE_ENTRY()
ControllerPak pak;
const auto filename = std::format("controllerPak_file_{}.sav", file_no);
pak.file.open(filename, std::ios::binary | std::ios::in | std::ios::out);
if (!std::filesystem::exists(filename)) {
return PFS_ERR_INVALID;
}
if (!pak.file.good()) {
return PFS_ERR_INVALID;
}
if (!pak.file.is_open()) {
return PFS_ERR_INVALID;
}
std::vector<u8> swap_buffer(size_in_bytes);
if (flag == 0) {
pak.file.seekg(offset, std::ios::beg);
pak.file.read((char*)swap_buffer.data(), size_in_bytes);
ByteSwapCopy(data_buffer, swap_buffer.data(), size_in_bytes);
} else {
ByteSwapCopy(swap_buffer.data(), data_buffer, size_in_bytes);
pak.file.seekp(offset, std::ios::beg);
pak.file.write((char*)swap_buffer.data(), size_in_bytes);
}
pak.file.close();
return 0;
}
extern "C" s32 osPfsFileState(RDRAM_ARG PTR(OSPfs) pfs_, s32 file_no, PTR(OSPfsState) state_) {
TRACE_ENTRY()
OSPfsState *state = TO_PTR(OSPfsState, state_);
// should pass the state of the requested file_no to the incoming state pointer,
// games call this function 16 times, once per file
// fills the incoming state with the information inside the header of the pak.
const auto filename = std::format("controllerPak_file_{}.sav", file_no);
if (!std::filesystem::exists(filename)) {
return PFS_ERR_INVALID;
}
/* Read game info from pak */
ControllerPakHdr hdr{};
Pfs_PakHeader_Read(hdr, file_no);
state->file_size = hdr.file_size;
state->company_code = hdr.company_code;
state->game_code = hdr.game_code;
for (size_t i = 0; i < ARRLEN(hdr.game_name); i++) {
state->game_name[i] = hdr.game_name[i];
}
for (size_t i = 0; i < ARRLEN(hdr.ext_name); i++) {
state->ext_name[i] = hdr.ext_name[i];
}
return 0;
}
extern "C" s32 osPfsGetLabel(RDRAM_ARG PTR(OSPfs) pfs_, u8* label, PTR(int) len_) {
TRACE_ENTRY()
OSPfs* pfs = TO_PTR(OSPfs, pfs_);
int* len = TO_PTR(int, len_);
if (label == NULL) {
return PFS_ERR_INVALID;
}
// if (__osCheckId(pfs) == PFS_ERR_NEW_PACK) {
// return PFS_ERR_NEW_PACK;
// }
int i;
for (i = 0; i < ARRLEN(pfs->label); i++) {
if (pfs->label[i] == 0) {
break;
}
*label++ = pfs->label[i];
}
*len = i;
return 0;
}
extern "C" s32 osPfsSetLabel(RDRAM_ARG PTR(OSPfs) pfs_, u8* label) {
TRACE_ENTRY()
OSPfs* pfs = TO_PTR(OSPfs, pfs_);
if (label != NULL) {
for (int i = 0; i < ARRLEN(pfs->label); i++) {
if (*label == 0) {
break;
}
pfs->label[i] = *label++;
}
}
return 0;
}
extern "C" s32 osPfsIsPlug(RDRAM_ARG PTR(OSMesgQueue) mq_, u8* pattern) {
TRACE_ENTRY()
u8 bits = 0;
for (int channel = 0; channel < max_controllers; channel++) {
if (__osPfsGetStatus(PASS_RDRAM mq_, channel) == 0) {
bits |= (1 << channel);
}
}
*pattern = bits;
return 0;
}
extern "C" s32 osPfsFreeBlocks(RDRAM_ARG PTR(OSPfs) pfs_, PTR(s32) bytes_not_used_) {
TRACE_ENTRY()
OSPfs *pfs = TO_PTR(OSPfs, pfs_);
s32 *bytes_not_used = TO_PTR(s32, bytes_not_used_);
s32 bytes_used = 0;
for (size_t i = 0; i < MAX_FILES; i++) {
ControllerPakHdr hdr{};
Pfs_PakHeader_Read(hdr, i);
if ((hdr.company_code != 0) && (hdr.game_code != 0)) {
bytes_used += hdr.file_size >> 8;
}
}
*bytes_not_used = (123 - bytes_used) << 8;
return 0;
}
extern "C" s32 osPfsNumFiles(RDRAM_ARG PTR(OSPfs) pfs_, PTR(s32) max_files_, PTR(s32) files_used_) {
TRACE_ENTRY()
OSPfs *pfs = TO_PTR(OSPfs, pfs_);
s32 *max_files = TO_PTR(s32, max_files_);
s32 *files_used = TO_PTR(s32, files_used_);
u8 num_files = 0;
for (size_t i = 0; i < MAX_FILES; i++) {
ControllerPakHdr hdr{};
Pfs_PakHeader_Read(hdr, i);
if ((hdr.company_code != 0) && (hdr.game_code != 0)) {
num_files++;
}
}
*max_files = MAX_FILES;
*files_used = num_files;
return 0;
}

355
ultramodern/src/pfs.cpp Normal file
View file

@ -0,0 +1,355 @@
#include <cassert>
#include <cstdlib>
#include <format>
#include <ultramodern/ultra64.h>
#include "pfs.hpp"
#define ARRLEN(x) (sizeof(x) / sizeof((x)[0]))
#define MAX_FILES 16
/* ControllerPak */
static s32 __osPfsGetStatus(RDRAM_ARG PTR(OSMesgQueue) queue, int channel) {
const auto device_info = ultramodern::get_connected_device_info(channel);
if (device_info.connected_device != ultramodern::input::Device::Controller) {
return PFS_ERR_CONTRFAIL;
}
if (device_info.connected_pak == ultramodern::input::Pak::None) {
return PFS_ERR_NOPACK;
}
if (device_info.connected_pak != ultramodern::input::Pak::ControllerPak) {
return PFS_ERR_DEVICE;
}
pfs_header_alloc();
return 0;
}
extern "C" s32 osPfsInitPak(RDRAM_ARG PTR(OSMesgQueue) mq_, PTR(OSPfs) pfs_, int channel) {
OSPfs* pfs = TO_PTR(OSPfs, pfs_);
const auto status = __osPfsGetStatus(PASS_RDRAM mq_, channel);
if (status != 0) {
return status;
}
pfs->queue = mq_;
pfs->channel = channel;
pfs->status = 0;
const s32 ret = osPfsChecker(PASS_RDRAM pfs_);
pfs->status |= PFS_INITIALIZED;
return 0;
}
extern "C" s32 osPfsRepairId(RDRAM_ARG PTR(OSPfs) pfs) {
return 0;
}
extern "C" s32 osPfsInit(RDRAM_ARG PTR(OSMesgQueue) mq_, PTR(OSPfs) pfs_, int channel) {
OSPfs* pfs = TO_PTR(OSPfs, pfs_);
const auto status = __osPfsGetStatus(PASS_RDRAM mq_, channel);
if (status != 0) {
return status;
}
pfs->queue = mq_;
pfs->channel = channel;
pfs->status = 0;
pfs->activebank = -1;
const s32 ret = osPfsChecker(PASS_RDRAM pfs_);
pfs->status |= PFS_INITIALIZED;
return 0;
}
extern "C" s32 osPfsReFormat(RDRAM_ARG PTR(OSPfs) pfs, PTR(OSMesgQueue) mq_, int channel) {
return 0;
}
extern "C" s32 osPfsChecker(RDRAM_ARG PTR(OSPfs) pfs) {
return 0;
}
extern "C" s32 osPfsAllocateFile(RDRAM_ARG PTR(OSPfs) pfs, u16 company_code, u32 game_code, u8* game_name, u8* ext_name, int nbytes, PTR(s32) file_no_) {
s32* file_no = TO_PTR(s32, file_no_);
if ((company_code == 0) || (game_code == 0)) {
return PFS_ERR_INVALID;
}
/* Search for a free slot */
u8 free_file_index = 0;
for (size_t i = 0; i < MAX_FILES; i++) {
pfs_header_t hdr{};
pfs_header_read(hdr, i);
if ((hdr.company_code == 0) || (hdr.game_code == 0)) {
free_file_index = i;
break;
}
}
if (free_file_index == MAX_FILES) {
return PFS_DIR_FULL;
}
pfs_header_write(nbytes, game_code, company_code, ext_name, game_name, free_file_index);
/* Create empty file */
pfs_state_t pak;
const auto filename = pfs_file_path(free_file_index);
pak.file.open(filename, std::ios::binary | std::ios::out | std::ios::trunc);
nbytes = (nbytes + 31) & ~31;
std::vector<u8> zero_block(nbytes, 0);
pak.file.seekp(0, std::ios::beg);
pak.file.write((char*)zero_block.data(), nbytes);
pak.file.close();
*file_no = free_file_index;
return 0;
}
extern "C" s32 osPfsFindFile(RDRAM_ARG PTR(OSPfs) pfs_, u16 company_code, u32 game_code, u8* game_name, u8* ext_name, PTR(s32) file_no_) {
OSPfs* pfs = TO_PTR(OSPfs, pfs_);
s32* file_no = TO_PTR(s32, file_no_);
for (size_t i = 0; i < MAX_FILES; i++) {
pfs_header_t hdr{};
pfs_header_read(hdr, i);
if ((hdr.company_code == 0) || (hdr.game_code == 0)) {
continue;
} else {
if ((game_code == hdr.game_code) && (company_code == hdr.company_code)) {
for (size_t i = 0; i < ARRLEN(hdr.game_name); i++) {
if (game_name[i] != hdr.game_name[i]) {
break;
}
}
for (size_t i = 0; i < ARRLEN(hdr.ext_name); i++) {
if (ext_name[i] != hdr.ext_name[i]) {
break;
}
}
// File found
*file_no = i;
return 0;
}
}
}
return PFS_ERR_INVALID;
}
extern "C" s32 osPfsDeleteFile(RDRAM_ARG PTR(OSPfs) pfs_, u16 company_code, u32 game_code, u8* game_name, u8* ext_name) {
if (company_code == 0 || game_code == 0) {
return PFS_ERR_INVALID;
}
pfs_state_t pak;
for (int i = 0; i < MAX_FILES; i++) {
pfs_header_t hdr{};
pfs_header_read(hdr, i);
if ((hdr.company_code == 0) || (hdr.game_code == 0)) {
continue;
} else {
if ((game_code == hdr.game_code) && (company_code == hdr.company_code)) {
int gncount = 0;
int encount = 0;
for (size_t i = 0; i < ARRLEN(hdr.game_name); i++) {
if (game_name[i] == hdr.game_name[i]) {
gncount++;
}
}
for (size_t i = 0; i < ARRLEN(hdr.ext_name); i++) {
if (ext_name[i] == hdr.ext_name[i]) {
encount++;
}
}
if ((gncount != 16) || encount != 4) {
continue;
}
// File found
pak.header.open(pfs_header_path(), std::ios::binary | std::ios::in | std::ios::out);
if (!pak.header.good()) {
assert(false);
}
if (!pak.header.is_open()) {
assert(false);
}
u32 seek = i * sizeof(OSPfsState);
// Zero out the header for this file.
std::vector<u8> zero_block(sizeof(OSPfsState), 0);
pak.header.seekp(seek + 0x0, std::ios::beg);
pak.header.write((char*)zero_block.data(), sizeof(OSPfsState));
pak.header.close();
std::filesystem::remove(pfs_file_path(i));
return 0;
}
}
}
return PFS_ERR_INVALID;
}
extern "C" s32 osPfsReadWriteFile(RDRAM_ARG PTR(OSPfs) pfs_, s32 file_no, u8 flag, int offset, int size_in_bytes, u8* data_buffer) {
pfs_state_t pak;
const auto filename = pfs_file_path(file_no);
pak.file.open(filename, std::ios::binary | std::ios::in | std::ios::out);
if (!std::filesystem::exists(filename)) {
return PFS_ERR_INVALID;
}
if (!pak.file.good()) {
return PFS_ERR_INVALID;
}
if (!pak.file.is_open()) {
return PFS_ERR_INVALID;
}
std::vector<u8> swap_buffer(size_in_bytes);
if (flag == 0) {
pak.file.seekg(offset, std::ios::beg);
pak.file.read((char*)swap_buffer.data(), size_in_bytes);
ByteSwapCopy(data_buffer, swap_buffer.data(), size_in_bytes);
} else {
ByteSwapCopy(swap_buffer.data(), data_buffer, size_in_bytes);
pak.file.seekp(offset, std::ios::beg);
pak.file.write((char*)swap_buffer.data(), size_in_bytes);
}
pak.file.close();
return 0;
}
extern "C" s32 osPfsFileState(RDRAM_ARG PTR(OSPfs) pfs_, s32 file_no, PTR(OSPfsState) state_) {
OSPfsState *state = TO_PTR(OSPfsState, state_);
// should pass the state of the requested file_no to the incoming state pointer,
// games call this function 16 times, once per file
// fills the incoming state with the information inside the header of the pak.
const auto filename = pfs_file_path(file_no);
if (!std::filesystem::exists(filename)) {
return PFS_ERR_INVALID;
}
/* Read game info from pak */
pfs_header_t hdr{};
pfs_header_read(hdr, file_no);
state->file_size = hdr.file_size;
state->company_code = hdr.company_code;
state->game_code = hdr.game_code;
for (size_t i = 0; i < ARRLEN(hdr.game_name); i++) {
state->game_name[i] = hdr.game_name[i];
}
for (size_t i = 0; i < ARRLEN(hdr.ext_name); i++) {
state->ext_name[i] = hdr.ext_name[i];
}
return 0;
}
extern "C" s32 osPfsGetLabel(RDRAM_ARG PTR(OSPfs) pfs_, u8* label, PTR(int) len_) {
OSPfs* pfs = TO_PTR(OSPfs, pfs_);
int* len = TO_PTR(int, len_);
if (label == NULL) {
return PFS_ERR_INVALID;
}
// if (__osCheckId(pfs) == PFS_ERR_NEW_PACK) {
// return PFS_ERR_NEW_PACK;
// }
int i;
for (i = 0; i < ARRLEN(pfs->label); i++) {
if (pfs->label[i] == 0) {
break;
}
*label++ = pfs->label[i];
}
*len = i;
return 0;
}
extern "C" s32 osPfsSetLabel(RDRAM_ARG PTR(OSPfs) pfs_, u8* label) {
OSPfs* pfs = TO_PTR(OSPfs, pfs_);
if (label != NULL) {
for (int i = 0; i < ARRLEN(pfs->label); i++) {
if (*label == 0) {
break;
}
pfs->label[i] = *label++;
}
}
return 0;
}
extern "C" s32 osPfsIsPlug(RDRAM_ARG PTR(OSMesgQueue) mq_, u8* pattern) {
u8 bits = 0;
for (int channel = 0; channel < ultramodern::get_max_controllers(); channel++) {
if (__osPfsGetStatus(PASS_RDRAM mq_, channel) == 0) {
bits |= (1 << channel);
}
}
*pattern = bits;
return 0;
}
extern "C" s32 osPfsFreeBlocks(RDRAM_ARG PTR(OSPfs) pfs_, PTR(s32) bytes_not_used_) {
OSPfs *pfs = TO_PTR(OSPfs, pfs_);
s32 *bytes_not_used = TO_PTR(s32, bytes_not_used_);
s32 bytes_used = 0;
for (size_t i = 0; i < MAX_FILES; i++) {
pfs_header_t hdr{};
pfs_header_read(hdr, i);
if ((hdr.company_code != 0) && (hdr.game_code != 0)) {
bytes_used += hdr.file_size >> 8;
}
}
*bytes_not_used = (123 - bytes_used) << 8;
return 0;
}
extern "C" s32 osPfsNumFiles(RDRAM_ARG PTR(OSPfs) pfs_, PTR(s32) max_files_, PTR(s32) files_used_) {
OSPfs *pfs = TO_PTR(OSPfs, pfs_);
s32 *max_files = TO_PTR(s32, max_files_);
s32 *files_used = TO_PTR(s32, files_used_);
u8 num_files = 0;
for (size_t i = 0; i < MAX_FILES; i++) {
pfs_header_t hdr{};
pfs_header_read(hdr, i);
if ((hdr.company_code != 0) && (hdr.game_code != 0)) {
num_files++;
}
}
*max_files = MAX_FILES;
*files_used = num_files;
return 0;
}

49
ultramodern/src/controller_pak.hpp → ultramodern/src/pfs.hpp
View file

@ -2,27 +2,42 @@
#define __ULTRAMODERN_PFS_HPP__ #define __ULTRAMODERN_PFS_HPP__
#include <fstream> #include <fstream>
#include <ultramodern/save.hpp>
typedef struct ControllerPak { typedef struct pfs_state {
std::fstream header; std::fstream header;
std::fstream file; std::fstream file;
} ControllerPak; } pfs_state_t;
typedef struct ControllerPakHdr { typedef struct pfs_header {
int file_size; int file_size;
u32 game_code; u32 game_code;
u16 company_code; u16 company_code;
u8 ext_name[4]; u8 ext_name[4];
u8 game_name[16]; u8 game_name[16];
} ControllerPakHdr; } pfs_header_t;
// extern std::filesystem::path config_path; inline std::filesystem::path pfs_header_path() {
// const std::u8string save_folder = u8"saves"; const auto filename = "controllerpak_header.bin";
// std::filesystem::path save_folder_path = config_path / save_folder; return ultramodern::get_save_base_path() / filename;
}
void Pfs_PakHeader_Write(int file_size, u32 game_code, u16 company_code, const u8* ext_name, const u8* game_name, u8 file_index) { inline std::filesystem::path pfs_file_path(size_t fileno) {
ControllerPak pak; const auto filename = std::format("controllerpak_file_{}.bin", fileno);
pak.header.open("controllerPak_header.sav", std::ios::binary | std::ios::in | std::ios::out); return ultramodern::get_save_base_path() / filename;
}
void pfs_header_alloc() {
pfs_state_t pak;
if (!std::filesystem::exists(pfs_header_path())) {
pak.header.open(pfs_header_path(), std::ios::binary | std::ios::in | std::ios::out | std::ios::trunc);
pak.header.close();
}
}
void pfs_header_write(int file_size, u32 game_code, u16 company_code, const u8* ext_name, const u8* game_name, u8 file_index) {
pfs_state_t pak;
pak.header.open(pfs_header_path(), std::ios::binary | std::ios::out);
if (!pak.header.good()) { if (!pak.header.good()) {
assert(false); assert(false);
@ -53,13 +68,13 @@ void Pfs_PakHeader_Write(int file_size, u32 game_code, u16 company_code, const u
pak.header.close(); pak.header.close();
} }
void Pfs_PakHeader_Write(const ControllerPakHdr& hdr, u8 file_index) { void pfs_header_write(const pfs_header_t& hdr, u8 file_index) {
Pfs_PakHeader_Write(hdr.file_size, hdr.game_code, hdr.company_code, hdr.ext_name, hdr.game_name, file_index); pfs_header_write(hdr.file_size, hdr.game_code, hdr.company_code, hdr.ext_name, hdr.game_name, file_index);
} }
void Pfs_PakHeader_Read(ControllerPakHdr& hdr, u8 file_index) { void pfs_header_read(pfs_header_t& hdr, u8 file_index) {
ControllerPak pak; pfs_state_t pak;
pak.header.open("controllerPak_header.sav", std::ios::binary | std::ios::in | std::ios::out); pak.header.open(pfs_header_path(), std::ios::binary | std::ios::in);
if (!pak.header.good()) { if (!pak.header.good()) {
assert(false); assert(false);
@ -106,8 +121,8 @@ void Pfs_ByteSwapFile(u8* buffer, size_t size) {
} }
} }
void ByteSwapCopy(uint8_t* dst, uint8_t* src, size_t size_bytes) { void ByteSwapCopy(uint8_t* dst, const uint8_t* src, size_t nbytes) {
for (size_t i = 0; i < size_bytes; i++) { for (size_t i = 0; i < nbytes; i++) {
dst[i] = src[i ^ 3]; dst[i] = src[i ^ 3];
} }
} }

11
ultramodern/src/save.cpp
View file

@ -9,6 +9,7 @@
struct { struct {
std::vector<char> save_buffer; std::vector<char> save_buffer;
std::thread saving_thread; std::thread saving_thread;
std::filesystem::path save_base_path;
std::filesystem::path save_file_path; std::filesystem::path save_file_path;
moodycamel::LightweightSemaphore write_sempahore; moodycamel::LightweightSemaphore write_sempahore;
// Used to tell the saving thread that a file swap is pending. // Used to tell the saving thread that a file swap is pending.
@ -54,16 +55,20 @@ bool ultramodern::flashram_allowed() {
save_type == SaveType::AllowAll; save_type == SaveType::AllowAll;
} }
std::filesystem::path ultramodern::get_save_base_path() {
return save_context.save_base_path;
}
std::filesystem::path ultramodern::get_save_file_path() { std::filesystem::path ultramodern::get_save_file_path() {
return save_context.save_file_path; return save_context.save_file_path;
} }
void ultramodern::set_save_file_path(const std::u8string& subfolder, const std::u8string& name) { void ultramodern::set_save_file_path(const std::u8string& subfolder, const std::u8string& name) {
std::filesystem::path save_folder_path = config_path / save_folder; save_context.save_base_path = config_path / save_folder;
if (!subfolder.empty()) { if (!subfolder.empty()) {
save_folder_path = save_folder_path / subfolder; save_context.save_base_path = save_context.save_base_path / subfolder;
} }
save_context.save_file_path = save_folder_path / (name + u8".bin"); save_context.save_file_path = save_context.save_base_path / (name + u8".bin");
} }
void update_save_file() { void update_save_file() {