Use libretro SRAM interface for save data persistence

Remove core-managed file I/O from eeprom.c and memtrack.c. Save data
is now persisted entirely by the frontend via retro_get_memory_data()
and retro_get_memory_size() using RETRO_MEMORY_SAVE_RAM.

This fixes save files going to the wrong directory (issue #8) by
letting the frontend control the save path and filename (.srm).

Save buffer layout:
- Regular carts: 256 bytes (128 cart EEPROM + 128 CDROM EEPROM),
  stored big-endian for cross-platform compatibility
- Memory Track cart (CRC 0xFDF37F47): 128K raw NVRAM

Changes:
- eeprom.c: Remove file I/O, expose cdromEEPROM for packing
- memtrack.c: Remove file I/O, MTInit/MTDone are now no-ops
- libretro.c: Add endian-safe pack/unpack for EEPROM save buffer,
  return correct buffer and size for Memory Track vs regular carts,
  unpack frontend-loaded save data on first retro_run()
- settings.h: Remove unused EEPROMPath and romName fields

Fixes #8.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Author: JoeMatt

libretro.c

@@ -30,7 +30,21 @@ uint32_t *videoBuffer        = NULL;
 int game_width               = 0;
 int game_height              = 0;
 
-extern uint16_t eeprom_ram[];
+extern uint16_t eeprom_ram[64];
+extern uint16_t cdromEEPROM[64];
+extern uint8_t mtMem[0x20000];
+extern uint32_t jaguarMainROMCRC32;
+
+/* Combined save buffer for RETRO_MEMORY_SAVE_RAM.
+ * Layout: [cart EEPROM 128 bytes][CDROM EEPROM 128 bytes]
+ * For Memory Track cart (CRC 0xFDF37F47): mtMem is used directly (128K).
+ *
+ * EEPROM data is stored big-endian on disk (high byte first per 16-bit word)
+ * to match the Jaguar's native byte order. This is handled by pack/unpack
+ * functions so the in-memory uint16_t arrays work on any host. */
+#define EEPROM_SAVE_SIZE 256  /* 128 bytes cart + 128 bytes CDROM */
+#define MT_SAVE_SIZE     0x20000  /* 128K Memory Track */
+static uint8_t eeprom_save_buf[EEPROM_SAVE_SIZE];
 
 static retro_video_refresh_t video_cb;
 static retro_input_poll_t input_poll_cb;
@@ -39,6 +53,7 @@ static retro_environment_t environ_cb;
 retro_audio_sample_batch_t audio_batch_cb;
 
 static bool libretro_supports_bitmasks = false;
+static bool save_data_needs_unpack = false;
 
 void retro_set_video_refresh(retro_video_refresh_t cb) { video_cb = cb; }
 void retro_set_audio_sample(retro_audio_sample_t cb) { (void)cb; }
@@ -719,25 +734,7 @@ static void update_input(void)
    }
 }
 
-static void extract_basename(char *buf, const char *path, size_t size)
-{
-   char       *ext  = NULL;
-   const char *base = strrchr(path, '/');
-   if (!base)
-      base = strrchr(path, '\\');
-   if (!base)
-      base = path;
-
-   if (*base == '\\' || *base == '/')
-      base++;
-
-   strncpy(buf, base, size - 1);
-   buf[size - 1] = '\0';
-
-   ext = strrchr(buf, '.');
-   if (ext)
-      *ext = '\0';
-}
+
 
 /************************************
  * libretro implementation
@@ -897,9 +894,7 @@ void retro_cheat_set(unsigned index, bool enabled, const char *code)
 
 bool retro_load_game(const struct retro_game_info *info)
 {
-   char slash;
    unsigned i;
-   const char *save_dir = NULL;
    enum retro_pixel_format fmt = RETRO_PIXEL_FORMAT_XRGB8888;
 
    struct retro_input_descriptor desc[] = {
@@ -981,32 +976,6 @@ bool retro_load_game(const struct retro_game_info *info)
 
    check_variables();
 
-   // Get eeprom path info
-   // > Handle Windows nonsense...
-#if defined(_WIN32)
-   slash = '\\';
-#else
-   slash = '/';
-#endif
-   // > Get save path
-   vjs.EEPROMPath[0] = '\0';
-   if (environ_cb(RETRO_ENVIRONMENT_GET_SAVE_DIRECTORY, &save_dir) && save_dir)
-   {
-      if (strlen(save_dir) > 0)
-      {
-         sprintf(vjs.EEPROMPath, "%s%c", save_dir, slash);
-      }
-   }
-   // > Get ROM name
-   if (info->path != NULL)
-   {
-      extract_basename(vjs.romName, info->path, sizeof(vjs.romName));
-   }
-   else
-   {
-      vjs.romName[0] = '\0';
-   }
-
    JaguarInit();                                             // set up hardware
    memcpy(jagMemSpace + 0xE00000,
          ((vjs.biosType == BT_K_SERIES) ? jaguarBootROM : jaguarBootROM2),
@@ -1023,6 +992,11 @@ bool retro_load_game(const struct retro_game_info *info)
    JaguarLoadFile((uint8_t*)info->data, info->size);
    JaguarReset();
 
+   /* The frontend will load .srm data into our save buffer (returned by
+    * retro_get_memory_data) after this function returns but before the
+    * first retro_run(). We unpack it on the first frame. */
+   save_data_needs_unpack = true;
+
    return true;
 }
 
