SDL_libretro/_s_d_l__libretro_8h_source.html

#ifndef SDL_LIBRETRO_H

#define SDL_LIBRETRO_H


#include <SDL3/SDL.h>


#define SDL_LIBRETRO_MAJOR_VERSION 0


#define SDL_LIBRETRO_MINOR_VERSION 1


#define SDL_LIBRETRO_MICRO_VERSION 0


#define SDL_LIBRETRO_VERSION SDL_VERSIONNUM(SDL_LIBRETRO_MAJOR_VERSION, SDL_LIBRETRO_MINOR_VERSION, SDL_LIBRETRO_MICRO_VERSION)


#define SDL_LIBRETRO_VERSION_ATLEAST(X, Y, Z) (SDL_LIBRETRO_VERSION >= SDL_VERSIONNUM(X, Y, Z))


typedef struct SDL_Libretro SDL_Libretro;


typedef enum SDL_LibretroFitMode {

    SDL_LIBRETRO_FIT_ASPECT = 0,

    SDL_LIBRETRO_FIT_INTEGER = 1,

    SDL_LIBRETRO_FIT_STRETCH = 2

} SDL_LibretroFitMode;


#ifdef __cplusplus

extern "C" {

#endif


// Libretro Instance


SDL_Libretro* SDL_Libretro_Create(void);

void SDL_Libretro_Destroy(SDL_Libretro* lr);

int SDL_Libretro_Version(void);


// Directories


bool SDL_Libretro_SetCoreDirectory(SDL_Libretro* lr, const char* path);

bool SDL_Libretro_SetSaveDirectory(SDL_Libretro* lr, const char* path);

bool SDL_Libretro_SetSystemDirectory(SDL_Libretro* lr, const char* path);

bool SDL_Libretro_SetCoreAssetsDirectory(SDL_Libretro* lr, const char* path);

const char* SDL_Libretro_GetCoreDirectory(SDL_Libretro* lr);

const char* SDL_Libretro_GetSaveDirectory(SDL_Libretro* lr);

const char* SDL_Libretro_GetSystemDirectory(SDL_Libretro* lr);

const char* SDL_Libretro_GetCoreAssetsDirectory(SDL_Libretro* lr);

bool SDL_Libretro_SetUsername(SDL_Libretro* lr, const char* username);

const char* SDL_Libretro_GetUsername(SDL_Libretro* lr);


// Config


bool SDL_Libretro_InitConfig(SDL_Libretro* lr, const char* org, const char* app);

bool SDL_Libretro_InitConfigFile(SDL_Libretro* lr, const char* file);


// Core


bool SDL_Libretro_LoadCore(SDL_Libretro* lr, const char* corePath);

void SDL_Libretro_UnloadCore(SDL_Libretro* lr);

bool SDL_Libretro_IsCoreReady(const SDL_Libretro* lr);

bool SDL_Libretro_ShouldQuit(const SDL_Libretro* lr);


// Game


bool SDL_Libretro_LoadGame(SDL_Libretro* lr, const char* gamePath);

void SDL_Libretro_UnloadGame(SDL_Libretro* lr);

bool SDL_Libretro_IsGameReady(const SDL_Libretro* lr);

bool SDL_Libretro_IsGameRequired(const SDL_Libretro* lr);

bool SDL_Libretro_Reset(SDL_Libretro* lr);

void SDL_Libretro_Update(SDL_Libretro* lr);


// Video


bool SDL_Libretro_SetRenderer(SDL_Libretro* lr, SDL_Renderer* renderer);

SDL_Renderer* SDL_Libretro_GetRenderer(const SDL_Libretro* lr);

SDL_Texture* SDL_Libretro_GetTexture(const SDL_Libretro* lr);

SDL_Surface* SDL_Libretro_CreateSurface(const SDL_Libretro* lr);

bool SDL_Libretro_Render(SDL_Renderer* renderer, SDL_Libretro* lr, const SDL_FRect* dstRect);

void SDL_Libretro_GetSize(const SDL_Libretro* lr, int* w, int* h);

float SDL_Libretro_GetAspectRatio(const SDL_Libretro* lr);

double SDL_Libretro_GetFPS(const SDL_Libretro* lr);

int SDL_Libretro_GetRotation(const SDL_Libretro* lr);

void SDL_Libretro_SetFitMode(SDL_Libretro* lr, SDL_LibretroFitMode mode);

SDL_LibretroFitMode SDL_Libretro_GetFitMode(const SDL_Libretro* lr);


// Audio


void SDL_Libretro_SetVolume(SDL_Libretro* lr, float volume);

float SDL_Libretro_GetVolume(const SDL_Libretro* lr);

void SDL_Libretro_SetSpeed(SDL_Libretro* lr, float speed);

float SDL_Libretro_GetSpeed(const SDL_Libretro* lr);

void SDL_Libretro_SetAudioLatency(SDL_Libretro* lr, unsigned latencyMs);

unsigned SDL_Libretro_GetAudioLatency(const SDL_Libretro* lr);

double SDL_Libretro_GetSampleRate(const SDL_Libretro* lr);


// Input


void SDL_Libretro_HandleEvent(SDL_Libretro* lr, const SDL_Event* event);

bool SDL_Libretro_SetPortDevice(SDL_Libretro* lr, unsigned port, unsigned device);

unsigned SDL_Libretro_GetPortDevice(const SDL_Libretro* lr, unsigned port);

void SDL_Libretro_SetKeyboardMapping(SDL_Libretro* lr, int retroButton, SDL_Scancode scancode);

void SDL_Libretro_SetVirtualButton(SDL_Libretro* lr, unsigned port, int button, bool pressed);

unsigned SDL_Libretro_GetInputDescriptorCount(const SDL_Libretro* lr);

bool SDL_Libretro_GetInputDescriptor(const SDL_Libretro* lr, unsigned index, unsigned* port, unsigned* device, unsigned* id, const char** description);


// Save States


size_t SDL_Libretro_GetStateSize(const SDL_Libretro* lr);

bool SDL_Libretro_SaveState(SDL_Libretro* lr, const char* file);

bool SDL_Libretro_SaveState_IO(SDL_Libretro* lr, SDL_IOStream* dst, bool closeio);

bool SDL_Libretro_LoadState(SDL_Libretro* lr, const char* file);

bool SDL_Libretro_LoadState_IO(SDL_Libretro* lr, SDL_IOStream* src, bool closeio);


// Memory


bool SDL_Libretro_SaveMemory(SDL_Libretro* lr, unsigned memoryType, const char* file);

bool SDL_Libretro_SaveMemory_IO(SDL_Libretro* lr, unsigned memoryType, SDL_IOStream* dst, bool closeio);

bool SDL_Libretro_LoadMemory(SDL_Libretro* lr, unsigned memoryType, const char* file);

bool SDL_Libretro_LoadMemory_IO(SDL_Libretro* lr, unsigned memoryType, SDL_IOStream* src, bool closeio);

void* SDL_Libretro_GetMemoryData(const SDL_Libretro* lr, unsigned memoryType, size_t* size);

bool SDL_Libretro_SetMemoryData(SDL_Libretro* lr, unsigned memoryType, const void* data, size_t size);

bool SDL_Libretro_SaveSRAM(SDL_Libretro* lr, const char* file);

bool SDL_Libretro_SaveSRAM_IO(SDL_Libretro* lr, SDL_IOStream* dst, bool closeio);

bool SDL_Libretro_LoadSRAM(SDL_Libretro* lr, const char* file);

bool SDL_Libretro_LoadSRAM_IO(SDL_Libretro* lr, SDL_IOStream* src, bool closeio);

unsigned SDL_Libretro_GetMemoryMapCount(const SDL_Libretro* lr);

bool SDL_Libretro_GetMemoryMapDescriptor(const SDL_Libretro* lr, unsigned index,

    Uint64* flags, void** ptr, size_t* offset, size_t* start,

    size_t* select, size_t* disconnect, size_t* len, const char** addrspace);

void* SDL_Libretro_GetMapAddress(const SDL_Libretro* lr, size_t address, size_t* regionRemaining);


// Core Options


typedef struct SDL_LibretroOptionValue {

    const char* value;

    const char* label;

} SDL_LibretroOptionValue;


typedef struct SDL_LibretroOption {

    const char* key;

    const char* desc;

    const char* info;

    const char* value;

    const char* defaultValue;

    const char* category;

    bool visible;

    unsigned valuesCount;

    SDL_LibretroOptionValue* values;

    unsigned valuesCapacity;

} SDL_LibretroOption;


typedef struct SDL_LibretroCategory {

    const char* key;

    const char* desc;

    const char* info;

} SDL_LibretroCategory;


unsigned SDL_Libretro_GetOptionCount(const SDL_Libretro* lr);

const SDL_LibretroOption* SDL_Libretro_GetOption(const SDL_Libretro* lr, const char* key);

const SDL_LibretroOption* SDL_Libretro_GetOptionByIndex(const SDL_Libretro* lr, unsigned index);

bool SDL_Libretro_SetOptionValue(SDL_Libretro* lr, const char* key, const char* value);

const char* SDL_Libretro_GetOptionValue(SDL_Libretro* lr, const char* key);

const char* SDL_Libretro_GetOptionValueLabel(SDL_Libretro* lr, const char* key);

bool SDL_Libretro_CycleOptionValue(SDL_Libretro* lr, const char* key, int direction);

bool SDL_Libretro_ResetOption(SDL_Libretro* lr, const char* key);

void SDL_Libretro_ResetAllOptions(SDL_Libretro* lr);

bool SDL_Libretro_AreOptionsDirty(SDL_Libretro* lr);

bool SDL_Libretro_UpdateOptionVisibility(SDL_Libretro* lr);

unsigned SDL_Libretro_GetCategoryCount(const SDL_Libretro* lr);

const SDL_LibretroCategory* SDL_Libretro_GetCategory(const SDL_Libretro* lr, const char* key);

const SDL_LibretroCategory* SDL_Libretro_GetCategoryByIndex(const SDL_Libretro* lr, unsigned index);


// Cheats


bool SDL_Libretro_SetCheat(SDL_Libretro* lr, unsigned index, bool enabled, const char* code);

void SDL_Libretro_ResetCheats(SDL_Libretro* lr);


// Meta Data


const char* SDL_Libretro_GetCoreName(const SDL_Libretro* lr);

const char* SDL_Libretro_GetCoreVersion(const SDL_Libretro* lr);

const char* SDL_Libretro_GetValidExtensions(const SDL_Libretro* lr);

const char* SDL_Libretro_GetContentExtension(const SDL_Libretro* lr);

unsigned SDL_Libretro_GetPerformanceLevel(const SDL_Libretro* lr);


// Utilities


size_t SDL_Libretro_GetFileName(char* dst, size_t dstSize, const char* path, bool withExtension);

size_t SDL_Libretro_GetSavePath(const SDL_Libretro* lr, const char* extension, char* dst, size_t dstSize);


// Rewind


bool SDL_Libretro_SetRewindEnabled(SDL_Libretro* lr, bool enabled, unsigned bufferFrames, unsigned captureInterval);

bool SDL_Libretro_GetRewindEnabled(const SDL_Libretro* lr);

double SDL_Libretro_GetRewindRemaining(const SDL_Libretro* lr);

size_t SDL_Libretro_GetRewindMemoryUsage(const SDL_Libretro* lr);

void SDL_Libretro_SetRewindMemoryLimit(SDL_Libretro* lr, size_t maxBytes);

size_t SDL_Libretro_GetRewindMemoryLimit(const SDL_Libretro* lr);

bool SDL_Libretro_SetRewindMemoryDuration(SDL_Libretro* lr, double seconds);


// VFS


void SDL_Libretro_SetVFS(SDL_Libretro* lr, void* vfs);


// Logging


void SDL_Libretro_SetLogLevel(SDL_Libretro* lr, SDL_LogPriority level);

SDL_LogPriority SDL_Libretro_GetLogLevel(const SDL_Libretro* lr);


// On-Screen Display


void SDL_Libretro_SetMessage(SDL_Libretro* lr, const char* msg, double duration);

const char* SDL_Libretro_GetMessage(SDL_Libretro* lr);

int SDL_Libretro_GetMessageProgress(SDL_Libretro* lr);

int SDL_Libretro_GetMessageType(SDL_Libretro* lr);

unsigned SDL_Libretro_GetMessageCount(SDL_Libretro* lr);

bool SDL_Libretro_GetMessageByIndex(SDL_Libretro* lr, unsigned index, const char** msg, int* progress, int* type);


#ifdef __cplusplus

}

