SDL_libretro_core.h

Go to the documentation of this file.

 
#if defined(SDL_LIBRETRO_IMPLEMENTATION) && !defined(SDL_LIBRETRO_CORE_IMPL_ONCE)
#define SDL_LIBRETRO_CORE_IMPL_ONCE
 
#ifndef SDL_LIBRETRO_GET_TICKS_NS
#define SDL_LIBRETRO_GET_TICKS_NS() SDL_GetTicksNS()
#endif
 
static void SDL_Libretro_ResetPortDevices(SDL_Libretro* lr) {
    for (unsigned i = 0; i < SDL_LIBRETRO_MAX_USERS; i++) {
        lr->core.portDeviceMap[i] = RETRO_DEVICE_JOYPAD;
    }
}
 
#define LOAD_SYM(sym)                                                             \
    do {                                                                          \
        SDL_FunctionPointer fp = SDL_LoadFunction(lr->core.symbols.handle, #sym); \
        SDL_memcpy(&lr->core.symbols.sym, &fp, sizeof(fp));                       \
        if (!fp) {                                                                \
            SDL_SetError("[SDL_Libretro] Failed to load symbol '%s'", #sym);      \
            SDL_UnloadObject(lr->core.symbols.handle);                            \
            SDL_memset(&lr->core, 0, sizeof(lr->core));                           \
            SDL_Libretro_ResetPortDevices(lr);                                    \
            return false;                                                         \
        }                                                                         \
    } while (0)
 
static void SDL_Libretro_ReserveEvents(void) {
    static SDL_AtomicInt reserved;
    if (!SDL_CompareAndSwapAtomicInt(&reserved, 0, 1)) {
        return;
    }
 
    // Probe where SDL's next user event sits, then claim up to the end of
    // the range in one block.
    const Uint32 next = SDL_RegisterEvents(1);
    if (next == 0 || next >= SDL_EVENT_LIBRETRO) {
        SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "[SDL_Libretro] Registered user events reach the SDL_EVENT_LIBRETRO range (0x%x-0x%x); they may collide", (unsigned)SDL_EVENT_LIBRETRO, (unsigned)SDL_EVENT_LIBRETRO_LAST);
        return;
    }
    const int count = (int)(SDL_EVENT_LIBRETRO_LAST - next);
    const Uint32 base = SDL_RegisterEvents(count);
    if (base == 0 || base > SDL_EVENT_LIBRETRO) {
        SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "[SDL_Libretro] Failed to reserve the SDL_EVENT_LIBRETRO range (0x%x-0x%x); registered user events may collide", (unsigned)SDL_EVENT_LIBRETRO, (unsigned)SDL_EVENT_LIBRETRO_LAST);
    }
}
 
SDL_Libretro* SDL_Libretro_Create(void) {
    SDL_Libretro* lr = (SDL_Libretro*)SDL_calloc(1, sizeof(SDL_Libretro));
    if (!lr) {
        SDL_SetError("[SDL_Libretro] Failed to allocate context");
        return NULL;
    }
 
    SDL_Libretro_ReserveEvents();
 
    // Initial state (the calloc above already zeroed the struct).
    lr->rewindMaxBytes = SDL_LIBRETRO_REWIND_DEFAULT_MAX_BYTES;
    SDL_Libretro_ResetPortDevices(lr);
    SDL_Libretro_SetVFS(lr, NULL);
    SDL_Libretro_SetVolume(lr, 1.0f);
    SDL_Libretro_SetSpeed(lr, 1.0f);
    SDL_Libretro_SetUsername(lr, "SDL_libretro");
    SDL_Libretro_SetLanguage(lr, -1);
 
    // Keyboard Mappings
    lr->keyboardPlayer1[RETRO_DEVICE_ID_JOYPAD_B] = SDL_SCANCODE_Z;
    lr->keyboardPlayer1[RETRO_DEVICE_ID_JOYPAD_Y] = SDL_SCANCODE_A;
    lr->keyboardPlayer1[RETRO_DEVICE_ID_JOYPAD_SELECT] = SDL_SCANCODE_RSHIFT;
    lr->keyboardPlayer1[RETRO_DEVICE_ID_JOYPAD_START] = SDL_SCANCODE_RETURN;
    lr->keyboardPlayer1[RETRO_DEVICE_ID_JOYPAD_UP] = SDL_SCANCODE_UP;
    lr->keyboardPlayer1[RETRO_DEVICE_ID_JOYPAD_DOWN] = SDL_SCANCODE_DOWN;
    lr->keyboardPlayer1[RETRO_DEVICE_ID_JOYPAD_LEFT] = SDL_SCANCODE_LEFT;
    lr->keyboardPlayer1[RETRO_DEVICE_ID_JOYPAD_RIGHT] = SDL_SCANCODE_RIGHT;
    lr->keyboardPlayer1[RETRO_DEVICE_ID_JOYPAD_A] = SDL_SCANCODE_X;
    lr->keyboardPlayer1[RETRO_DEVICE_ID_JOYPAD_X] = SDL_SCANCODE_S;
    lr->keyboardPlayer1[RETRO_DEVICE_ID_JOYPAD_L] = SDL_SCANCODE_Q;
    lr->keyboardPlayer1[RETRO_DEVICE_ID_JOYPAD_R] = SDL_SCANCODE_W;
    lr->keyboardPlayer1[RETRO_DEVICE_ID_JOYPAD_L2] = SDL_SCANCODE_E;
    lr->keyboardPlayer1[RETRO_DEVICE_ID_JOYPAD_R2] = SDL_SCANCODE_R;
    lr->keyboardPlayer1[RETRO_DEVICE_ID_JOYPAD_L3] = SDL_SCANCODE_D;
    lr->keyboardPlayer1[RETRO_DEVICE_ID_JOYPAD_R3] = SDL_SCANCODE_F;
 
    // Gamepad Mappings; analogToDigital stays zeroed (None) from the calloc.
    for (unsigned port = 0; port < SDL_LIBRETRO_MAX_USERS; port++) {
        SDL_memcpy(lr->gamepadButtons[port], SDL_Libretro_DefaultGamepadButtons, sizeof(lr->gamepadButtons[port]));
    }
 
    return lr;
}
 
void SDL_Libretro_Destroy(SDL_Libretro* lr) {
    if (!lr) return;
 
    SDL_Libretro_UnloadGame(lr);
    SDL_Libretro_UnloadCore(lr);
 
    // Tear down PhysFS if it was initialized.
    SDL_Libretro_PhysFS_Quit(lr);
 
    for (unsigned i = 0; i < SDL_LIBRETRO_MAX_USERS; i++) {
        if (lr->gamepads[i]) {
            SDL_CloseGamepad(lr->gamepads[i]);
            lr->gamepads[i] = NULL;
        }
    }
 
    SDL_Libretro_FreeCoreLibrary(lr);
    SDL_Libretro_FreeMessages(lr);
    SDL_Libretro_CloseConfig(lr);
 
    // Queued SDL_libretro events (including the unloads pushed above) carry
    // pointers into this context; drop them before it goes away.
    SDL_FlushEvents(SDL_EVENT_LIBRETRO, SDL_EVENT_LIBRETRO_LAST);
 
    SDL_free(lr);
}
 
static const char* SDL_Libretro_GetCorePathFromName(const SDL_Libretro* lr, const char* coreName) {
    if (!lr || !coreName || !lr->coreLibrary || SDL_strrchr(coreName, '.') != NULL) {
        return NULL;
    }
    for (unsigned i = 0; i < lr->coreLibraryCount; i++) {
        if (lr->coreLibrary[i].corename && SDL_strcasecmp(lr->coreLibrary[i].corename, coreName) == 0) {
            return lr->coreLibrary[i].path;
        }
    }
    return NULL;
}
 
