Merge pull request #104 from Provenance-Emu/libretro/feature/save-states

Implement save state support (retro_serialize/retro_unserialize)

Author: JoeMatt

CLAUDE.md

@@ -64,7 +64,6 @@ Core options defined in `libretro_core_options.h` control blitter mode, BIOS usa
 
 ### Known Limitations
 
-- No save state support
 - Blitter not fully cycle-accurate (some games need fast blitter mode)
 - Bus contention between processors not emulated
 - Vertical count (VC) register behavior not fully accurate

libretro.c

@@ -17,6 +17,7 @@
 #include "joystick.h"
 #include "settings.h"
 #include "tom.h"
+#include "state.h"
 
 #define SAMPLERATE 48000
 #define BUFPAL  1920
@@ -776,17 +777,112 @@ void retro_set_controller_port_device(unsigned port, unsigned device)
 
 size_t retro_serialize_size(void)
 {
-   return 0;
+   return STATE_SIZE;
 }
 
 bool retro_serialize(void *data, size_t size)
 {
-   return false;
+   uint8_t *buf, *start;
+   size_t written;
+   uint32_t magic, version, flags, reserved;
+
+   if (!data || size < STATE_SIZE)
+      return false;
+
+   start = (uint8_t *)data;
+   buf   = start;
+
+   /* Header */
+   magic    = STATE_MAGIC;
+   version  = STATE_VERSION;
+   flags    = 0;
+   reserved = 0;
+   STATE_SAVE_VAR(buf, magic);
+   STATE_SAVE_VAR(buf, version);
+   STATE_SAVE_VAR(buf, flags);
+   STATE_SAVE_VAR(buf, reserved);
+
+   /* Large memory blocks */
+   STATE_SAVE_BUF(buf, jaguarMainRAM, 0x200000);  /* 2 MB main RAM */
+   STATE_SAVE_BUF(buf, tomRam8, 0x4000);           /* 16 KB TOM registers */
+
+   extern uint8_t jerry_ram_8[];
+   STATE_SAVE_BUF(buf, jerry_ram_8, 0x10000);      /* 64 KB JERRY registers */
+
+   /* Jaguar misc state */
+   extern bool lowerField;
+   STATE_SAVE_VAR(buf, lowerField);
+
+   /* Module state */
+   buf += M68KStateSave(buf);
+   buf += GPUStateSave(buf);
+   buf += DSPStateSave(buf);
+   buf += BlitterStateSave(buf);
+   buf += EventStateSave(buf);
+   buf += EepromStateSave(buf);
+   buf += JERRYStateSave(buf);
+   buf += TOMStateSave(buf);
+   buf += CDROMStateSave(buf);
+   buf += JoystickStateSave(buf);
+   buf += MTStateSave(buf);
+   buf += DACStateSave(buf);
+
+   written = (size_t)(buf - start);
+   if (written > STATE_SIZE)
+      return false;
+
+   /* Zero-fill remaining bytes for deterministic save states */
+   if (written < STATE_SIZE)
+      memset(buf, 0, STATE_SIZE - written);
+
+   return true;
 }
 
 bool retro_unserialize(const void *data, size_t size)
 {
-   return false;
+   const uint8_t *buf;
+   uint32_t magic, version, flags, reserved;
+
+   if (!data || size < STATE_SIZE)
+      return false;
+
+   buf = (const uint8_t *)data;
+
+   /* Validate header */
+   STATE_LOAD_VAR(buf, magic);
+   STATE_LOAD_VAR(buf, version);
+   STATE_LOAD_VAR(buf, flags);
+   STATE_LOAD_VAR(buf, reserved);
+
+   if (magic != STATE_MAGIC || version != STATE_VERSION)
+      return false;
+
+   /* Large memory blocks */
+   STATE_LOAD_BUF(buf, jaguarMainRAM, 0x200000);
+   STATE_LOAD_BUF(buf, tomRam8, 0x4000);
+
+   extern uint8_t jerry_ram_8[];
+   STATE_LOAD_BUF(buf, jerry_ram_8, 0x10000);
+
+   /* Jaguar misc state */
+   extern bool lowerField;
+   STATE_LOAD_VAR(buf, lowerField);
+
+   /* Module state */
+   buf += M68KStateLoad(buf);
+   buf += GPUStateLoad(buf);
+   buf += DSPStateLoad(buf);
+   buf += BlitterStateLoad(buf);
+   buf += EventStateLoad(buf);
+   buf += EepromStateLoad(buf);
+   buf += JERRYStateLoad(buf);
+   buf += TOMStateLoad(buf);
+   buf += CDROMStateLoad(buf);
+   buf += JoystickStateLoad(buf);
+   buf += MTStateLoad(buf);
+   buf += DACStateLoad(buf);
+
+   return true;
 }
 
 void retro_cheat_reset(void)