#endif


/* ===================================================================== */

/*  Implementation                                                       */

/* ===================================================================== */

#ifdef SDL_LIBRETRO_IMPLEMENTATION

#ifndef SDL_LIBRETRO_IMPLEMENTATION_ONCE

#define SDL_LIBRETRO_IMPLEMENTATION_ONCE


#include "libretro.h"


#ifndef SDL_LIBRETRO_NO_INI_IMPLEMENTATION

#define SDL_INI_IMPLEMENTATION

#include "SDL_ini.h"

#endif


#define SDL_LIBRETRO_MAX_PATH 4096

#define SDL_LIBRETRO_AUDIO_SINGLE_SAMPLE_BUFFER_SIZE 512

#define SDL_LIBRETRO_RUMBLE_PORTS 4

#define SDL_LIBRETRO_SENSOR_PORTS 4

#define SDL_LIBRETRO_OSD_INITIAL_CAPACITY 8


typedef struct SDL_Libretro_CoreInfo {

    char* corename;

    char* supported_extensions;

    char* path;

    bool needs_fullpath;

    bool supports_no_game;

} SDL_Libretro_CoreInfo;


typedef struct SDL_LibretroOsdEntry {

    char* msg;

    Uint64 endTimeMs;

    unsigned priority;

    enum retro_message_type type;

    int8_t progress;

} SDL_LibretroOsdEntry;