bool SDL_Libretro_LoadCore(SDL_Libretro* lr, const char* core) {
    if (!lr || !core) {
        SDL_SetError("[SDL_Libretro] Invalid arguments");
        return false;
    }
 
    if (SDL_Libretro_active && SDL_Libretro_active != lr) {
        SDL_SetError("[SDL_Libretro] Another context already has a core loaded");
        return false;
    }
 
    // Make sure the old core is unloaded.
    SDL_Libretro_UnloadCore(lr);
 
    // Ensure the Saves and System directories exist, since the core may need them.
    if (lr->saveDirectory[0] != '\0') {
        SDL_CreateDirectory(lr->saveDirectory);
    }
    if (lr->systemDirectory[0] != '\0') {
        SDL_CreateDirectory(lr->systemDirectory);
    }
 
    // If the corePath is just a name, see if it lives in the loaded coreLibrary.
    const char* path = SDL_Libretro_GetCorePathFromName(lr, core);
    if (path) {
        core = path;
    }
 
    // Load the core handle.
    lr->core.symbols.handle = SDL_LoadObject(core);
    if (!lr->core.symbols.handle) {
        SDL_SetError("[SDL_Libretro] Failed to load core '%s': %s", core, SDL_GetError());
        return false;
    }
 
    // Verify core API version.
    LOAD_SYM(retro_api_version);
    lr->core.apiVersion = lr->core.symbols.retro_api_version();
    if (lr->core.apiVersion != 1) {
        SDL_UnloadObject(lr->core.symbols.handle);
        SDL_SetError("[SDL_Libretro] Unsupported Core API Version: %d", (int)lr->core.apiVersion);
        SDL_memset(&lr->core, 0, sizeof(lr->core));
        SDL_Libretro_ResetPortDevices(lr);
        return false;
    }
 
    LOAD_SYM(retro_init);
    LOAD_SYM(retro_deinit);
    LOAD_SYM(retro_set_environment);
    LOAD_SYM(retro_set_video_refresh);
    LOAD_SYM(retro_set_audio_sample);
    LOAD_SYM(retro_set_audio_sample_batch);
    LOAD_SYM(retro_set_input_poll);
    LOAD_SYM(retro_set_input_state);
    LOAD_SYM(retro_get_system_info);
    LOAD_SYM(retro_get_system_av_info);
    LOAD_SYM(retro_set_controller_port_device);
    LOAD_SYM(retro_reset);
    LOAD_SYM(retro_run);
    LOAD_SYM(retro_serialize_size);
    LOAD_SYM(retro_serialize);
    LOAD_SYM(retro_unserialize);
    LOAD_SYM(retro_cheat_reset);
    LOAD_SYM(retro_cheat_set);
    LOAD_SYM(retro_load_game);
    LOAD_SYM(retro_load_game_special);
    LOAD_SYM(retro_unload_game);
    LOAD_SYM(retro_get_region);
    LOAD_SYM(retro_get_memory_data);
    LOAD_SYM(retro_get_memory_size);
 
    SDL_strlcpy(lr->core.corePath, core, sizeof(lr->core.corePath));
 
    // Default to normal speed for the freshly loaded core (lr->core was zeroed
    // above, so speed does not carry over from a previously loaded core).
    lr->core.speed = 1.0f;
 
    SDL_Libretro_active = lr;
 
    // Tell the core that we should call our own enviornment callback.
    lr->core.symbols.retro_set_environment(SDL_Libretro_EnvironmentCallback);
 
    // Grab the initial system info from the core.
    struct retro_system_info sysinfo = {0};
    lr->core.symbols.retro_get_system_info(&sysinfo);
    SDL_strlcpy(lr->core.libraryName, sysinfo.library_name ? sysinfo.library_name : "", sizeof(lr->core.libraryName));
    SDL_strlcpy(lr->core.libraryVersion, sysinfo.library_version ? sysinfo.library_version : "", sizeof(lr->core.libraryVersion));
    SDL_strlcpy(lr->core.validExtensions, sysinfo.valid_extensions ? sysinfo.valid_extensions : "", sizeof(lr->core.validExtensions));
    lr->core.needFullpath = sysinfo.need_fullpath;
    lr->core.blockExtract = sysinfo.block_extract;
 
    // Default the content name to the core's reported name.
    SDL_strlcpy(lr->core.contentName, lr->core.libraryName, sizeof(lr->core.contentName));
 
    // Config
    SDL_Libretro_LoadCoreConfig(lr);
 
    // Initialize the core
    lr->core.symbols.retro_init();
 
    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "[SDL_Libretro] Core loaded: %s %s", lr->core.libraryName, lr->core.libraryVersion);
 
    SDL_Libretro_PushEvent(lr, SDL_EVENT_LIBRETRO_CORE_LOADED, lr->core.libraryName);
 
    return true;
}
 
void SDL_Libretro_UnloadCore(SDL_Libretro* lr) {
    if (!lr) return;
    bool hadCore = SDL_Libretro_IsCoreReady(lr);
 
    SDL_Libretro_UnloadGame(lr);
 
    // Tear down the loaded core module, if one is present.
    if (SDL_Libretro_IsCoreReady(lr)) {
        SDL_Libretro_SaveCoreConfig(lr);
        lr->core.symbols.retro_deinit();
        SDL_UnloadObject(lr->core.symbols.handle);
    }
 
    // Unload any frontend resources associated with the core.
    SDL_Libretro_CloseSensors(lr);
    SDL_Libretro_CloseMicrophone(lr);
    SDL_Libretro_FreeCoreOptions(lr);
    SDL_Libretro_FreeInputDescriptors(lr);
    SDL_Libretro_FreeControllerInfo(lr);
    SDL_Libretro_FreeMemoryMap(lr);
    SDL_Libretro_FreeContentInfoOverrides(lr);
    SDL_Libretro_FreeSubsystems(lr);
    SDL_Libretro_StopRumble(lr);
 
    SDL_memset(&lr->core, 0, sizeof(lr->core));
    SDL_Libretro_ResetPortDevices(lr);
    if (SDL_Libretro_active == lr) {
        SDL_Libretro_active = NULL;
    }
    lr->coreGeneration++;
 
    SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "[SDL_Libretro] Core unloaded");
 
    if (hadCore) {
        SDL_Libretro_PushEvent(lr, SDL_EVENT_LIBRETRO_CORE_UNLOADED, NULL);
    }
}
 
bool SDL_Libretro_IsCoreReady(const SDL_Libretro* lr) {
    return lr && lr->core.symbols.handle != NULL;
}
 
size_t SDL_Libretro_GetFileName(char* dst, size_t dstSize, const char* path, bool withExtension) {
    if (!dst || dstSize == 0) return 0;
    dst[0] = '\0';
    if (!path) return 0;
 
    // Skip past the last path separator to the base name.
    const char* base = SDL_strrchr(path, '/');
    if (!base) base = SDL_strrchr(path, '\\');
    base = base ? base + 1 : path;
 
    SDL_strlcpy(dst, base, dstSize);
 
    if (!withExtension) {
        char* dot = SDL_strrchr(dst, '.');
        if (dot) *dot = '\0';
    }
 
    return SDL_strlen(dst);
}
 
static const char* SDL_Libretro_GetExtension(const char* path) {
    const char* dot = SDL_strrchr(path, '.');
    return dot ? dot + 1 : "";
}
 
size_t SDL_Libretro_GetSavePath(const SDL_Libretro* lr, const char* extension, char* dst, size_t dstSize) {
    if (!dst || dstSize == 0) return 0;
    dst[0] = '\0';
    if (!lr || lr->core.contentName[0] == '\0') return 0;
 
    if (!extension) {
        extension = "";
    }
 
    if (lr->saveDirectory[0] != '\0') {
        SDL_snprintf(dst, dstSize, "%s/%s%s", lr->saveDirectory, lr->core.contentName, extension);
    }
    else {
        SDL_snprintf(dst, dstSize, "%s%s", lr->core.contentName, extension);
    }
 
    return SDL_strlen(dst);
}
 
static void SDL_Libretro_FreeContentInfoOverrides(SDL_Libretro* lr) {
    if (lr->core.contentInfoOverrides) {
        for (unsigned i = 0; i < lr->core.contentInfoOverrideCount; i++) {
            SDL_free((void*)lr->core.contentInfoOverrides[i].extensions);
        }
        SDL_free(lr->core.contentInfoOverrides);
        lr->core.contentInfoOverrides = NULL;
    }
    lr->core.contentInfoOverrideCount = 0;
}
 
static void SDL_Libretro_FreeSubsystems(SDL_Libretro* lr) {
    if (!lr || !lr->core.subsystems) return;
    for (unsigned i = 0; i < lr->core.subsystemCount; i++) {
        // Subsystem Data
        SDL_free((void*)lr->core.subsystems[i].desc);
        SDL_free((void*)lr->core.subsystems[i].ident);
 
        // Roms
        if (lr->core.subsystems[i].roms) {
            for (unsigned r = 0; r < lr->core.subsystems[i].num_roms; r++) {
                SDL_free((void*)lr->core.subsystems[i].roms[r].desc);
                SDL_free((void*)lr->core.subsystems[i].roms[r].valid_extensions);
 
                // Rom Memory
                if (lr->core.subsystems[i].roms[r].memory) {
                    for (unsigned m = 0; m < lr->core.subsystems[i].roms[r].num_memory; m++) {
                        SDL_free((void*)lr->core.subsystems[i].roms[r].memory[m].extension);
                    }
                    SDL_free((void*)lr->core.subsystems[i].roms[r].memory);
                }
            }
            SDL_free((void*)lr->core.subsystems[i].roms);
        }
    }
    SDL_free(lr->core.subsystems);
    lr->core.subsystems = NULL;
    lr->core.subsystemCount = 0;
}
 
static void SDL_Libretro_FreeInputDescriptors(SDL_Libretro* lr) {
    if (!lr || !lr->core.inputDescriptors) return;
    for (unsigned i = 0; i < lr->core.inputDescriptorsCount; i++) {
        SDL_free((void*)lr->core.inputDescriptors[i].description);
    }
    SDL_free(lr->core.inputDescriptors);
    lr->core.inputDescriptors = NULL;
    lr->core.inputDescriptorsCount = 0;
}
 
static void SDL_Libretro_FreeControllerInfo(SDL_Libretro* lr) {
    if (!lr || !lr->core.controllerInfo) return;
    for (unsigned i = 0; i < lr->core.controllerInfoCount; i++) {
        if (lr->core.controllerInfo[i].types) {
            for (unsigned t = 0; t < lr->core.controllerInfo[i].num_types; t++) {
                SDL_free((void*)lr->core.controllerInfo[i].types[t].desc);
            }
            SDL_free((void*)lr->core.controllerInfo[i].types);
        }
    }
    SDL_free(lr->core.controllerInfo);
    lr->core.controllerInfo = NULL;
    lr->core.controllerInfoCount = 0;
}
 
static const struct retro_subsystem_info* SDL_Libretro_GetSubsystemById(const SDL_Libretro* lr, unsigned subsystemId) {
    if (!lr) return NULL;
    for (unsigned i = 0; i < lr->core.subsystemCount; i++) {
        if (lr->core.subsystems[i].id == subsystemId) {
            return &lr->core.subsystems[i];
        }
    }
    return NULL;
}
 