@@ -1055,22 +1029,63 @@ unsigned retro_api_version(void)
    return RETRO_API_VERSION;
 }
 
+/* Pack EEPROM uint16_t arrays into the save buffer (big-endian).
+ * Called before the frontend reads save data. */
+static void eeprom_pack_save_buf(void)
+{
+   unsigned i;
+   for (i = 0; i < 64; i++)
+   {
+      eeprom_save_buf[(i * 2) + 0] = eeprom_ram[i] >> 8;
+      eeprom_save_buf[(i * 2) + 1] = eeprom_ram[i] & 0xFF;
+   }
+   for (i = 0; i < 64; i++)
+   {
+      eeprom_save_buf[128 + (i * 2) + 0] = cdromEEPROM[i] >> 8;
+      eeprom_save_buf[128 + (i * 2) + 1] = cdromEEPROM[i] & 0xFF;
+   }
+}
+
+/* Unpack the save buffer back into EEPROM uint16_t arrays.
+ * Called after the frontend loads save data. */
+static void eeprom_unpack_save_buf(void)
+{
+   unsigned i;
+   for (i = 0; i < 64; i++)
+      eeprom_ram[i] = ((uint16_t)eeprom_save_buf[(i * 2) + 0] << 8)
+                    | eeprom_save_buf[(i * 2) + 1];
+   for (i = 0; i < 64; i++)
+      cdromEEPROM[i] = ((uint16_t)eeprom_save_buf[128 + (i * 2) + 0] << 8)
+                      | eeprom_save_buf[128 + (i * 2) + 1];
+}
+
 void *retro_get_memory_data(unsigned type)
 {
-   if(type == RETRO_MEMORY_SYSTEM_RAM)
+   if (type == RETRO_MEMORY_SYSTEM_RAM)
       return jaguarMainRAM;
-   else if (type == RETRO_MEMORY_SAVE_RAM)
-      return eeprom_ram;
-   else return NULL;
+   if (type == RETRO_MEMORY_SAVE_RAM)
+   {
+      /* Memory Track cart uses 128K NVRAM directly */
+      if (jaguarMainROMCRC32 == 0xFDF37F47)
+         return mtMem;
+      /* Regular carts: pack EEPROM into endian-safe buffer */
+      eeprom_pack_save_buf();
+      return eeprom_save_buf;
+   }
+   return NULL;
 }
 
 size_t retro_get_memory_size(unsigned type)
 {
-   if(type == RETRO_MEMORY_SYSTEM_RAM)
+   if (type == RETRO_MEMORY_SYSTEM_RAM)
       return 0x200000;
-   else if (type == RETRO_MEMORY_SAVE_RAM)
-      return 128;
-   else return 0;
+   if (type == RETRO_MEMORY_SAVE_RAM)
+   {
+      if (jaguarMainROMCRC32 == 0xFDF37F47)
+         return MT_SAVE_SIZE;
+      return EEPROM_SAVE_SIZE;
+   }
+   return 0;
 }
 
 void retro_init(void)
@@ -1097,6 +1112,16 @@ void retro_run(void)
 {
    bool updated = false;
 
+   /* On the first frame, unpack save data that the frontend loaded
+    * into our RETRO_MEMORY_SAVE_RAM buffer after retro_load_game(). */
+   if (save_data_needs_unpack)
+   {
+      save_data_needs_unpack = false;
+      if (jaguarMainROMCRC32 != 0xFDF37F47)
+         eeprom_unpack_save_buf();
+      /* Memory Track: mtMem was written directly, no unpack needed. */
+   }
+
    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE, &updated) && updated)
       check_variables();
 

src/eeprom.c

@@ -18,52 +18,15 @@
 #include <stdlib.h>
 #include <string.h>								// For memset
 
-#include <streams/file_stream.h>
-#include "settings.h"
-
-extern uint32_t jaguarMainROMCRC32;
-
 uint16_t eeprom_ram[64];
-static uint16_t cdromEEPROM[64];
+uint16_t cdromEEPROM[64];
 
 // Private function prototypes
-RFILE* rfopen(const char *path, const char *mode);
-int rfclose(RFILE* stream);
-int64_t rfwrite(void const* buffer,
-   size_t elem_size, size_t elem_count, RFILE* stream);
-int64_t rfread(void* buffer,
-   size_t elem_size, size_t elem_count, RFILE* stream);
-
 static void EEPROMSave(void);
 static void eeprom_set_di(uint32_t state);
 static void eeprom_set_cs(uint32_t state);
 static uint32_t eeprom_get_do(void);
 