typedef struct SDL_LibretroCoreSymbols {

    SDL_SharedObject* handle;

    void (*retro_init)(void);

    void (*retro_deinit)(void);

    unsigned (*retro_api_version)(void);

    void (*retro_set_environment)(retro_environment_t);

    void (*retro_set_video_refresh)(retro_video_refresh_t);

    void (*retro_set_audio_sample)(retro_audio_sample_t);

    void (*retro_set_audio_sample_batch)(retro_audio_sample_batch_t);

    void (*retro_set_input_poll)(retro_input_poll_t);

    void (*retro_set_input_state)(retro_input_state_t);

    void (*retro_get_system_info)(struct retro_system_info*);

    void (*retro_get_system_av_info)(struct retro_system_av_info*);

    void (*retro_set_controller_port_device)(unsigned port, unsigned device);

    void (*retro_reset)(void);

    void (*retro_run)(void);

    size_t (*retro_serialize_size)(void);

    bool (*retro_serialize)(void*, size_t);

    bool (*retro_unserialize)(const void*, size_t);

    void (*retro_cheat_reset)(void);

    void (*retro_cheat_set)(unsigned index, bool enabled, const char* code);

    bool (*retro_load_game)(const struct retro_game_info*);

    bool (*retro_load_game_special)(unsigned, const struct retro_game_info*, size_t);

    void (*retro_unload_game)(void);

    unsigned (*retro_get_region)(void);

    void* (*retro_get_memory_data)(unsigned);

    size_t (*retro_get_memory_size)(unsigned);

} SDL_LibretroCoreSymbols;


typedef struct SDL_LibretroMicrophone {

    SDL_AudioStream* stream;

    unsigned rate;

    bool active;

    SDL_Libretro* lr;

} SDL_LibretroMicrophone;


typedef struct SDL_LibretroCoreData {

    SDL_LibretroCoreSymbols symbols;


    bool loaded;

    bool gameLoaded;

    bool shutdown;

    unsigned width, height;

    double fps;

    double sampleRate;

    float aspectRatio;

    char corePath[SDL_LIBRETRO_MAX_PATH];

    char libraryName[128];

    char libraryVersion[128];

    char validExtensions[128];

    bool needFullpath;

    bool supportNoGame;

    unsigned apiVersion;

    enum retro_pixel_format pixelFormat;

    unsigned performanceLevel;

    uint64_t serializationQuirks;

    int rotation;


    // Video

    SDL_Texture* texture;

    SDL_ScaleMode textureScaleMode;

    SDL_FRect renderDstRect;

    bool videoReinitPending;

    void* softwareFramebufferPixels;


    // Audio

    SDL_AudioStream* audioStream;

    int audioQueueThresholdBytes;

    unsigned minimumAudioLatencyMs;

    int16_t singleSampleBuffer[SDL_LIBRETRO_AUDIO_SINGLE_SAMPLE_BUFFER_SIZE * 2];

    size_t singleSampleCount;

    int audioDropWarnCount;

    bool audioReinitPending;

    struct retro_audio_callback audio_callback;

    struct retro_audio_buffer_status_callback audio_buffer_status;

    // Input

    float inputLastMouseX, inputLastMouseY;

    float inputMouseX, inputMouseY;

    unsigned portDeviceMap[16];

    bool virtualJoypadState[16];

    retro_keyboard_event_t keyboard_event;


    // Timing

    struct retro_frame_time_callback runloop_frame_time;

    retro_usec_t runloop_frame_time_last;


    // Core Options

    SDL_LibretroOption* options;

    unsigned optionCount;

    unsigned optionCapacity;

    bool optionsDirty;

    retro_core_options_update_display_callback_t optionsUpdateDisplayCallback;

    SDL_LibretroCategory* optionCategories;

    unsigned optionCategoryCount;

    unsigned optionCategoryCapacity;


    // Input Descriptors

    struct retro_input_descriptor* inputDescriptors;

    unsigned inputDescriptorCount;

    struct retro_controller_info* controllerInfo;

    unsigned controllerPortCount;


    // Game Content

    char contentPath[SDL_LIBRETRO_MAX_PATH];

    char contentName[SDL_LIBRETRO_MAX_PATH];

    char contentDir[SDL_LIBRETRO_MAX_PATH];

    char contentExt[8];

    struct retro_game_info_ext gameInfoExt;

    // Content Info Overrides

    struct retro_system_content_info_override* contentInfoOverrides;

    unsigned contentInfoOverrideCount;

    // Rumble

    float rumbleStrong[SDL_LIBRETRO_RUMBLE_PORTS];

    float rumbleWeak[SDL_LIBRETRO_RUMBLE_PORTS];


    // Sensors

    SDL_Sensor* sensorAccel[SDL_LIBRETRO_SENSOR_PORTS];

    SDL_Sensor* sensorGyro[SDL_LIBRETRO_SENSOR_PORTS];

    float sensorAccelData[SDL_LIBRETRO_SENSOR_PORTS][3];

    float sensorGyroData[SDL_LIBRETRO_SENSOR_PORTS][3];


    // Microphone

    SDL_LibretroMicrophone* microphone;


    // Disk control

    struct retro_disk_control_ext_callback disk_control;

    bool diskControlActive;


    // Memory Maps

    struct retro_memory_descriptor* memoryMapDescriptors;

    unsigned memoryMapDescriptorCount;


    // Dynamic Rate Control

    bool drcEnabled;

    float drcAdjustment;

    double drcDriftAvg;


    // Performance Counter

    struct retro_perf_counter* perfCounters[64];

    unsigned perfCounterCount;

    retro_perf_tick_t gameTimeNSEC;

} SDL_LibretroCoreData;