static const struct retro_subsystem_info* SDL_Libretro_GetSubsystemByName(const SDL_Libretro* lr, const char* name) {
    if (!lr || !name) return NULL;
    for (unsigned i = 0; i < lr->core.subsystemCount; i++) {
        const struct retro_subsystem_info* subsys = &lr->core.subsystems[i];
        if ((subsys->ident && SDL_strcasecmp(subsys->ident, name) == 0) ||
            (subsys->desc && SDL_strcasecmp(subsys->desc, name) == 0)) {
            return subsys;
        }
    }
    return NULL;
}
 
static int SDL_Libretro_GetContentInfoOverride(const SDL_Libretro* lr, const char* ext) {
    if (!lr || !ext || ext[0] == '\0') return -1;
    for (unsigned i = 0; i < lr->core.contentInfoOverrideCount; i++) {
        if (SDL_Libretro_ExtensionInList(ext, lr->core.contentInfoOverrides[i].extensions)) {
            return (int)i;
        }
    }
    return -1;
}
 
static bool SDL_Libretro_ContentNeedsFullpath(const SDL_Libretro* lr, const char* ext) {
    int i = SDL_Libretro_GetContentInfoOverride(lr, ext);
    return i >= 0 ? lr->core.contentInfoOverrides[i].need_fullpath : lr->core.needFullpath;
}
 
static bool SDL_Libretro_ContentPersistData(const SDL_Libretro* lr, const char* ext) {
    int i = SDL_Libretro_GetContentInfoOverride(lr, ext);
    return i >= 0 ? lr->core.contentInfoOverrides[i].persistent_data : false;
}
 
static void SDL_Libretro_FreeGameInfoExtArray(SDL_Libretro* lr) {
    for (unsigned i = 0; i < lr->core.gameInfoExtCount; i++) {
        struct retro_game_info_ext* entry = &lr->core.gameInfoExtArray[i];
        SDL_free((void*)entry->full_path);
        SDL_free((void*)entry->dir);
        SDL_free((void*)entry->name);
        SDL_free((void*)entry->ext);
    }
    SDL_free(lr->core.gameInfoExtArray);
    lr->core.gameInfoExtArray = NULL;
    lr->core.gameInfoExtCount = 0;
}
 
static void SDL_Libretro_FillGameInfoExt(struct retro_game_info_ext* entry, const char* path) {
    if (!path) return;
    entry->full_path = SDL_strdup(path);
 
    char buffer[SDL_LIBRETRO_MAX_PATH];
    SDL_Libretro_GetFileName(buffer, sizeof(buffer), path, false);
    entry->name = SDL_strdup(buffer);
 
    SDL_Libretro_GetFileName(buffer, sizeof(buffer), path, true);
    const char* dot = SDL_strrchr(buffer, '.');
    char* ext = SDL_strdup(dot ? dot + 1 : "");
    if (ext) {
        for (char* c = ext; *c; c++) *c = (char)SDL_tolower((unsigned char)*c);
    }
    entry->ext = ext;
 
    SDL_strlcpy(buffer, path, sizeof(buffer));
    char* sep = SDL_strrchr(buffer, '/');
    char* backslash = SDL_strrchr(buffer, '\\');
    if (!sep || (backslash && backslash > sep)) sep = backslash;
    if (sep)
        *sep = '\0';
    else
        buffer[0] = '\0';
    entry->dir = SDL_strdup(buffer);
}
 
static void SDL_Libretro_ResetContentState(SDL_Libretro* lr) {
    lr->core.contentPath[0] = '\0';
    lr->core.contentDir[0] = '\0';
    lr->core.contentExt[0] = '\0';
    SDL_strlcpy(lr->core.contentName, lr->core.libraryName, sizeof(lr->core.contentName));
 
    // Remove the file SDL_Libretro_LoadGame_IO() spilled for a need_fullpath core.
    if (lr->core.contentTempPath[0] != '\0') {
        SDL_RemovePath(lr->core.contentTempPath);
        lr->core.contentTempPath[0] = '\0';
    }
 
    // Remove an archive extracted for a need_fullpath core, with everything in it.
    if (lr->core.contentTempDir[0] != '\0') {
        SDL_Libretro_RemoveTree(lr->core.contentTempDir);
        lr->core.contentTempDir[0] = '\0';
    }
 
    if (lr->core.gameInfoExt.persistent_data) {
        SDL_free((void*)lr->core.gameInfoExt.data);
    }
    SDL_memset(&lr->core.gameInfoExt, 0, sizeof(lr->core.gameInfoExt));
    SDL_Libretro_FreeGameInfoExtArray(lr);
 
    // Images kept by SDL_Libretro_AddDiskImage() and _IO() belong to the game.
    SDL_Libretro_FreeDiskImages(lr);
 
    // Restart the frame-time clock, so the first tick of new content reports the core's reference.
    lr->core.runloop_frame_time_last = 0;
 
    // The disk control interface is core-lifetime state (registered from
    // retro_set_environment/retro_init), so it's kept until SDL_Libretro_UnloadCore().
}
 
static const char* SDL_Libretro_SetContentIdentity(SDL_Libretro* lr, const char* path, const char* identityPath) {
    SDL_strlcpy(lr->core.contentPath, path, sizeof(lr->core.contentPath));
    if (!identityPath) identityPath = path;
 
    // Content base name (no extension) and lower-case extension.
    SDL_Libretro_GetFileName(lr->core.contentName, sizeof(lr->core.contentName), identityPath, false);
    const char* ext = SDL_Libretro_GetContentExtension(lr);
    SDL_strlcpy(lr->core.contentExt, SDL_Libretro_GetExtension(identityPath), sizeof(lr->core.contentExt));
    for (char* c = lr->core.contentExt; *c; c++)
        *c = (char)SDL_tolower((unsigned char)*c);
 
    // Directory containing the content file.
    SDL_strlcpy(lr->core.contentDir, identityPath, sizeof(lr->core.contentDir));
    char* sep = SDL_strrchr(lr->core.contentDir, '/');
    if (!sep) sep = SDL_strrchr(lr->core.contentDir, '\\');
    if (sep)
        *sep = '\0';
    else
        lr->core.contentDir[0] = '\0';
 
    // Initial gameInfoExt.
    lr->core.gameInfoExt.full_path = lr->core.contentPath;
    lr->core.gameInfoExt.dir = lr->core.contentDir;
    lr->core.gameInfoExt.name = lr->core.contentName;
    lr->core.gameInfoExt.ext = lr->core.contentExt;
 
    return ext;
}
 
static bool SDL_Libretro_LoadCoreForGame(SDL_Libretro* lr, const char* gamePath) {
    if (!lr || !gamePath) {
        SDL_SetError("[SDL_Libretro] No core loaded, and no content to pick one by");
        return false;
    }
 
    // The game's file extension.
    const char* extension = SDL_Libretro_GetExtension(gamePath);
    if (extension[0] == '\0') {
        SDL_SetError("[SDL_Libretro] Game path '%s' has no file extension", gamePath);
        return false;
    }
 
    // Try to load cores that match the extension.
    bool claimed = false;
    for (unsigned i = 0; i < lr->coreLibraryCount; i++) {
        // Check if the extension is in the lr->coreLibrary[i] list.
        if (!SDL_Libretro_ExtensionInList(extension, lr->coreLibrary[i].supported_extensions)) {
            continue;
        }
 
        // A candidate core claims this extension, try loading it.
        claimed = true;
        if (SDL_Libretro_LoadCore(lr, lr->coreLibrary[i].path)) {
            return true;
        }
    }
 
    // When a core claimed the extension but failed to load, its error says why.
    if (!claimed) {
        SDL_SetError("[SDL_Libretro] No core found for extension '%s'", extension);
    }
    return false;
}
 
static void SDL_Libretro_SetCoreCallbacks(SDL_Libretro* lr) {
    if (!lr) return;
    if (lr->core.symbols.retro_set_video_refresh) lr->core.symbols.retro_set_video_refresh(SDL_Libretro_VideoRefresh);
    if (lr->core.symbols.retro_set_audio_sample) lr->core.symbols.retro_set_audio_sample(SDL_Libretro_AudioSample);
    if (lr->core.symbols.retro_set_audio_sample_batch) lr->core.symbols.retro_set_audio_sample_batch(SDL_Libretro_AudioSampleBatch);
    if (lr->core.symbols.retro_set_input_poll) lr->core.symbols.retro_set_input_poll(SDL_Libretro_InputPoll);
    if (lr->core.symbols.retro_set_input_state) lr->core.symbols.retro_set_input_state(SDL_Libretro_InputState);
}
 