-static void WriteEEPROMToFile(RFILE * file, uint16_t * ram)
-{
-   unsigned i;
-   uint8_t buffer[128];
-
-   for(i = 0; i < 64; i++)
-   {
-      buffer[(i * 2) + 0] = ram[i] >> 8;
-      buffer[(i * 2) + 1] = ram[i] & 0xFF;
-   }
-
-   rfwrite(buffer, 1, 128, file);
-}
-
-// Read/write EEPROM files to disk in an endian safe manner
-static void ReadEEPROMFromFile(RFILE *file, uint16_t * ram)
-{
-   unsigned i;
-   uint8_t buffer[128];
-   size_t ignored = rfread(buffer, 1, 128, file);
-
-   for(i = 0; i < 64; i++)
-      ram[i] = (buffer[(i * 2) + 0] << 8) | buffer[(i * 2) + 1];
-}
-
 enum { EE_STATE_START = 1, EE_STATE_OP_A, EE_STATE_OP_B, EE_STATE_0, EE_STATE_1,
 	EE_STATE_2, EE_STATE_3, EE_STATE_0_0, EE_READ_ADDRESS, EE_STATE_0_0_0,
 	EE_STATE_0_0_1, EE_STATE_0_0_2, EE_STATE_0_0_3, EE_STATE_0_0_1_0, EE_READ_DATA,
@@ -81,62 +44,21 @@ static uint16_t jerry_ee_data_cnt = 16;
 static uint16_t jerry_writes_enabled = 0;
 static uint16_t jerry_ee_direct_jump = 0;
 
-static char eeprom_filename[MAX_PATH];
-static char cdromEEPROMFilename[MAX_PATH];
-static bool haveEEPROM = false;
-static bool haveCDROMEEPROM = false;
-
 
 void EepromInit(void)
 {
-   RFILE * fp;
-
-   /* No need for EEPROM for the Memory Track device */
-   if (jaguarMainROMCRC32 == 0xFDF37F47)
-      return;
-   
-   /* Get EEPROM file names */
-	if (strlen(vjs.romName) > 0)
-	{
-		sprintf(eeprom_filename, "%s%s.srm", vjs.EEPROMPath, vjs.romName);
-		sprintf(cdromEEPROMFilename, "%s%s.cdrom.srm", vjs.EEPROMPath, vjs.romName);
-	}
-	else
-	{
-		// Use old CRC fallback...
-		sprintf(eeprom_filename, "%s%08X.srm", vjs.EEPROMPath, (unsigned int)jaguarMainROMCRC32);
-		sprintf(cdromEEPROMFilename, "%s%08X.cdrom.srm", vjs.EEPROMPath, (unsigned int)jaguarMainROMCRC32);
-	}
-
-	/* Handle regular cartridge EEPROM */
-	fp = rfopen(eeprom_filename, "rb");
-
-	if (fp)
-	{
-		ReadEEPROMFromFile(fp, eeprom_ram);
-		rfclose(fp);
-		haveEEPROM = true;
-	}
-
-	// Handle JagCD EEPROM
-	fp = rfopen(cdromEEPROMFilename, "rb");
-
-	if (fp)
-	{
-		ReadEEPROMFromFile(fp, cdromEEPROM);
-		rfclose(fp);
-		haveCDROMEEPROM = true;
-	}
+   /* EEPROM data is now loaded/saved by the frontend via
+    * retro_get_memory_data(RETRO_MEMORY_SAVE_RAM). No file I/O here. */
 }
 
 
 void EepromReset(void)
 {
-	if (!haveEEPROM)
-		memset(eeprom_ram, 0xFF, 64 * sizeof(uint16_t));
-
-	if (!haveCDROMEEPROM)
-		memset(cdromEEPROM, 0xFF, 64 * sizeof(uint16_t));
+   /* Fill with 0xFF (blank EEPROM state). If the frontend has
+    * previously saved data, it will overwrite this via the
+    * RETRO_MEMORY_SAVE_RAM interface before the first frame. */
+   memset(eeprom_ram, 0xFF, 64 * sizeof(uint16_t));
+   memset(cdromEEPROM, 0xFF, 64 * sizeof(uint16_t));
 }
 
 
@@ -147,23 +69,7 @@ void EepromDone(void)
 
 static void EEPROMSave(void)
 {
-	// Write out regular cartridge EEPROM data
-	RFILE * fp = rfopen(eeprom_filename, "wb");
-
-	if (fp)
-	{
-		WriteEEPROMToFile(fp, eeprom_ram);
-		rfclose(fp);
-	}
-
-	// Write out JagCD EEPROM data
-	fp = rfopen(cdromEEPROMFilename, "wb");
-
-	if (fp)
-	{
-		WriteEEPROMToFile(fp, cdromEEPROM);
-		rfclose(fp);
-	}
+   /* No-op: the frontend persists SRAM via retro_get_memory_data. */
 }