typedef struct SDL_LibretroRewindDelta {

    unsigned char* data;

    size_t length;   /* used bytes of the encoded delta */

    size_t capacity; /* allocated bytes of data (>= length); enables in-place reuse */

} SDL_LibretroRewindDelta;


struct SDL_Libretro {

    // Persistent Settings Across Cores

    float volume;

    float speed;

    SDL_LibretroFitMode fitMode;

    double speedAccumulator;

    Uint64 lastTickNS; /* Wall-clock of the previous RunFrame (SDL_GetTicksNS); 0 until first call. */

    SDL_Scancode keyboardPlayer1[RETRO_DEVICE_ID_JOYPAD_R3 + 1];

    char coreDirectory[SDL_LIBRETRO_MAX_PATH];

    char saveDirectory[SDL_LIBRETRO_MAX_PATH];

    char systemDirectory[SDL_LIBRETRO_MAX_PATH];

    char coreAssetsDirectory[SDL_LIBRETRO_MAX_PATH];

    char playlistDirectory[SDL_LIBRETRO_MAX_PATH];

    char fileBrowserStartDirectory[SDL_LIBRETRO_MAX_PATH];

    char username[64];


    // Render target (persists across cores/games; set via SDL_Libretro_SetRenderer)

    SDL_Renderer* renderer;

    SDL_Window* window;

    // Logging

    enum retro_log_level logLevel;


    // On-Screen Display Message Queue

    SDL_LibretroOsdEntry* osdQueue;

    int osdQueueCount;

    int osdQueueCapacity;


    // Virtual File System

    struct retro_vfs_interface vfs_interface;


    // Rewind (delta-compressed circular buffer)

    unsigned char* rewindReference;

    unsigned char* rewindScratch;

    unsigned char* rewindEncodeScratch; /* reusable worst-case-sized buffer for one-pass delta encoding */

    SDL_LibretroRewindDelta* rewindEntries;

    size_t rewindSlotSize;

    size_t rewindBytes;    /* live encoded delta bytes currently stored */

    size_t rewindMaxBytes; /* memory budget for delta data; 0 = unbounded */

    unsigned rewindCapacity;

    unsigned rewindHead;

    unsigned rewindCount;

    unsigned rewindCaptureInterval;

    unsigned rewindFrameCounter;

    bool rewindEnabled;

    bool rewindHasReference;

    bool rewindActive; /* true only during a backward step's re-run (mutes audio, neutralizes input) */


    /* SDL gamepads (opened handles, indexed by port) */

    SDL_Gamepad* gamepads[16];

    unsigned gamepadCount;


    SDL_LibretroCoreData core;

    // Configuration

    char* iniFile;

    SDL_ini* ini;


    // Core Library

    SDL_Libretro_CoreInfo* coreLibrary;

    unsigned coreLibraryCount;

    void* userData;

};


static SDL_Libretro* SDL_Libretro_active = NULL;


static bool SDL_Libretro_InitVideo(SDL_Libretro* lr);

static void SDL_Libretro_CloseVideo(SDL_Libretro* lr);

static void SDL_Libretro_VideoRefresh(const void* data, unsigned width, unsigned height, size_t pitch);

static void SDL_Libretro_ReleaseSoftwareFramebuffer(SDL_Libretro* lr);


static void SDL_Libretro_AudioSample(int16_t left, int16_t right);

static size_t SDL_Libretro_AudioSampleBatch(const int16_t* data, size_t frames);

static void SDL_Libretro_FlushSingleSamples(SDL_Libretro* lr);

static void SDL_Libretro_UpdateDRC(SDL_Libretro* lr, float speed);

static unsigned SDL_Libretro_UpdateAudioThreshold(SDL_Libretro* lr);

static void SDL_Libretro_ReportAudioBufferStatus(SDL_Libretro* lr);


static bool SDL_Libretro_InitAudio(SDL_Libretro* lr);

static void SDL_Libretro_CloseAudio(SDL_Libretro* lr);

static void SDL_Libretro_InputPoll(void);

static int16_t SDL_Libretro_InputState(unsigned port, unsigned device, unsigned index, unsigned id);

static bool SDL_Libretro_RewindStep(SDL_Libretro* lr);