@@ -857,6 +953,13 @@ bool retro_load_game(const struct retro_game_info *info)
 
    environ_cb(RETRO_ENVIRONMENT_SET_INPUT_DESCRIPTORS, desc);
 
+   /* Report that save states are deterministic (no quirks).
+    * This enables run-ahead and netplay in RetroArch. */
+   {
+      uint64_t serialization_quirks = 0;
+      environ_cb(RETRO_ENVIRONMENT_SET_SERIALIZATION_QUIRKS, &serialization_quirks);
+   }
+
    if (!environ_cb(RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, &fmt))
    {
       //fprintf(stderr, "Pixel format XRGB8888 not supported by platform, cannot use.\n");

src/blitter.c

@@ -3427,3 +3427,129 @@ Dbinh[7]	:= NAN2 (dbinh\[7], di7t[2], phrase_mode);*/
 }
 
 #endif
+
+
+/* Save state serialization for Blitter */
+
+#include "state.h"
+
+size_t BlitterStateSave(uint8_t *buf)
+{
+   uint8_t *start = buf;
+
+   STATE_SAVE_BUF(buf, blitter_ram, sizeof(blitter_ram));
+   STATE_SAVE_VAR(buf, src);
+   STATE_SAVE_VAR(buf, dst);
+   STATE_SAVE_VAR(buf, misc);
+   STATE_SAVE_VAR(buf, a1ctl);
+   STATE_SAVE_VAR(buf, mode);
+   STATE_SAVE_VAR(buf, ity);
+   STATE_SAVE_VAR(buf, zop);
+   STATE_SAVE_VAR(buf, op);
+   STATE_SAVE_VAR(buf, ctrl);
+   STATE_SAVE_VAR(buf, a1_addr);
+   STATE_SAVE_VAR(buf, a2_addr);
+   STATE_SAVE_VAR(buf, a1_zoffs);
+   STATE_SAVE_VAR(buf, a2_zoffs);
+   STATE_SAVE_VAR(buf, xadd_a1_control);
+   STATE_SAVE_VAR(buf, xadd_a2_control);
+   STATE_SAVE_VAR(buf, a1_pitch);
+   STATE_SAVE_VAR(buf, a2_pitch);
+   STATE_SAVE_VAR(buf, n_pixels);
+   STATE_SAVE_VAR(buf, n_lines);
+   STATE_SAVE_VAR(buf, a1_x);
+   STATE_SAVE_VAR(buf, a1_y);
+   STATE_SAVE_VAR(buf, a1_width);
+   STATE_SAVE_VAR(buf, a2_x);
+   STATE_SAVE_VAR(buf, a2_y);
+   STATE_SAVE_VAR(buf, a2_width);
+   STATE_SAVE_VAR(buf, a2_mask_x);
+   STATE_SAVE_VAR(buf, a2_mask_y);
+   STATE_SAVE_VAR(buf, a1_xadd);
+   STATE_SAVE_VAR(buf, a1_yadd);
+   STATE_SAVE_VAR(buf, a2_xadd);
+   STATE_SAVE_VAR(buf, a2_yadd);
+   STATE_SAVE_VAR(buf, a1_phrase_mode);
+   STATE_SAVE_VAR(buf, a2_phrase_mode);
+   STATE_SAVE_VAR(buf, a1_step_x);
+   STATE_SAVE_VAR(buf, a1_step_y);
+   STATE_SAVE_VAR(buf, a2_step_x);
+   STATE_SAVE_VAR(buf, a2_step_y);
+   STATE_SAVE_VAR(buf, outer_loop);
+   STATE_SAVE_VAR(buf, inner_loop);
+   STATE_SAVE_VAR(buf, a2_psize);
+   STATE_SAVE_VAR(buf, a1_psize);
+   STATE_SAVE_VAR(buf, gouraud_add);
+   STATE_SAVE_BUF(buf, gd_i, sizeof(gd_i));
+   STATE_SAVE_BUF(buf, gd_c, sizeof(gd_c));
+   STATE_SAVE_VAR(buf, gd_ia);
+   STATE_SAVE_VAR(buf, gd_ca);
+   STATE_SAVE_VAR(buf, colour_index);
+   STATE_SAVE_VAR(buf, zadd);
+   STATE_SAVE_BUF(buf, z_i, sizeof(z_i));
+   STATE_SAVE_VAR(buf, a1_clip_x);
+   STATE_SAVE_VAR(buf, a1_clip_y);
+
+   return (size_t)(buf - start);
+}
+
+
+size_t BlitterStateLoad(const uint8_t *buf)
+{
+   const uint8_t *start = buf;
+
+   STATE_LOAD_BUF(buf, blitter_ram, sizeof(blitter_ram));
+   STATE_LOAD_VAR(buf, src);
+   STATE_LOAD_VAR(buf, dst);
+   STATE_LOAD_VAR(buf, misc);
+   STATE_LOAD_VAR(buf, a1ctl);
+   STATE_LOAD_VAR(buf, mode);
+   STATE_LOAD_VAR(buf, ity);
+   STATE_LOAD_VAR(buf, zop);
+   STATE_LOAD_VAR(buf, op);
+   STATE_LOAD_VAR(buf, ctrl);
+   STATE_LOAD_VAR(buf, a1_addr);
+   STATE_LOAD_VAR(buf, a2_addr);
+   STATE_LOAD_VAR(buf, a1_zoffs);
+   STATE_LOAD_VAR(buf, a2_zoffs);
+   STATE_LOAD_VAR(buf, xadd_a1_control);
+   STATE_LOAD_VAR(buf, xadd_a2_control);
+   STATE_LOAD_VAR(buf, a1_pitch);
+   STATE_LOAD_VAR(buf, a2_pitch);
+   STATE_LOAD_VAR(buf, n_pixels);
+   STATE_LOAD_VAR(buf, n_lines);
+   STATE_LOAD_VAR(buf, a1_x);
+   STATE_LOAD_VAR(buf, a1_y);
+   STATE_LOAD_VAR(buf, a1_width);
+   STATE_LOAD_VAR(buf, a2_x);
+   STATE_LOAD_VAR(buf, a2_y);
+   STATE_LOAD_VAR(buf, a2_width);
+   STATE_LOAD_VAR(buf, a2_mask_x);
+   STATE_LOAD_VAR(buf, a2_mask_y);
+   STATE_LOAD_VAR(buf, a1_xadd);
+   STATE_LOAD_VAR(buf, a1_yadd);
+   STATE_LOAD_VAR(buf, a2_xadd);
+   STATE_LOAD_VAR(buf, a2_yadd);
+   STATE_LOAD_VAR(buf, a1_phrase_mode);
+   STATE_LOAD_VAR(buf, a2_phrase_mode);
+   STATE_LOAD_VAR(buf, a1_step_x);
+   STATE_LOAD_VAR(buf, a1_step_y);
+   STATE_LOAD_VAR(buf, a2_step_x);
+   STATE_LOAD_VAR(buf, a2_step_y);
+   STATE_LOAD_VAR(buf, outer_loop);
+   STATE_LOAD_VAR(buf, inner_loop);
+   STATE_LOAD_VAR(buf, a2_psize);
+   STATE_LOAD_VAR(buf, a1_psize);
+   STATE_LOAD_VAR(buf, gouraud_add);
+   STATE_LOAD_BUF(buf, gd_i, sizeof(gd_i));
+   STATE_LOAD_BUF(buf, gd_c, sizeof(gd_c));
+   STATE_LOAD_VAR(buf, gd_ia);
+   STATE_LOAD_VAR(buf, gd_ca);
+   STATE_LOAD_VAR(buf, colour_index);
+   STATE_LOAD_VAR(buf, zadd);
+   STATE_LOAD_BUF(buf, z_i, sizeof(z_i));
+   STATE_LOAD_VAR(buf, a1_clip_x);
+   STATE_LOAD_VAR(buf, a1_clip_y);
+
+   return (size_t)(buf - start);
+}