static bool SDL_Libretro_FinishGameLoad(SDL_Libretro* lr) {
    lr->core.gameLoaded = true;
 
    // Re-apply the app's port devices; cores expect them after retro_load_game().
    for (unsigned port = 0; port < SDL_LIBRETRO_MAX_USERS; port++) {
        if (lr->core.portDeviceMap[port] != RETRO_DEVICE_JOYPAD) {
            lr->core.symbols.retro_set_controller_port_device(port, lr->core.portDeviceMap[port]);
        }
    }
 
    // Restore the game's battery save before it first runs.
    SDL_Libretro_AutoLoadSRAM(lr);
 
    // Grab the Audio/Video data.
    struct retro_system_av_info avInfo = {0};
    lr->core.symbols.retro_get_system_av_info(&avInfo);
    lr->core.width = avInfo.geometry.base_width;
    lr->core.height = avInfo.geometry.base_height;
    lr->core.fps = avInfo.timing.fps;
    lr->core.sampleRate = avInfo.timing.sample_rate;
    lr->core.aspectRatio = avInfo.geometry.aspect_ratio;
 
    // Failed video initialization should not fail loading the game. Video is
    // deferred until a renderer is set via SDL_Libretro_SetRenderer().
    if (lr->renderer && !SDL_Libretro_InitVideo(lr)) {
        SDL_LogWarn(SDL_LOG_CATEGORY_VIDEO, "[SDL_Libretro] Video failed to initialize: %s", SDL_GetError());
    }
 
    // A missing device shouldn't stop the game from running; it plays silently
    // until the game is loaded again.
    if (!SDL_Libretro_InitAudio(lr)) {
        SDL_LogWarn(SDL_LOG_CATEGORY_AUDIO, "[SDL_Libretro] Audio failed to initialize: %s", SDL_GetError());
    }
 
    SDL_Log("[SDL_Libretro] Game loaded: %s [%ux%u @ %.2ffps]", lr->core.contentName, lr->core.width, lr->core.height, lr->core.fps);
 
    // Allocate the rewind buffer now that the serialize size is known. A core
    // that doesn't report one yet gets it on a later capture instead.
    if (lr->rewindEnabled && !lr->rewindReference && lr->core.symbols.retro_serialize_size() > 0) {
        SDL_Libretro_RewindAllocate(lr);
    }
 
    SDL_Libretro_PushEvent(lr, SDL_EVENT_LIBRETRO_GAME_LOADED, lr->core.contentName);
 
    return true;
}
 
static bool SDL_Libretro_ContentExists(const SDL_Libretro* lr, const char* path) {
    // Look through the VFS the core will use, which also sees PhysFS mounts.
    if (lr->vfs_interface.stat) {
        return (lr->vfs_interface.stat(path, NULL) & RETRO_VFS_STAT_IS_VALID) != 0;
    }
    return SDL_GetPathInfo(path, NULL);
}
 
static bool SDL_Libretro_LoadGameCommon(SDL_Libretro* lr, const char* gamePath, const char* identityPath, void* fileData, size_t fileSize) {
    // Check what can be checked before unloading anything, so a request that's
    // bound to fail leaves the running game alone.
 
    // A core that didn't opt into no-content (SET_SUPPORT_NO_GAME) can't run without a game.
    if (!gamePath && SDL_Libretro_IsGameRequired(lr)) {
        SDL_free(fileData);
        SDL_SetError("[SDL_Libretro] This core requires content");
        return false;
    }
 
    // The content has to be there: read the bytes for cores that want them,
    // or make sure the file exists for cores that want its path.
    if (gamePath && !fileData) {
        if (!SDL_Libretro_ContentNeedsFullpath(lr, SDL_Libretro_GetExtension(identityPath ? identityPath : gamePath))) {
            fileData = SDL_LoadFile(gamePath, &fileSize);
            if (!fileData) {
                SDL_SetError("[SDL_Libretro] Failed to load game file '%s'", gamePath);
                return false;
            }
        }
        else if (!SDL_Libretro_ContentExists(lr, gamePath)) {
            SDL_SetError("[SDL_Libretro] Game file '%s' not found", gamePath);
            return false;
        }
    }
 
    // Switching content: unload any game that's already running first.
    SDL_Libretro_UnloadGame(lr);
 
    struct retro_game_info gameInfo = {0};
    bool persistData = false;
 
    // Cleared here so a no-content load leaves GET_GAME_INFO_EXT invalid.
    SDL_memset(&lr->core.gameInfoExt, 0, sizeof(lr->core.gameInfoExt));
 
    if (gamePath) {
        const char* ext = SDL_Libretro_SetContentIdentity(lr, gamePath, identityPath);
 
        bool needFullpath = SDL_Libretro_ContentNeedsFullpath(lr, ext);
        persistData = SDL_Libretro_ContentPersistData(lr, ext);
 
        gameInfo.path = lr->core.contentPath;
 
        if (!needFullpath) {
            if (!fileData) {
                fileData = SDL_LoadFile(gamePath, &fileSize);
                if (!fileData) {
                    SDL_SetError("[SDL_Libretro] Failed to load game file '%s'", gamePath);
                    SDL_Libretro_ResetContentState(lr);
                    return false;
                }
            }
            gameInfo.data = fileData;
            gameInfo.size = fileSize;
        }
        else if (fileData) {
            // The core wants a path, not bytes; drop a pre-read buffer.
            SDL_free(fileData);
            fileData = NULL;
        }
 
        // The string fields are set above; fill in the content buffer.
        lr->core.gameInfoExt.data = gameInfo.data;
        lr->core.gameInfoExt.size = gameInfo.size;
        lr->core.gameInfoExt.persistent_data = persistData;
    }
    else if (fileData) {
        SDL_free(fileData);
        fileData = NULL;
    }
 
    SDL_Libretro_SetCoreCallbacks(lr);
 
    bool result = lr->core.symbols.retro_load_game(gamePath ? &gameInfo : NULL);
 
    // The gameInfoExt.data owns the content buffer. Persistent content keeps it until unload, otherwise the data is only valid for the duration of the load, so free it now and clear the (now dangling) pointer.
    if (fileData && !(persistData && result)) {
        SDL_free(fileData);
        lr->core.gameInfoExt.data = NULL;
        lr->core.gameInfoExt.size = 0;
    }
 
    if (!result) {
        SDL_Libretro_ResetContentState(lr);
        SDL_SetError("[SDL_Libretro] Core failed to load the game");
        return false;
    }
 
    SDL_Libretro_FinishGameLoad(lr);
    return true;
}
 
static bool SDL_Libretro_LoadGameFile(SDL_Libretro* lr, const char* gamePath) {
    // Try to find what can be loaded with it.
    if (!SDL_Libretro_IsCoreReady(lr) && !SDL_Libretro_LoadCoreForGame(lr, gamePath)) {
        return false;
    }
 
    return SDL_Libretro_LoadGameCommon(lr, gamePath, NULL, NULL, 0);
}
 
bool SDL_Libretro_LoadGame(SDL_Libretro* lr, const char* gamePath) {
    if (!lr) return false;
 
#if defined(SDL_LIBRETRO_ENABLE_PHYSFS) && !defined(SDL_LIBRETRO_DISABLE_PHYSFS)
    // Route archives through the PhysFS loader. It only ever falls back to
    // SDL_Libretro_LoadGameFile(), never this dispatcher, so there is no loop.
    if (gamePath && SDL_strcasecmp(SDL_Libretro_GetExtension(gamePath), "zip") == 0) {
        return SDL_Libretro_PhysFS_LoadGame(lr, gamePath);
    }
#endif
 
    return SDL_Libretro_LoadGameFile(lr, gamePath);
}
 
static bool SDL_Libretro_GetTempDirectory(SDL_Libretro* lr, char* dir, size_t dirSize) {
    const char* saveDir = SDL_Libretro_GetSaveDirectory(lr);
    if (saveDir && saveDir[0]) {
        SDL_snprintf(dir, dirSize, "%s/tmp/", saveDir);
    }
    else if (SDL_Libretro_GetPrefDirectory(dir, dirSize)) {
        SDL_strlcat(dir, "/tmp/", dirSize);
    }
    else {
        const char* base = SDL_GetBasePath();
        SDL_snprintf(dir, dirSize, "%stmp/", base ? base : "./");
    }
    if (!SDL_CreateDirectory(dir)) {
        return SDL_SetError("[SDL_Libretro] Failed to create temp directory '%s': %s", dir, SDL_GetError());
    }
    return true;
}
 
static SDL_EnumerationResult SDLCALL SDL_Libretro_RemoveTreeEntry(void* userdata, const char* dirname, const char* fname) {
    (void)userdata;
    char path[SDL_LIBRETRO_MAX_PATH];
    size_t len = SDL_strlen(dirname);
    bool slash = len > 0 && (dirname[len - 1] == '/' || dirname[len - 1] == '\\');
    SDL_snprintf(path, sizeof(path), "%s%s%s", dirname, slash ? "" : "/", fname);
    SDL_PathInfo info;
    if (SDL_GetPathInfo(path, &info) && info.type == SDL_PATHTYPE_DIRECTORY) {
        SDL_EnumerateDirectory(path, SDL_Libretro_RemoveTreeEntry, NULL);
    }
    SDL_RemovePath(path);
    return SDL_ENUM_CONTINUE;
}
 
static void SDL_Libretro_RemoveTree(const char* path) {
    SDL_EnumerateDirectory(path, SDL_Libretro_RemoveTreeEntry, NULL);
    SDL_RemovePath(path);
}
 