static void SDL_Libretro_OsdPush(SDL_Libretro* lr, const char* msg, double durationSec, unsigned priority, enum retro_message_type type, int8_t progress);

static void SDL_Libretro_FreeMessages(SDL_Libretro* lr);

static bool SDL_Libretro_EnvironmentCallback(unsigned cmd, void* data);

static void SDL_Libretro_ClearRewind(SDL_Libretro* lr);


static SDL_Scancode SDL_Libretro_RetroKeyToScancode(unsigned key);

static unsigned SDL_Libretro_ScancodeToRetroKey(SDL_Scancode scancode);

static uint16_t SDL_Libretro_KeymodToRetroMod(SDL_Keymod mod);

static SDL_GamepadButton SDL_Libretro_RetroJoypadToGamepadButton(unsigned button);


// Sensors

static bool SDL_Libretro_SetSensorState(unsigned port, enum retro_sensor_action action, unsigned rate);

static float SDL_Libretro_GetSensorInput(unsigned port, unsigned id);

static void SDL_Libretro_CloseSensors(SDL_Libretro* lr);


// Microphone

static retro_microphone_t* SDL_Libretro_MicOpen(const retro_microphone_params_t* params);

static void SDL_Libretro_MicClose(retro_microphone_t* microphone);

static bool SDL_Libretro_MicGetParams(const retro_microphone_t* microphone, retro_microphone_params_t* params);

static bool SDL_Libretro_MicSetState(retro_microphone_t* microphone, bool state);

static bool SDL_Libretro_MicGetState(const retro_microphone_t* microphone);

static int SDL_Libretro_MicRead(retro_microphone_t* microphone, int16_t* samples, size_t num_samples);

static void SDL_Libretro_CloseMicrophone(SDL_Libretro* lr);


#ifdef SDL_LIBRETRO_ENABLE_REWIND_DELTA

static size_t SDL_Libretro_RewindEncodeDelta(const unsigned char* cur, const unsigned char* ref, size_t len, unsigned char* out, size_t outCap);

static bool SDL_Libretro_RewindDecodeDelta(const unsigned char* delta, size_t deltaLen, unsigned char* state, size_t stateLen);

#endif

static void SDL_Libretro_RewindCapture(SDL_Libretro* lr);

static bool SDL_Libretro_RewindStepState(SDL_Libretro* lr);

static void SDL_Libretro_RewindFreeEntry(SDL_Libretro* lr, SDL_LibretroRewindDelta* entry);

static void SDL_Libretro_RewindEvictToBudget(SDL_Libretro* lr);

static void SDL_Libretro_RewindFree(SDL_Libretro* lr);


static bool SDL_Libretro_ExtensionInList(const char* ext, const char* pipeList);


static void SDL_Libretro_InitCoreOption(SDL_Libretro* lr, const char* key, const char* defaultValue,

    const char* desc, const struct retro_core_option_value* values,

    const char* info, const char* categoryKey);

static void SDL_Libretro_InitCoreOptionCategory(SDL_Libretro* lr, const char* key,

    const char* desc, const char* info);

static void SDL_Libretro_FreeCoreOptions(SDL_Libretro* lr);


static void SDL_Libretro_FreeMemoryMap(SDL_Libretro* lr);

static void SDL_Libretro_FreeContentInfoOverrides(SDL_Libretro* lr);


// Directory


static void SDL_Libretro_FreeCoreLibrary(SDL_Libretro* lr);


// Config


static bool SDL_Libretro_LoadCoreConfig(SDL_Libretro* lr);

static bool SDL_Libretro_SaveCoreConfig(SDL_Libretro* lr);

static bool SDL_Libretro_CloseConfig(SDL_Libretro* lr);


#include "SDL_libretro_video.h"

#include "SDL_libretro_audio.h"

#include "SDL_libretro_input.h"

#include "SDL_libretro_options.h"

#include "SDL_libretro_serialize.h"

#include "SDL_libretro_vfs.h"

#include "SDL_libretro_messages.h"

#include "SDL_libretro_env.h"

#include "SDL_libretro_core.h"

#include "SDL_libretro_config.h"


#endif /* SDL_LIBRETRO_IMPLEMENTATION_ONCE */

#endif /* SDL_LIBRETRO_IMPLEMENTATION */


#endif /* SDL_LIBRETRO_H */

SDL_libretro_audio.h
SDL_libretro - audio subsystem.

SDL_libretro_config.h
SDL_libretro config saving/loading.

SDL_libretro_core.h
SDL_libretro - core lifecycle implementation.

SDL_libretro_env.h
SDL_libretro environment callback dispatch.

SDL_libretro_input.h
SDL_libretro - input subsystem.

SDL_libretro_messages.h
SDL_libretro - on-screen display message queue.

SDL_libretro_options.h
SDL_libretro - core options management.

SDL_libretro_serialize.h
SDL_libretro - save states, core memory (SRAM/RTC/...), and rewind.

SDL_libretro_vfs.h
SDL_libretro - SDL3 Virtual File System interface for libretro.

SDL_libretro_video.h
SDL_libretro - Video System.

SDL_Libretro_SetMessage
void SDL_Libretro_SetMessage(SDL_Libretro *lr, const char *msg, double duration)
Add a message to be displayed within the libretro context.
Definition SDL_libretro_messages.h:89

SDL_Libretro_SaveState_IO
bool SDL_Libretro_SaveState_IO(SDL_Libretro *lr, SDL_IOStream *dst, bool closeio)
Save the current libretro state to the given SDL_IOStream.
Definition SDL_libretro_serialize.h:60

SDL_Libretro_CycleOptionValue
bool SDL_Libretro_CycleOptionValue(SDL_Libretro *lr, const char *key, int direction)
Advance a core option to the next (+1) or previous (-1) value.
Definition SDL_libretro_options.h:225

SDL_Libretro_Render
bool SDL_Libretro_Render(SDL_Renderer *renderer, SDL_Libretro *lr, const SDL_FRect *dstRect)
Render the libretro context in the given renderer.
Definition SDL_libretro_video.h:268