src/cdrom.c

@@ -1121,3 +1121,66 @@ storew	TEMP,(r24)
 
    */
 
+#include "state.h"
+
+size_t CDROMStateSave(uint8_t *buf)
+{
+	uint8_t *start = buf;
+
+	STATE_SAVE_BUF(buf, cdRam, sizeof(cdRam));
+	STATE_SAVE_VAR(buf, cdCmd);
+	STATE_SAVE_VAR(buf, cdPtr);
+	STATE_SAVE_VAR(buf, haveCDGoodness);
+	STATE_SAVE_VAR(buf, min);
+	STATE_SAVE_VAR(buf, sec);
+	STATE_SAVE_VAR(buf, frm);
+	STATE_SAVE_VAR(buf, block);
+	STATE_SAVE_BUF(buf, cdBuf, sizeof(cdBuf));
+	STATE_SAVE_VAR(buf, cdBufPtr);
+	STATE_SAVE_VAR(buf, trackNum);
+	STATE_SAVE_VAR(buf, minTrack);
+	STATE_SAVE_VAR(buf, maxTrack);
+	STATE_SAVE_VAR(buf, currentState);
+	STATE_SAVE_VAR(buf, counter);
+	STATE_SAVE_VAR(buf, cmdTx);
+	STATE_SAVE_VAR(buf, busCmd);
+	STATE_SAVE_VAR(buf, rxData);
+	STATE_SAVE_VAR(buf, txData);
+	STATE_SAVE_VAR(buf, rxDataBit);
+	STATE_SAVE_VAR(buf, firstTime);
+	STATE_SAVE_BUF(buf, cdBuf2, sizeof(cdBuf2));
+	STATE_SAVE_BUF(buf, cdBuf3, sizeof(cdBuf3));
+
+	return (size_t)(buf - start);
+}
+
+size_t CDROMStateLoad(const uint8_t *buf)
+{
+	const uint8_t *start = buf;
+
+	STATE_LOAD_BUF(buf, cdRam, sizeof(cdRam));
+	STATE_LOAD_VAR(buf, cdCmd);
+	STATE_LOAD_VAR(buf, cdPtr);
+	STATE_LOAD_VAR(buf, haveCDGoodness);
+	STATE_LOAD_VAR(buf, min);
+	STATE_LOAD_VAR(buf, sec);
+	STATE_LOAD_VAR(buf, frm);
+	STATE_LOAD_VAR(buf, block);
+	STATE_LOAD_BUF(buf, cdBuf, sizeof(cdBuf));
+	STATE_LOAD_VAR(buf, cdBufPtr);
+	STATE_LOAD_VAR(buf, trackNum);
+	STATE_LOAD_VAR(buf, minTrack);
+	STATE_LOAD_VAR(buf, maxTrack);
+	STATE_LOAD_VAR(buf, currentState);
+	STATE_LOAD_VAR(buf, counter);
+	STATE_LOAD_VAR(buf, cmdTx);
+	STATE_LOAD_VAR(buf, busCmd);
+	STATE_LOAD_VAR(buf, rxData);
+	STATE_LOAD_VAR(buf, txData);
+	STATE_LOAD_VAR(buf, rxDataBit);
+	STATE_LOAD_VAR(buf, firstTime);
+	STATE_LOAD_BUF(buf, cdBuf2, sizeof(cdBuf2));
+	STATE_LOAD_BUF(buf, cdBuf3, sizeof(cdBuf3));
+
+	return (size_t)(buf - start);
+}

src/dac.c

@@ -213,3 +213,27 @@ uint16_t DACReadWord(uint32_t offset, uint32_t who)
 
    return 0xFFFF;	// May need SSTAT as well... (but may be a Jaguar II only feature)
 }
+
+#include "state.h"
+
+size_t DACStateSave(uint8_t *buf)
+{
+	uint8_t *start = buf;
+
+	STATE_SAVE_VAR(buf, bufferIndex);
+	STATE_SAVE_VAR(buf, numberOfSamples);
+	STATE_SAVE_VAR(buf, bufferDone);
+
+	return (size_t)(buf - start);
+}
+
+size_t DACStateLoad(const uint8_t *buf)
+{
+	const uint8_t *start = buf;
+
+	STATE_LOAD_VAR(buf, bufferIndex);
+	STATE_LOAD_VAR(buf, numberOfSamples);
+	STATE_LOAD_VAR(buf, bufferDone);
+
+	return (size_t)(buf - start);
+}