static bool SDL_Libretro_SpillToTempFile(SDL_Libretro* lr, SDL_IOStream* src, const char* path, bool closeio, char* tempPath, size_t tempPathSize) {
    // Read the content first, so the stream is handled on every path.
    size_t fileSize = 0;
    void* fileData = SDL_LoadFile_IO(src, &fileSize, closeio);
    if (!fileData) return false;
 
    char name[SDL_LIBRETRO_MAX_PATH];
    if (!path || SDL_Libretro_GetFileName(name, sizeof(name), path, true) == 0) {
        SDL_strlcpy(name, "content.bin", sizeof(name));
    }
 
    // Pick the temp directory and make sure it exists.
    char dir[SDL_LIBRETRO_MAX_PATH];
    if (!SDL_Libretro_GetTempDirectory(lr, dir, sizeof(dir))) {
        SDL_free(fileData);
        return false;
    }
 
    // Find a file name in the directory that doesn't exist yet.
    SDL_snprintf(tempPath, tempPathSize, "%s%s", dir, name);
    const char* dot = SDL_strrchr(name, '.');
    int stemLen = dot ? (int)(dot - name) : (int)SDL_strlen(name);
    for (int attempt = 1; SDL_GetPathInfo(tempPath, NULL); attempt++) {
        if (attempt > 99) {
            SDL_SetError("[SDL_Libretro] Could not find a free file name for '%s' in '%s'", name, dir);
            SDL_free(fileData);
            return false;
        }
        SDL_snprintf(tempPath, tempPathSize, "%s%.*s-%d%s", dir, stemLen, name, attempt, dot ? dot : "");
    }
 
    bool saved = SDL_SaveFile(tempPath, fileData, fileSize);
    SDL_free(fileData);
    if (!saved) {
        SDL_SetError("[SDL_Libretro] Failed to save content to '%s'", tempPath);
        return false;
    }
    return true;
}
 
bool SDL_Libretro_LoadGame_IO(SDL_Libretro* lr, SDL_IOStream* src, const char* path, bool closeio) {
    if (!lr || !src || !path) {
        if (src && closeio) SDL_CloseIO(src);
        return SDL_InvalidParamError("src, path");
    }
 
    // Try to find what can be loaded with it.
    if (!SDL_Libretro_IsCoreReady(lr) && !SDL_Libretro_LoadCoreForGame(lr, path)) {
        if (closeio) SDL_CloseIO(src);
        return false;
    }
 
    // The raw-case extension drives the need_fullpath resolution.
    if (!SDL_Libretro_ContentNeedsFullpath(lr, SDL_Libretro_GetExtension(path))) {
        // Byte-oriented content: hand the stream contents to the core.
        size_t fileSize = 0;
        void* fileData = SDL_LoadFile_IO(src, &fileSize, closeio);
        if (!fileData) return false;
        return SDL_Libretro_LoadGameCommon(lr, path, NULL, fileData, fileSize);
    }
 
    // The core wants a real file: spill the stream to the temp directory and
    // load from there. The content keeps the identity of `path`, so save files
    // are named after it rather than the temp file.
    char tempPath[SDL_LIBRETRO_MAX_PATH];
    if (!SDL_Libretro_SpillToTempFile(lr, src, path, closeio, tempPath, sizeof(tempPath))) {
        return false;
    }
 
    // The temp path is recorded only after the load, so the UnloadGame inside
    // SDL_Libretro_LoadGameCommon() doesn't remove the file it's about to use.
    bool result = SDL_Libretro_LoadGameCommon(lr, tempPath, path, NULL, 0);
    if (result) {
        SDL_strlcpy(lr->core.contentTempPath, tempPath, sizeof(lr->core.contentTempPath));
    }
    else {
        SDL_RemovePath(tempPath);
    }
    return result;
}
 
bool SDL_Libretro_LoadGameSpecialById(SDL_Libretro* lr, unsigned subsystemId, const char** paths, unsigned numPaths) {
    if (!SDL_Libretro_IsCoreReady(lr) || !paths || numPaths == 0) {
        SDL_SetError("[SDL_Libretro] Invalid arguments for LoadGameSpecial");
        return false;
    }
 
    // Find the subsystem info to determine per-ROM need_fullpath.
    const struct retro_subsystem_info* subsys = SDL_Libretro_GetSubsystemById(lr, subsystemId);
    if (!subsys) {
        SDL_SetError("[SDL_Libretro] Unknown subsystem id %u", subsystemId);
        return false;
    }
 
    // The paths must fit the ROMs the subsystem declares, with every required
    // one given, or the core only rejects them with no hint why.
    unsigned requiredCount = 0;
    bool missingRequired = false;
    for (unsigned i = 0; i < subsys->num_roms; i++) {
        if (subsys->roms[i].required) {
            requiredCount++;
            missingRequired = missingRequired || i >= numPaths || !paths[i];
        }
    }
    if (numPaths > subsys->num_roms || missingRequired) {
        SDL_SetError("[SDL_Libretro] Subsystem '%s' expects %u ROM(s) (%u required), got %u", subsys->desc ? subsys->desc : (subsys->ident ? subsys->ident : ""), subsys->num_roms, requiredCount, numPaths);
        return false;
    }
 
    // Build the game info with the given data. The files are read before the
    // running game is unloaded, so a missing one leaves it running.
    struct retro_game_info* gameInfos = (struct retro_game_info*)SDL_calloc(numPaths, sizeof(struct retro_game_info));
    void** fileBuffers = (void**)SDL_calloc(numPaths, sizeof(void*));
    if (!gameInfos || !fileBuffers) {
        SDL_free(gameInfos);
        SDL_free(fileBuffers);
        SDL_SetError("[SDL_Libretro] Allocation failed");
        return false;
    }
 
    for (unsigned i = 0; i < numPaths; i++) {
        if (!paths[i]) continue;
        gameInfos[i].path = paths[i];
 
        bool needFullpath = lr->core.needFullpath;
        if (i < subsys->num_roms) {
            needFullpath = subsys->roms[i].need_fullpath;
        }
 
        if (!needFullpath) {
            size_t fileSize = 0;
            fileBuffers[i] = SDL_LoadFile(paths[i], &fileSize);
            if (!fileBuffers[i]) {
                SDL_SetError("[SDL_Libretro] Failed to load file '%s'", paths[i]);
                for (unsigned j = 0; j < i; j++) SDL_free(fileBuffers[j]);
                SDL_free(fileBuffers);
                SDL_free(gameInfos);
                return false;
            }
            gameInfos[i].data = fileBuffers[i];
            gameInfos[i].size = fileSize;
        }
        else if (!SDL_Libretro_ContentExists(lr, paths[i])) {
            SDL_SetError("[SDL_Libretro] File '%s' not found", paths[i]);
            for (unsigned j = 0; j < i; j++) SDL_free(fileBuffers[j]);
            SDL_free(fileBuffers);
            SDL_free(gameInfos);
            return false;
        }
    }
 
    SDL_Libretro_UnloadGame(lr);
 
    // Populate the game info from the primary path, so
    // GET_GAME_INFO_EXT is valid while loading the game.
    SDL_memset(&lr->core.gameInfoExt, 0, sizeof(lr->core.gameInfoExt));
    if (paths[0]) {
        SDL_Libretro_SetContentIdentity(lr, paths[0], NULL);
        lr->core.gameInfoExt.data = gameInfos[0].data;
        lr->core.gameInfoExt.size = gameInfos[0].size;
        lr->core.gameInfoExt.persistent_data = false;
    }
    else {
        SDL_strlcpy(lr->core.contentName, lr->core.libraryName, sizeof(lr->core.contentName));
    }
 
    // GET_GAME_INFO_EXT hands subsystem cores one entry per content file, in subsystem order. Files that weren't given keep a NULL full_path.
    SDL_Libretro_FreeGameInfoExtArray(lr);
    lr->core.gameInfoExtArray = (struct retro_game_info_ext*)SDL_calloc(numPaths, sizeof(struct retro_game_info_ext));
    if (lr->core.gameInfoExtArray) {
        lr->core.gameInfoExtCount = numPaths;
        for (unsigned i = 0; i < numPaths; i++) {
            SDL_Libretro_FillGameInfoExt(&lr->core.gameInfoExtArray[i], paths[i]);
            lr->core.gameInfoExtArray[i].data = gameInfos[i].data;
            lr->core.gameInfoExtArray[i].size = gameInfos[i].size;
            lr->core.gameInfoExtArray[i].persistent_data = false;
        }
    }
 
    SDL_Libretro_SetCoreCallbacks(lr);
 
    bool result = lr->core.symbols.retro_load_game_special(subsystemId, gameInfos, numPaths);
 
    // The frontend owns the ROM buffers for the load only, free them
    // and drop gameInfoExt.
    for (unsigned i = 0; i < numPaths; i++) SDL_free(fileBuffers[i]);
    SDL_free(fileBuffers);
    SDL_free(gameInfos);
    lr->core.gameInfoExt.data = NULL;
    lr->core.gameInfoExt.size = 0;
    for (unsigned i = 0; i < lr->core.gameInfoExtCount; i++) {
        lr->core.gameInfoExtArray[i].data = NULL;
        lr->core.gameInfoExtArray[i].size = 0;
    }
 
    if (!result) {
        SDL_Libretro_ResetContentState(lr);
        SDL_SetError("[SDL_Libretro] Core failed to load the special game");
        return false;
    }
 
    SDL_Libretro_FinishGameLoad(lr);
    return true;
}
 
bool SDL_Libretro_LoadGameSpecial(SDL_Libretro* lr, const char* subsystem, const char** paths, unsigned numPaths) {
    // Match by ident or human-readable description.
    const struct retro_subsystem_info* subsys = SDL_Libretro_GetSubsystemByName(lr, subsystem);
    if (!subsys) {
        SDL_SetError("[SDL_Libretro] Unknown subsystem '%s'", subsystem ? subsystem : "(null)");
        return false;
    }
    return SDL_Libretro_LoadGameSpecialById(lr, subsys->id, paths, numPaths);
}
 