SDL_Libretro_GetSavePath
size_t SDL_Libretro_GetSavePath(const SDL_Libretro *lr, const char *extension, char *dst, size_t dstSize)
Build a path in the save directory for the currently loaded content.
Definition SDL_libretro_core.h:289

SDL_Libretro_SetCoreDirectory
bool SDL_Libretro_SetCoreDirectory(SDL_Libretro *lr, const char *path)
Sets the associated libretro core directory, where the default set of cores will be loaded from.
Definition SDL_libretro_core.h:821

SDL_Libretro_SetRewindMemoryLimit
void SDL_Libretro_SetRewindMemoryLimit(SDL_Libretro *lr, size_t maxBytes)
Set the maximum number of bytes of encoded delta history to retain.
Definition SDL_libretro_serialize.h:763

SDL_Libretro_SaveSRAM
bool SDL_Libretro_SaveSRAM(SDL_Libretro *lr, const char *file)
Saves the current SRAM to the given file.
Definition SDL_libretro_serialize.h:455

SDL_Libretro_CreateSurface
SDL_Surface * SDL_Libretro_CreateSurface(const SDL_Libretro *lr)
Creates a new surface from the current libretro context.
Definition SDL_libretro_video.h:192

SDL_Libretro_GetContentExtension
const char * SDL_Libretro_GetContentExtension(const SDL_Libretro *lr)
Get the extension of the loaded content, as it appears in the path.
Definition SDL_libretro_core.h:995

SDL_Libretro_GetInputDescriptorCount
unsigned SDL_Libretro_GetInputDescriptorCount(const SDL_Libretro *lr)
Retrieve the number of input descriptors provided by a Libretro core.
Definition SDL_libretro_input.h:583

SDL_Libretro_LoadCore
bool SDL_Libretro_LoadCore(SDL_Libretro *lr, const char *corePath)
Loads a libretro core.
Definition SDL_libretro_core.h:113

SDL_Libretro_UnloadCore
void SDL_Libretro_UnloadCore(SDL_Libretro *lr)
Unloads the actively loaded core.
Definition SDL_libretro_core.h:212

SDL_Libretro_GetMemoryMapDescriptor
bool SDL_Libretro_GetMemoryMapDescriptor(const SDL_Libretro *lr, unsigned index, Uint64 *flags, void **ptr, size_t *offset, size_t *start, size_t *select, size_t *disconnect, size_t *len, const char **addrspace)
Retrieve one memory-map descriptor by index.
Definition SDL_libretro_serialize.h:232

SDL_Libretro_SetLogLevel
void SDL_Libretro_SetLogLevel(SDL_Libretro *lr, SDL_LogPriority level)
Sets the threshold for logs to be posted.
Definition SDL_libretro_core.h:929

SDL_LibretroFitMode
SDL_LibretroFitMode
When rendering the libretro context, determine how to display within the destination.
Definition SDL_libretro.h:85

SDL_Libretro_LoadSRAM
bool SDL_Libretro_LoadSRAM(SDL_Libretro *lr, const char *file)
Loads the current SRAM to the given file.
Definition SDL_libretro_serialize.h:466

SDL_Libretro_GetFileName
size_t SDL_Libretro_GetFileName(char *dst, size_t dstSize, const char *path, bool withExtension)
Copy the file name portion of a path into a caller-provided buffer.
Definition SDL_libretro_core.h:258

SDL_Libretro_AreOptionsDirty
bool SDL_Libretro_AreOptionsDirty(SDL_Libretro *lr)
Retrieves whether the options have been changed since the last time they were checked.
Definition SDL_libretro_options.h:273

SDL_Libretro_GetMemoryData
void * SDL_Libretro_GetMemoryData(const SDL_Libretro *lr, unsigned memoryType, size_t *size)
Get a pointer to a core memory region and its size.
Definition SDL_libretro_serialize.h:139

SDL_Libretro_GetPortDevice
unsigned SDL_Libretro_GetPortDevice(const SDL_Libretro *lr, unsigned port)
Get the device type assigned to a controller port.
Definition SDL_libretro_input.h:559

SDL_Libretro_GetCategoryByIndex
const SDL_LibretroCategory * SDL_Libretro_GetCategoryByIndex(const SDL_Libretro *lr, unsigned index)
Retrieve an option category by index, or NULL if out of range.
Definition SDL_libretro_options.h:308

SDL_Libretro_SetRewindEnabled
bool SDL_Libretro_SetRewindEnabled(SDL_Libretro *lr, bool enabled, unsigned bufferFrames, unsigned captureInterval)
Enable or disable the rewind system.
Definition SDL_libretro_serialize.h:637

SDL_Libretro_GetCoreVersion
const char * SDL_Libretro_GetCoreVersion(const SDL_Libretro *lr)
Retrieves the version of the libretro core that's actively loaded.
Definition SDL_libretro_core.h:964

SDL_Libretro_GetCategory
const SDL_LibretroCategory * SDL_Libretro_GetCategory(const SDL_Libretro *lr, const char *key)
Retrieve an option category by key, or NULL if there's no such category.
Definition SDL_libretro_options.h:295

SDL_Libretro_SetRewindMemoryDuration
bool SDL_Libretro_SetRewindMemoryDuration(SDL_Libretro *lr, double seconds)
Set the rewind memory budget by target duration instead of raw bytes.
Definition SDL_libretro_serialize.h:795

SDL_Libretro_GetPerformanceLevel
unsigned SDL_Libretro_GetPerformanceLevel(const SDL_Libretro *lr)
Get the performance level the core requested via SET_PERFORMANCE_LEVEL.
Definition SDL_libretro_core.h:983

SDL_Libretro_GetInputDescriptor
bool SDL_Libretro_GetInputDescriptor(const SDL_Libretro *lr, unsigned index, unsigned *port, unsigned *device, unsigned *id, const char **description)
Retrieve an input descriptor by index.
Definition SDL_libretro_input.h:605

