How to trigger creation of savefile

Question

I'm trying to create a libretro core. It will be a standalone game, so I'm setting RETRO_ENVIRONMENT_SET_SUPPORT_NO_GAME to true. The documentation suggests that retro_get_memory_* can be used to have data saved without needing to explicitly query RETRO_ENVIRONMENT_GET_SAVE_DIRECTORY:

The save directory should be used to store SRAM, memory cards, high scores, etc, if the libretro core cannot use the regular memory interface (retro_get_memory_data()).

How should the core trigger the saving of data using this interface? Or am I misunderstanding the documentation?

I would expect the frontend to call retro_get_memory_{data,size}, read from the exposed buffer when stopping the core, persist the data to disk, and write it back to the exposed buffer the next time the core starts. Instead I observe:

• If I don't provide a content file, the frontend never calls retro_get_memory_{data,size}.
• If I provide a content file (which is unused), the frontend calls retro_get_memory_{data,size} after retro_load_game but doesn't write to disk.

---

Note that this question is about save files (automatically persisted data, usually capturing the player's progress), not save states (snapshots of the game state triggered by the user) which are implemented by the *serialize* methods.

---

Here is a simple example to reproduce the issue (based on this sample):

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "libretro.h"

static unsigned char c = 0;

void* retro_get_memory_data(unsigned id) {
  fprintf(stderr, "retro_get_memory_data(%d)\n", id);
  return (id == RETRO_MEMORY_SAVE_RAM) ? &c : NULL;
}

size_t retro_get_memory_size(unsigned id) {
  fprintf(stderr, "retro_get_memory_size(%d)\n", id);
  return (id == RETRO_MEMORY_SAVE_RAM) ? 1 : 0;
}

#define WIDTH 320
#define HEIGHT 240

static uint32_t* frame_buf;

void retro_init(void) { frame_buf = calloc(WIDTH * HEIGHT, sizeof(uint32_t)); }

void retro_deinit(void) {
  free(frame_buf);
  frame_buf = NULL;
}

unsigned retro_api_version(void) { return RETRO_API_VERSION; }

void retro_get_system_info(struct retro_system_info* info) {
  memset(info, 0, sizeof(*info));
  info->library_name = "SaveTest";
  info->library_version = "v1";
  info->need_fullpath = false;
  info->valid_extensions = NULL;  // Anything is fine, we don't care.
}

static retro_video_refresh_t video_cb;
static retro_environment_t environ_cb;
static retro_input_poll_t input_poll_cb;
static retro_input_state_t input_state_cb;

void retro_set_input_poll(retro_input_poll_t cb) { input_poll_cb = cb; }
void retro_set_input_state(retro_input_state_t cb) { input_state_cb = cb; }
void retro_set_video_refresh(retro_video_refresh_t cb) { video_cb = cb; }
void retro_set_environment(retro_environment_t cb) {
  environ_cb = cb;
  bool no_content = true;
  cb(RETRO_ENVIRONMENT_SET_SUPPORT_NO_GAME, &no_content);
}

void retro_get_system_av_info(struct retro_system_av_info* info) {
  float aspect = (float)WIDTH / HEIGHT;

  info->timing = (struct retro_system_timing){
      .fps = 60.0,
      .sample_rate = 0.0,
  };

  info->geometry = (struct retro_game_geometry){
      .base_width = WIDTH,
      .base_height = HEIGHT,
      .max_width = WIDTH,
      .max_height = HEIGHT,
      .aspect_ratio = aspect,
  };
}

unsigned retro_get_region(void) { return RETRO_REGION_NTSC; }

bool retro_load_game(const struct retro_game_info* info) {
  enum retro_pixel_format fmt = RETRO_PIXEL_FORMAT_XRGB8888;
  if (!environ_cb(RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, &fmt)) {
    fprintf(stderr, "XRGB8888 is not supported.\n");
    return false;
  }
  (void)info;
  return true;
}

bool button(unsigned id) {
  return input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, id);
}

void retro_run(void) {
  input_poll_cb();
  if (button(RETRO_DEVICE_ID_JOYPAD_LEFT) && c > 0) --c;
  if (button(RETRO_DEVICE_ID_JOYPAD_RIGHT) && c < 255) ++c;
  uint32_t color = (255 - c) | (c << 8);
  uint32_t* buf = frame_buf;
  for (unsigned i = WIDTH * HEIGHT; i > 0; --i) {
    *buf = color;
    ++buf;
  }
  video_cb(frame_buf, WIDTH, HEIGHT, WIDTH * sizeof(uint32_t));
}

void retro_unload_game(void) {}

size_t retro_serialize_size(void) { return 1; }
bool retro_serialize(void* data, size_t size) {
  fprintf(stderr, "serialize(%p, %lu) <= %u\n", data, size, c);
  *(char*)data = c;
  return true;
}
bool retro_unserialize(const void* data, size_t size) {
  c = *(char*)data;
  fprintf(stderr, "unserialize(%p, %lu) => %u\n", data, size, c);
  return true;
}

void retro_set_controller_port_device(unsigned port, unsigned device) {}
void retro_set_audio_sample(retro_audio_sample_t cb) {}
void retro_set_audio_sample_batch(retro_audio_sample_batch_t cb) {}
void retro_reset(void) {}
bool retro_load_game_special(unsigned type, const struct retro_game_info* info,
                             size_t num) {
  return false;
}
void retro_cheat_reset(void) {}
void retro_cheat_set(unsigned index, bool enabled, const char* code) {}

Answer 1

It is undocumented but intended that auto save does not trigger for a core without content.

Moreover auto save was not triggering for cores which had content but could support no content. This was unintended and recently fixed.

Reference: https://github.com/libretro/RetroArch/issues/9300