void SDL_Libretro_UnloadGame(SDL_Libretro* lr) {
    if (!lr || !lr->core.gameLoaded) return;
 
    // Keep the game's battery save while the core still has it.
    SDL_Libretro_AutoSaveSRAM(lr);
 
    // Unload the game before closing audio and video.
    lr->core.symbols.retro_unload_game();
    lr->core.gameLoaded = false;
    // A shutdown request was for the game that's now gone.
    lr->core.shutdown = false;
    SDL_Libretro_ResetContentState(lr);
    SDL_Libretro_StopRumble(lr);
 
    SDL_Libretro_RewindFree(lr);
    SDL_Libretro_CloseAudio(lr);
    SDL_Libretro_CloseVideo(lr);
    SDL_Libretro_PhysFS_ClearMount(lr);
    SDL_Log("[SDL_Libretro] Game unloaded");
 
    SDL_Libretro_PushEvent(lr, SDL_EVENT_LIBRETRO_GAME_UNLOADED, NULL);
}
 
bool SDL_Libretro_IsGameReady(const SDL_Libretro* lr) {
    return lr && lr->core.gameLoaded;
}
 
bool SDL_Libretro_IsGameRequired(const SDL_Libretro* lr) {
    return lr && !lr->core.supportNoGame;
}
 
bool SDL_Libretro_Reset(SDL_Libretro* lr) {
    if (!lr || !lr->core.gameLoaded) {
        SDL_SetError("[SDL_Libretro] No game loaded");
        return false;
    }
    lr->core.symbols.retro_reset();
 
    // Restart the frame-time clock, so the first tick after the reset reports the core's reference.
    lr->core.runloop_frame_time_last = 0;
 
    // Clear any rewind states.
    SDL_Libretro_ClearRewind(lr);
 
    // Drop the audio queued from before the reset so it doesn't continue into the reset.
    if (lr->core.audioStream) {
        SDL_ClearAudioStream(lr->core.audioStream);
        lr->core.singleSampleCount = 0;
        lr->core.drcDriftAvg = 0.0;
    }
    return true;
}
 
#define SDL_LIBRETRO_FRAME_TIME_MAX_GAP_NS (250 * SDL_NS_PER_MS)
 
static retro_usec_t SDL_Libretro_FrameTimeDelta(SDL_Libretro* lr, retro_usec_t referenceUsec, int ticks) {
    Uint64 nowNS = SDL_LIBRETRO_GET_TICKS_NS();
    Uint64 lastNS = lr->core.runloop_frame_time_last;
    lr->core.runloop_frame_time_last = nowNS;
    if (!lastNS || referenceUsec <= 0 || nowNS - lastNS > SDL_LIBRETRO_FRAME_TIME_MAX_GAP_NS) {
        return lr->core.runloop_frame_time.reference;
    }
    if (lr->core.speed != 1.0f) {
        return referenceUsec;
    }
    retro_usec_t measured = (retro_usec_t)((nowNS - lastNS) / SDL_NS_PER_US);
    return ticks > 1 ? measured / ticks : measured;
}
 
static void SDL_Libretro_Tick(SDL_Libretro* lr, retro_usec_t frameTimeUsec) {
    if (lr->core.runloop_frame_time.callback) {
        lr->core.runloop_frame_time.callback(frameTimeUsec);
    }
 
    // Report audio buffer occupancy so the core can frame-skip if an underrun looms. Per the libretro spec this fires right before retro_run().
    SDL_Libretro_ReportAudioBufferStatus(lr);
 
    // Run the frame.
    lr->core.symbols.retro_run();
 
    // Capture rewind state after each forward tick.
    SDL_Libretro_RewindCapture(lr);
 
    // Only pump the core's async-audio callback when audio is actually up.
    if (lr->core.audioStream && lr->core.audio_callback.callback) {
        lr->core.audio_callback.callback();
    }
}
 
void SDL_Libretro_Update(SDL_Libretro* lr) {
    // Once the core asks to shut down, it doesn't expect to run again.
    if (!lr || !lr->core.gameLoaded || lr->core.shutdown) return;
 
    // Pending Video Driver Reinit
    if (lr->core.videoReinitPending) {
        lr->core.videoReinitPending = false;
        SDL_Libretro_InitVideo(lr);
    }
 
    // Pending Audio Driver Reinit
    if (lr->core.audioReinitPending) {
        lr->core.audioReinitPending = false;
        SDL_Libretro_InitAudio(lr);
    }
 
    // Paused: Do nothing when speed is zero. The frame-time clock restarts on resume, so the pause isn't reported as one long frame.
    if (lr->core.speed == 0.0f) {
        lr->core.runloop_frame_time_last = 0;
        return;
    }
 
    // Keep any active rumble going until the core sets it back to 0.
    for (unsigned port = 0; port < SDL_LIBRETRO_MAX_USERS; port++) {
        if (lr->core.rumbleStrong[port] > 0.0f || lr->core.rumbleWeak[port] > 0.0f) {
            SDL_Libretro_ApplyRumble(lr, port);
        }
    }
 
    // Rewind mode: step backwards when speed is negative.
    if (lr->rewindEnabled && lr->core.speed < 0.0f) {
        Uint64 nowNS = SDL_LIBRETRO_GET_TICKS_NS();
        if (lr->core.lastTickNS == 0) {
            lr->core.lastTickNS = nowNS;
        }
        double frameTime = (double)(nowNS - lr->core.lastTickNS) / 1.0e9;
        lr->core.lastTickNS = nowNS;
        double framePeriod = (lr->core.fps > 0.0) ? (1.0 / lr->core.fps) : (1.0 / 60.0);
        // Each stored snapshot spans captureInterval real frames (a snapshot is taken every Nth frame), so a single rewind step undoes that many frames of game time. Scale the per-step wall-clock cost by the interval; otherwise speed -1 would rewind captureInterval times faster than speed +1 plays forward.
        unsigned interval = lr->rewindCaptureInterval > 0 ? lr->rewindCaptureInterval : 1;
        double stepPeriod = framePeriod * (double)interval;
        lr->core.speedAccumulator += frameTime * (double)(-lr->core.speed);
 
        // Protect against infinite rewinds, and clamp it to 1 tick.
        int maxTicks = (int)(-lr->core.speed + 1.0f);
        if (maxTicks < 1) maxTicks = 1;
 
        // Protect with a maximum accumulator, so frame spikes don't drain the rewind buffer.
        double maxAccumulator = stepPeriod * (double)maxTicks;
        if (lr->core.speedAccumulator > maxAccumulator) {
            lr->core.speedAccumulator = maxAccumulator;
        }
 
        // Mute audio and neutralize input for the throwaway re-runs that produce the displayed frames while scrubbing backward.
        lr->rewindActive = true;
        while (lr->core.speedAccumulator >= stepPeriod && maxTicks-- > 0 && !lr->core.shutdown) {
            lr->core.speedAccumulator -= stepPeriod;
            if (!SDL_Libretro_RewindStepState(lr)) break;
            lr->core.symbols.retro_run();
        }
        lr->rewindActive = false;
        // Rewind steps bypass the frame-time callback, so restart its clock for when forward play resumes.
        lr->core.runloop_frame_time_last = 0;
        return;
    }
 
    // Keep audio consumption locked to speed + nudge the queue toward its target fill. Done here, above all three return paths below, so it runs every frame.
    SDL_Libretro_UpdateDRC(lr, lr->core.speed);
 
    // Wall-clock delta since the previous RunFrame.
    Uint64 nowNS = SDL_LIBRETRO_GET_TICKS_NS();
    if (lr->core.lastTickNS == 0) {
        // First call: seed the clock and run exactly one tick.
        lr->core.lastTickNS = nowNS;
        lr->core.speedAccumulator = 0.0;
        SDL_Libretro_Tick(lr, SDL_Libretro_FrameTimeDelta(lr, 0, 1));
        return;
    }
 
    // Calculate the frame time in seconds.
    double frameTime = (double)(nowNS - lr->core.lastTickNS) / 1.0e9;
    lr->core.lastTickNS = nowNS;
 
    // Target frame period from the core's declared fps (default 60).
    double framePeriod = (lr->core.fps > 0.0) ? (1.0 / lr->core.fps) : (1.0 / 60.0);
 
    // Reference frame-time the core is told about, in microseconds.
    retro_usec_t referenceUsec = (retro_usec_t)(framePeriod * 1.0e6 / (double)lr->core.speed);
 
    // At normal speed, when the loop is already paced close to the core's frame rate (e.g. a vsync'd 60 Hz display with a ~60 fps core), run exactly one tick and discard the accumulator. This avoids the beat-frequency judder of occasionally emitting 0 or 2 ticks. Gating on the *measured* cadence keeps the core bounded when vsync is off / FPS uncapped.
    double cadence = (framePeriod > 0.0) ? (frameTime / framePeriod) : 0.0;
    if (lr->core.speed == 1.0f && cadence > 0.9 && cadence < 1.1) {
        lr->core.speedAccumulator = 0.0;
        SDL_Libretro_Tick(lr, SDL_Libretro_FrameTimeDelta(lr, referenceUsec, 1));
        return;
    }
 
    lr->core.speedAccumulator += frameTime * (double)lr->core.speed;
 
    // Cap iterations to avoid a spiral of death on slow hardware.
    int maxTicks = (int)(lr->core.speed + 1.0f);
    if (maxTicks < 1) maxTicks = 1;
 
    // Clamp the accumulator so a frame-time spike (game load, window drag, menu pause) can't leave a backlog that runs the core fast afterwards.
    double maxAccumulator = framePeriod * (double)maxTicks;
    if (lr->core.speedAccumulator > maxAccumulator) {
        lr->core.speedAccumulator = maxAccumulator;
    }
 
    // Count the ticks needed to catch up, so the measured frame time can be shared between them.
    int ticks = 0;
    while (lr->core.speedAccumulator >= framePeriod && ticks < maxTicks) {
        lr->core.speedAccumulator -= framePeriod;
        ticks++;
    }
    if (ticks == 0) return;
 
    // Run the required number of ticks.
    retro_usec_t frameTimeUsec = SDL_Libretro_FrameTimeDelta(lr, referenceUsec, ticks);
    for (int i = 0; i < ticks && !lr->core.shutdown; i++) {
        SDL_Libretro_Tick(lr, frameTimeUsec);
    }
}
 