SDL_Libretro_GetRewindMemoryUsage
size_t SDL_Libretro_GetRewindMemoryUsage(const SDL_Libretro *lr)
Get the approximate memory currently held by the rewind buffer, in bytes.
Definition SDL_libretro_serialize.h:743

SDL_Libretro_GetValidExtensions
const char * SDL_Libretro_GetValidExtensions(const SDL_Libretro *lr)
Gets the default set of valid extensions associated with the core, seperated by a "|".
Definition SDL_libretro_core.h:971

SDL_Libretro_GetCategoryCount
unsigned SDL_Libretro_GetCategoryCount(const SDL_Libretro *lr)
Get the number of option categories registered by the core.
Definition SDL_libretro_options.h:288

SDL_Libretro_InitConfig
bool SDL_Libretro_InitConfig(SDL_Libretro *lr, const char *org, const char *app)
Sets up the config file to be the default path, accoring to the organization and app name.
Definition SDL_libretro_config.h:80

SDL_Libretro_InitConfigFile
bool SDL_Libretro_InitConfigFile(SDL_Libretro *lr, const char *file)
Initializes the config system based on the given file.
Definition SDL_libretro_config.h:26

SDL_Libretro_GetMemoryMapCount
unsigned SDL_Libretro_GetMemoryMapCount(const SDL_Libretro *lr)
Get the number of memory-map descriptors the core has published.
Definition SDL_libretro_serialize.h:207

SDL_Libretro_GetMessage
const char * SDL_Libretro_GetMessage(SDL_Libretro *lr)
Gets the most relevent libretro message to display from the queue.
Definition SDL_libretro_messages.h:104

SDL_Libretro_GetOptionValueLabel
const char * SDL_Libretro_GetOptionValueLabel(SDL_Libretro *lr, const char *key)
Get the human-readable label for a core option's current value.
Definition SDL_libretro_options.h:211

SDL_Libretro_GetLogLevel
SDL_LogPriority SDL_Libretro_GetLogLevel(const SDL_Libretro *lr)
Retrieve the threshold for logs that will be posted.
Definition SDL_libretro_core.h:943

SDL_Libretro_LoadState
bool SDL_Libretro_LoadState(SDL_Libretro *lr, const char *file)
Loads the libretro state from the given file.
Definition SDL_libretro_serialize.h:115

SDL_Libretro_GetOptionByIndex
const SDL_LibretroOption * SDL_Libretro_GetOptionByIndex(const SDL_Libretro *lr, unsigned index)
Retrieve a core option by its registration index, or NULL if out of range.
Definition SDL_libretro_options.h:162

SDL_Libretro_SetVolume
void SDL_Libretro_SetVolume(SDL_Libretro *lr, float volume)
Set the audio volume when playing sounds.
Definition SDL_libretro_core.h:884

SDL_Libretro_GetStateSize
size_t SDL_Libretro_GetStateSize(const SDL_Libretro *lr)
Retrieves the size of serialized states.
Definition SDL_libretro_serialize.h:52

SDL_Libretro_SaveMemory
bool SDL_Libretro_SaveMemory(SDL_Libretro *lr, unsigned memoryType, const char *file)
Write a core memory region to a file.
Definition SDL_libretro_serialize.h:353

SDL_Libretro_GetOptionValue
const char * SDL_Libretro_GetOptionValue(SDL_Libretro *lr, const char *key)
Get a core option's current value, or NULL if there's no such option.
Definition SDL_libretro_options.h:199

SDL_Libretro_LoadGame
bool SDL_Libretro_LoadGame(SDL_Libretro *lr, const char *gamePath)
Loads a game at the given path.
Definition SDL_libretro_core.h:424

SDL_Libretro_GetAspectRatio
float SDL_Libretro_GetAspectRatio(const SDL_Libretro *lr)
Gets the aspect ratio for the libretro context.
Definition SDL_libretro_video.h:319

SDL_Libretro_GetRenderer
SDL_Renderer * SDL_Libretro_GetRenderer(const SDL_Libretro *lr)
Get the renderer the context draws into.
Definition SDL_libretro_video.h:179

SDL_Libretro_ShouldQuit
bool SDL_Libretro_ShouldQuit(const SDL_Libretro *lr)
Indicates whether or not the core has requested to shutdown.
Definition SDL_libretro_core.h:726

SDL_Libretro_LoadMemory_IO
bool SDL_Libretro_LoadMemory_IO(SDL_Libretro *lr, unsigned memoryType, SDL_IOStream *src, bool closeio)
Load a core memory region from a stream.
Definition SDL_libretro_serialize.h:388

SDL_Libretro_ResetOption
bool SDL_Libretro_ResetOption(SDL_Libretro *lr, const char *key)
Reset a core option to its default value.
Definition SDL_libretro_options.h:248

SDL_Libretro_SetAudioLatency
void SDL_Libretro_SetAudioLatency(SDL_Libretro *lr, unsigned latencyMs)
Set the desired minimum audio latency for the audio stream.
Definition SDL_libretro_audio.h:260

SDL_Libretro_Destroy
void SDL_Libretro_Destroy(SDL_Libretro *lr)
Destroys the given libretro context.
Definition SDL_libretro_core.h:64

SDL_Libretro_LoadMemory
bool SDL_Libretro_LoadMemory(SDL_Libretro *lr, unsigned memoryType, const char *file)
Load a core memory region from a file.
Definition SDL_libretro_serialize.h:431

SDL_Libretro_Create
SDL_Libretro * SDL_Libretro_Create(void)
Builds a libretro context.
Definition SDL_libretro_core.h:24

SDL_Libretro_GetRewindEnabled
bool SDL_Libretro_GetRewindEnabled(const SDL_Libretro *lr)
Check whether the rewind system is enabled (independent of current direction).
Definition SDL_libretro_serialize.h:718

SDL_Libretro_UnloadGame
void SDL_Libretro_UnloadGame(SDL_Libretro *lr)
Unloads the actively loaded game.
Definition SDL_libretro_core.h:559

SDL_Libretro_SetOptionValue
bool SDL_Libretro_SetOptionValue(SDL_Libretro *lr, const char *key, const char *value)
Set a core option's value; fails if the value isn't one the core declared.
Definition SDL_libretro_options.h:170

SDL_Libretro_ResetAllOptions
void SDL_Libretro_ResetAllOptions(SDL_Libretro *lr)
Reset every core option to its default value.
Definition SDL_libretro_options.h:260

SDL_Libretro_SaveState
bool SDL_Libretro_SaveState(SDL_Libretro *lr, const char *file)
Saves the current libretro state to a file.
Definition SDL_libretro_serialize.h:85

SDL_Libretro_GetRewindMemoryLimit
size_t SDL_Libretro_GetRewindMemoryLimit(const SDL_Libretro *lr)
Get the current rewind memory budget in bytes (0 if unbounded).
Definition SDL_libretro_serialize.h:775

SDL_Libretro_GetSize
void SDL_Libretro_GetSize(const SDL_Libretro *lr, int *w, int *h)
Gets the width and heigh tof the given libretro context.
Definition SDL_libretro_video.h:311

SDL_Libretro_SetMemoryData
bool SDL_Libretro_SetMemoryData(SDL_Libretro *lr, unsigned memoryType, const void *data, size_t size)
Overwrite a core memory region with caller-provided bytes.
Definition SDL_libretro_serialize.h:162

SDL_Libretro_GetRewindRemaining
double SDL_Libretro_GetRewindRemaining(const SDL_Libretro *lr)
Calculates the amount of rewind time remaining in the buffer.
Definition SDL_libretro_serialize.h:728

SDL_Libretro_GetOptionCount
unsigned SDL_Libretro_GetOptionCount(const SDL_Libretro *lr)
Get the number of core options that have been set.
Definition SDL_libretro_options.h:142

SDL_Libretro_GetMapAddress
void * SDL_Libretro_GetMapAddress(const SDL_Libretro *lr, size_t address, size_t *regionRemaining)
Translate an emulated (guest) address to a live host pointer via the memory map.
Definition SDL_libretro_serialize.h:272

SDL_Libretro_SetRenderer
bool SDL_Libretro_SetRenderer(SDL_Libretro *lr, SDL_Renderer *renderer)
Set the renderer the libretro context draws into.
Definition SDL_libretro_video.h:152

SDL_Libretro_HandleEvent
void SDL_Libretro_HandleEvent(SDL_Libretro *lr, const SDL_Event *event)
Call this function within the SDL_PollEvent() loop to ensure libretro knows of important events.
Definition SDL_libretro_input.h:484

SDL_Libretro_SaveMemory_IO
bool SDL_Libretro_SaveMemory_IO(SDL_Libretro *lr, unsigned memoryType, SDL_IOStream *dst, bool closeio)
Write a core memory region to a stream.
Definition SDL_libretro_serialize.h:325

SDL_Libretro_GetOption
const SDL_LibretroOption * SDL_Libretro_GetOption(const SDL_Libretro *lr, const char *key)
Retrieve details about a given core option.
Definition SDL_libretro_options.h:149

SDL_Libretro_SetFitMode
void SDL_Libretro_SetFitMode(SDL_Libretro *lr, SDL_LibretroFitMode mode)
Sets the desired scale mode for the libretro context when it's displayed.
Definition SDL_libretro_video.h:334

SDL_Libretro_GetCoreName
const char * SDL_Libretro_GetCoreName(const SDL_Libretro *lr)
Retrieve the name of the libretro core that's actively loaded.
Definition SDL_libretro_core.h:957

SDL_LIBRETRO_FIT_STRETCH
@ SDL_LIBRETRO_FIT_STRETCH
Keep the same aspect ratio, while keeping integer scaling within the confines of the destination.
Definition SDL_libretro.h:88

SDL_LIBRETRO_FIT_INTEGER
@ SDL_LIBRETRO_FIT_INTEGER
Keep the same aspect ratio, and fit within the confines of the destination.
Definition SDL_libretro.h:87

SDL_LibretroCategory
A group of related core options.
Definition SDL_libretro.h:224

SDL_LibretroCategory::desc
const char * desc
Unique identifier referenced by SDL_LibretroOption::category.
Definition SDL_libretro.h:226

SDL_LibretroCategory::info
const char * info
Human-readable name.
Definition SDL_libretro.h:227

SDL_LibretroMicrophone
Definition SDL_libretro.h:367

SDL_LibretroMicrophone::lr
SDL_Libretro * lr
Whether or not the micropohne device is active.
Definition SDL_libretro.h:371

SDL_LibretroMicrophone::active
bool active
The sample rate.
Definition SDL_libretro.h:370

SDL_LibretroOption
A core option and its current state.
Definition SDL_libretro.h:208

SDL_LibretroOption::visible
bool visible
Key of the category it belongs to; empty if none.
Definition SDL_libretro.h:215

SDL_LibretroOption::values
SDL_LibretroOptionValue * values
The number of populated entries in values.
Definition SDL_libretro.h:217

SDL_LibretroOption::valuesCapacity
unsigned valuesCapacity
The selectable values; dynamically allocated.
Definition SDL_libretro.h:218

SDL_LibretroOption::desc
const char * desc
Unique identifier the core queries.
Definition SDL_libretro.h:210

SDL_LibretroOption::value
const char * value
Description / help text; may be empty.
Definition SDL_libretro.h:212

SDL_LibretroOption::category
const char * category
The default value.
Definition SDL_libretro.h:214

SDL_LibretroOption::valuesCount
unsigned valuesCount
Whether the frontend should display it.
Definition SDL_libretro.h:216

SDL_LibretroOption::defaultValue
const char * defaultValue
The current value.
Definition SDL_libretro.h:213

SDL_LibretroOption::info
const char * info
Human-readable name.
Definition SDL_libretro.h:211

SDL_LibretroOptionValue
One selectable value for a core option.
Definition SDL_libretro.h:200

SDL_LibretroOptionValue::label
const char * label
The value the core stores.
Definition SDL_libretro.h:202