bool SDL_Libretro_ShouldQuit(const SDL_Libretro* lr) {
    return lr && lr->core.shutdown;
}
 
int SDL_Libretro_GetVersion(void) {
    return SDL_LIBRETRO_VERSION;
}
 
static void SDL_Libretro_PushEvent(SDL_Libretro* lr, Uint32 type, void* data) {
    SDL_Event event;
    SDL_zero(event);
    event.user.type = type;
    event.user.data1 = lr;
    event.user.data2 = data;
    SDL_PushEvent(&event);
}
 
static bool SDLCALL SDL_Libretro_KeepUnclaimedEnvEvent(void* userdata, SDL_Event* event) {
    const SDL_UserEvent* pushed = (const SDL_UserEvent*)userdata;
    return !(event->type == pushed->type && event->user.data1 == pushed->data1 && event->user.reserved == pushed->reserved);
}
 
static bool SDL_Libretro_PushEnvEvent(SDL_Libretro* lr, unsigned cmd, void* data) {
    // Only commands that map onto their own event type are reported, so an
    // out-of-range number can't pose as another command or a library event.
    unsigned flags = cmd & (unsigned)(RETRO_ENVIRONMENT_EXPERIMENTAL | RETRO_ENVIRONMENT_PRIVATE);
    if ((cmd & ~flags) >= 0x400 || flags == (unsigned)(RETRO_ENVIRONMENT_EXPERIMENTAL | RETRO_ENVIRONMENT_PRIVATE)) {
        return false;
    }
 
    static SDL_AtomicInt sequence;
    SDL_Event event;
    SDL_zero(event);
    event.user.type = SDL_EVENT_LIBRETRO_ENVIRONMENT(cmd);
    event.user.reserved = (Uint32)SDL_AddAtomicInt(&sequence, 1) + 1;
    event.user.data1 = lr;
    event.user.data2 = data;
    const SDL_UserEvent pushed = event.user;
 
    // SDL_PushEvent() returns false when the filter drops the event, which a
    // filter that claimed the command may do, so only user.code decides.
    const bool queued = SDL_PushEvent(&event);
    if (event.user.code == 0) {
        return false;
    }
 
    // A watch implemented the command, so each event is delivered exactly
    // once: the queued copy would only re-report it with an expired data
    // pointer, so drop it. Unclaimed commands stay queued for observation.
    if (queued) {
        SDL_FilterEvents(SDL_Libretro_KeepUnclaimedEnvEvent, (void*)&pushed);
    }
    return true;
}
 
// Directory
 
static void SDL_Libretro_FreeCoreLibrary(SDL_Libretro* lr) {
    if (lr->coreLibrary) {
        for (unsigned i = 0; i < lr->coreLibraryCount; i++) {
            SDL_free(lr->coreLibrary[i].corename);
            SDL_free(lr->coreLibrary[i].supported_extensions);
            SDL_free(lr->coreLibrary[i].path);
        }
        SDL_free(lr->coreLibrary);
        lr->coreLibrary = NULL;
    }
    lr->coreLibraryCount = 0;
}
 
// The file extension for the cores on this platform
#if defined(SDL_PLATFORM_WINDOWS)
#define SDL_LIBRETRO_CORE_EXTENSION ".dll"
#elif defined(SDL_PLATFORM_APPLE)
#define SDL_LIBRETRO_CORE_EXTENSION ".dylib"
#elif defined(SDL_PLATFORM_EMSCRIPTEN)
#define SDL_LIBRETRO_CORE_EXTENSION ".wasm"
#else
#define SDL_LIBRETRO_CORE_EXTENSION ".so"
#endif
 
static SDL_EnumerationResult SDLCALL SDL_Libretro_SetCoreDirectory_Iterator(void* userdata, const char* dirname, const char* fname) {
    SDL_Libretro* lr = (SDL_Libretro*)userdata;
 
    // Find all .info files in the core directory.
    const char* dot = SDL_strrchr(fname, '.');
    if (!dot || SDL_strcasecmp(dot, ".info") != 0) {
        return SDL_ENUM_CONTINUE;
    }
 
    // Get the path.
    char infoPath[SDL_LIBRETRO_MAX_PATH];
    SDL_snprintf(infoPath, sizeof(infoPath), "%s%s", dirname, fname);
 
    // Load the .ini file.
    SDL_ini* ini = INI_Load(infoPath);
    if (!ini) {
        return SDL_ENUM_CONTINUE;
    }
 
    // Make sure it's a valid info file.
    const char* corename = INI_GetString(ini, NULL, "corename", NULL);
    if (!corename) {
        INI_Destroy(ini);
        return SDL_ENUM_CONTINUE;
    }
 
    // Grow the core library by one entry.
    SDL_Libretro_CoreInfo* grown = (SDL_Libretro_CoreInfo*)SDL_realloc(
        lr->coreLibrary,
        (lr->coreLibraryCount + 1) * sizeof(SDL_Libretro_CoreInfo));
    if (!grown) {
        INI_Destroy(ini);
        SDL_SetError("[SDL_Libretro] Out of memory building the core library");
        return SDL_ENUM_FAILURE;
    }
    lr->coreLibrary = grown;
 
    // Build the SDL_Libretro_CoreInfo structure.
    SDL_Libretro_CoreInfo* entry = &lr->coreLibrary[lr->coreLibraryCount];
    const char* extensions = INI_GetString(ini, NULL, "supported_extensions", NULL);
    entry->corename = SDL_strdup(corename);
    entry->supported_extensions = extensions ? SDL_strdup(extensions) : NULL;
    entry->needs_fullpath = INI_GetBoolean(ini, NULL, "needs_fullpath", false);
    entry->supports_no_game = INI_GetBoolean(ini, NULL, "supports_no_game", false);
    entry->block_extract = INI_GetBoolean(ini, NULL, "block_extract", false);
 
    // Build the path for the core.
    char base[SDL_LIBRETRO_MAX_PATH];
    size_t baseLen = (size_t)(dot - fname);
    SDL_strlcpy(base, fname, (baseLen < sizeof(base)) ? baseLen + 1 : sizeof(base));
    char corePath[SDL_LIBRETRO_MAX_PATH];
    SDL_snprintf(corePath, sizeof(corePath), "%s%s%s", dirname, base, SDL_LIBRETRO_CORE_EXTENSION);
    entry->path = SDL_strdup(corePath);
 
    INI_Destroy(ini);
 
    // Only publish the entry once every string copied, so the library never holds NULL names or paths.
    if (!entry->corename || !entry->path || (extensions && !entry->supported_extensions)) {
        SDL_free(entry->corename);
        SDL_free(entry->supported_extensions);
        SDL_free(entry->path);
        SDL_SetError("[SDL_Libretro] Out of memory building the core library");
        return SDL_ENUM_FAILURE;
    }
    lr->coreLibraryCount++;
    return SDL_ENUM_CONTINUE;
}
 
static int SDLCALL SDL_Libretro_CompareCoreInfo(const void* a, const void* b) {
    const SDL_Libretro_CoreInfo* left = (const SDL_Libretro_CoreInfo*)a;
    const SDL_Libretro_CoreInfo* right = (const SDL_Libretro_CoreInfo*)b;
    int result = SDL_strcasecmp(left->corename, right->corename);
    return result != 0 ? result : SDL_strcmp(left->path, right->path);
}
 
bool SDL_Libretro_SetCoreDirectory(SDL_Libretro* lr, const char* path) {
    if (!lr) return false;
    const char* newPath = path ? path : "";
    SDL_strlcpy(lr->coreDirectory, newPath, sizeof(lr->coreDirectory));
 
    // When the core directory changed, rebuild the core library.
    SDL_Libretro_FreeCoreLibrary(lr);
    if (lr->coreDirectory[0] == '\0') return true;
 
    SDL_PathInfo info;
    if (!SDL_GetPathInfo(lr->coreDirectory, &info) || info.type != SDL_PATHTYPE_DIRECTORY) {
        SDL_SetError("[SDL_Libretro] Core directory '%s' is not a directory", lr->coreDirectory);
        return false;
    }
 
    if (!SDL_EnumerateDirectory(lr->coreDirectory, &SDL_Libretro_SetCoreDirectory_Iterator, (void*)lr)) {
        SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "[SDL_Libretro] Failed to scan core directory '%s': %s", lr->coreDirectory, SDL_GetError());
        return false;
    }
 
    // Directory order varies by platform and filesystem, so sort for a stable pick.
    if (lr->coreLibraryCount > 1) {
        SDL_qsort(lr->coreLibrary, lr->coreLibraryCount, sizeof(SDL_Libretro_CoreInfo), SDL_Libretro_CompareCoreInfo);
    }
    return true;
}
 
static bool SDL_Libretro_GetPrefDirectory(char* dst, size_t dstSize) {
    const char* appName = SDL_GetAppMetadataProperty(SDL_PROP_APP_METADATA_NAME_STRING);
    const char* orgName = SDL_GetAppMetadataProperty(SDL_PROP_APP_METADATA_CREATOR_STRING);
    char* prefPath = SDL_GetPrefPath(orgName && orgName[0] ? orgName : "SDL_libretro", appName && appName[0] ? appName : "SDL_libretro");
    if (!prefPath) return false;
 
    // Ensure it's a clean path; directory paths are composed as "<dir>/<file>".
    size_t len = SDL_strlen(prefPath);
    while (len > 0 && (prefPath[len - 1] == '/' || prefPath[len - 1] == '\\')) {
        prefPath[--len] = '\0';
    }
    SDL_strlcpy(dst, prefPath, dstSize);
    SDL_free(prefPath);
    return dst[0] != '\0';
}
 
bool SDL_Libretro_SetSaveDirectory(SDL_Libretro* lr, const char* path) {
    if (!lr) return false;
 
    if (!path) {
        // NULL resets to the default: "saves" inside the app's pref path.
        char pref[SDL_LIBRETRO_MAX_PATH];
        if (SDL_Libretro_GetPrefDirectory(pref, sizeof(pref))) {
            SDL_snprintf(lr->saveDirectory, sizeof(lr->saveDirectory), "%s/saves", pref);
        }
        else {
            lr->saveDirectory[0] = '\0';
        }
        return true;
    }
 
    SDL_strlcpy(lr->saveDirectory, path, sizeof(lr->saveDirectory));
    return true;
}
 
bool SDL_Libretro_SetSystemDirectory(SDL_Libretro* lr, const char* path) {
    if (!lr) return false;
 
    if (!path) {
        // NULL resets to the default: "system" inside the app's pref path.
        char pref[SDL_LIBRETRO_MAX_PATH];
        if (SDL_Libretro_GetPrefDirectory(pref, sizeof(pref))) {
            SDL_snprintf(lr->systemDirectory, sizeof(lr->systemDirectory), "%s/system", pref);
        }
        else {
            lr->systemDirectory[0] = '\0';
        }
        return true;
    }
 
    SDL_strlcpy(lr->systemDirectory, path, sizeof(lr->systemDirectory));
    return true;
}
 
bool SDL_Libretro_SetCoreAssetsDirectory(SDL_Libretro* lr, const char* path) {
    if (!lr) return false;
    SDL_strlcpy(lr->coreAssetsDirectory, path ? path : "", sizeof(lr->coreAssetsDirectory));
    return true;
}
 
const char* SDL_Libretro_GetCoreDirectory(SDL_Libretro* lr) {
    if (!lr) return NULL;
    return lr->coreDirectory[0] ? lr->coreDirectory : NULL;
}
 
const char* SDL_Libretro_GetSaveDirectory(SDL_Libretro* lr) {
    if (!lr) return NULL;
    return lr->saveDirectory[0] ? lr->saveDirectory : NULL;
}
 
const char* SDL_Libretro_GetSystemDirectory(SDL_Libretro* lr) {
    if (!lr) return NULL;
    return lr->systemDirectory[0] ? lr->systemDirectory : NULL;
}
 
const char* SDL_Libretro_GetCoreAssetsDirectory(SDL_Libretro* lr) {
    if (!lr) return NULL;
    return lr->coreAssetsDirectory[0] ? lr->coreAssetsDirectory : NULL;
}
 
bool SDL_Libretro_SetUsername(SDL_Libretro* lr, const char* username) {
    if (!lr) return false;
    SDL_strlcpy(lr->username, username ? username : "", sizeof(lr->username));
    return true;
}
 
const char* SDL_Libretro_GetUsername(SDL_Libretro* lr) {
    if (!lr) return NULL;
    return lr->username;
}
 
void SDL_Libretro_SetVolume(SDL_Libretro* lr, float volume) {
    if (!lr) return;
    lr->volume = SDL_clamp(volume, 0.0f, 1.0f);
    if (lr->core.audioStream) {
        SDL_SetAudioStreamGain(lr->core.audioStream, lr->volume);
    }
}
 
float SDL_Libretro_GetVolume(const SDL_Libretro* lr) {
    return lr ? lr->volume : 0.0f;
}
 
void SDL_Libretro_SetSpeed(SDL_Libretro* lr, float speed) {
    if (!lr) return;
 
    if (lr->core.fastforwardOverrideActive && lr->core.fastforwardOverride.inhibit_toggle) return;
 
    if (speed < 0.0f && lr->rewindEnabled && lr->rewindReference) {
        lr->core.speed = speed;
        if (lr->core.audioStream) {
            lr->core.drcAdjustment = 1.0f;
            lr->core.drcDriftAvg = 0.0;
            SDL_ClearAudioStream(lr->core.audioStream);
            // Pitch and consume the reversed audio at the rewind speed, mirroring
            // the forward path (which sets the ratio to speed * drcAdjustment).
            SDL_SetAudioStreamFrequencyRatio(lr->core.audioStream, -speed);
        }
    }
    else {
        lr->core.speed = SDL_max(speed, 0.0f);
    }
 
    if (lr->core.audioStream && lr->core.speed > 0.0f) {
        lr->core.drcAdjustment = 1.0f;
        lr->core.drcDriftAvg = 0.0;
        SDL_SetAudioStreamFrequencyRatio(lr->core.audioStream, lr->core.speed * lr->core.drcAdjustment);
    }
}
 
float SDL_Libretro_GetSpeed(const SDL_Libretro* lr) {
    return lr ? lr->core.speed : 1.0f;
}
 
bool SDL_Libretro_IsFastforwardOverrideActive(const SDL_Libretro* lr) {
    return lr && lr->core.fastforwardOverrideActive;
}
 
void SDL_Libretro_SetLogLevel(SDL_Libretro* lr, SDL_LogPriority level) {
    if (!lr) return;
    switch (level) {
        case SDL_LOG_PRIORITY_INFO: lr->logLevel = RETRO_LOG_INFO; break;
        case SDL_LOG_PRIORITY_WARN: lr->logLevel = RETRO_LOG_WARN; break;
        case SDL_LOG_PRIORITY_ERROR: lr->logLevel = RETRO_LOG_ERROR; break;
        case SDL_LOG_PRIORITY_CRITICAL: lr->logLevel = RETRO_LOG_ERROR; break;
        default: lr->logLevel = RETRO_LOG_DEBUG; break;
    }
}
 
SDL_LogPriority SDL_Libretro_GetLogLevel(const SDL_Libretro* lr) {
    if (!lr) return SDL_LOG_PRIORITY_INVALID;
    switch (lr->logLevel) {
        case RETRO_LOG_DEBUG: return SDL_LOG_PRIORITY_DEBUG;
        case RETRO_LOG_INFO: return SDL_LOG_PRIORITY_INFO;
        case RETRO_LOG_WARN: return SDL_LOG_PRIORITY_WARN;
        case RETRO_LOG_ERROR: return SDL_LOG_PRIORITY_ERROR;
        default: return SDL_LOG_PRIORITY_INVALID;
    }
}
 
const char* SDL_Libretro_GetCoreName(const SDL_Libretro* lr) {
    return SDL_Libretro_IsCoreReady(lr) ? lr->core.libraryName : "";
}
 
const char* SDL_Libretro_GetGameName(const SDL_Libretro* lr) {
    return SDL_Libretro_IsGameReady(lr) ? lr->core.contentName : "";
}
 
const char* SDL_Libretro_GetCoreVersion(const SDL_Libretro* lr) {
    return SDL_Libretro_IsCoreReady(lr) ? lr->core.libraryVersion : "";
}
 
const char* SDL_Libretro_GetValidExtensions(const SDL_Libretro* lr) {
    return SDL_Libretro_IsCoreReady(lr) ? lr->core.validExtensions : "";
}
 
unsigned SDL_Libretro_GetPerformanceLevel(const SDL_Libretro* lr) {
    return lr ? lr->core.performanceLevel : 0;
}
 
enum retro_savestate_context SDL_Libretro_GetSavestateContext(const SDL_Libretro* lr) {
    return lr ? lr->core.savestateContext : RETRO_SAVESTATE_CONTEXT_NORMAL;
}
 
void SDL_Libretro_SetSavestateContext(SDL_Libretro* lr, enum retro_savestate_context context) {
    if (lr) lr->core.savestateContext = context;
}
 
bool SDL_Libretro_GetBlockExtract(const SDL_Libretro* lr) {
    return SDL_Libretro_IsCoreReady(lr) && lr->core.blockExtract;
}
 
const char* SDL_Libretro_GetContentExtension(const SDL_Libretro* lr) {
    if (!lr || lr->core.contentPath[0] == '\0') return "";
    return SDL_Libretro_GetExtension(lr->core.contentPath);
}
 
static bool SDL_Libretro_ExtensionInList(const char* ext, const char* pipeList) {
    if (!ext || !pipeList) return false;
    size_t extLen = SDL_strlen(ext);
    const char* p = pipeList;
    while (*p) {
        const char* sep = SDL_strchr(p, '|');
        size_t segLen = sep ? (size_t)(sep - p) : SDL_strlen(p);
        if (segLen == extLen && SDL_strncasecmp(p, ext, extLen) == 0) return true;
        if (!sep) break;
        p = sep + 1;
    }
    return false;
}
 
#undef LOAD_SYM
 
#endif /* SDL_LIBRETRO_CORE_IMPL_ONCE */