rg_system: rg_system_init now takes a config struct

This will allow adding configuration options in the future without ever changing the function's signature.

Author: ducalex

components/retro-go/rg_system.c

@@ -278,7 +278,7 @@ static void system_monitor_task(void *arg)
 
         // Auto frameskip
         // TODO: Use a rolling average of frameTimes instead of this mess
-        if (app.tickRate > 0 && statistics.ticks > app.tickRate * 2)
+        if (app.tickRate > 0 && statistics.ticks > app.tickRate * 2 && app.frameskip > -1) // -1 disables auto frameskip
         {
             float speed = statistics.speedPercent / app.speed;
             // We don't fully go back to 0 frameskip because if we dip below 95% once, we're clearly
@@ -379,20 +379,7 @@ static void platform_init(void)
 #endif
 }
 
-rg_app_t *rg_system_reinit(int sampleRate, const rg_handlers_t *handlers, void *_unused)
-{
-    if (!app.initialized)
-        return rg_system_init(sampleRate, handlers, NULL);
-
-    app.sampleRate = sampleRate;
-    if (handlers)
-        app.handlers = *handlers;
-    rg_audio_set_sample_rate(app.sampleRate);
-
-    return &app;
-}
-
-rg_app_t *rg_system_init(int sampleRate, const rg_handlers_t *handlers, void *_unused)
+rg_app_t *rg_system_init(const rg_config_t *config)
 {
     RG_ASSERT(app.initialized == false, "rg_system_init() was already called.");
     bool enterRecoveryMode = false;
@@ -408,7 +395,7 @@ rg_app_t *rg_system_init(int sampleRate, const rg_handlers_t *handlers, void *_u
         .bootFlags = 0,
         .indicatorsMask = (1 << RG_INDICATOR_POWER_LOW),
         .speed = 1.f,
-        .sampleRate = sampleRate,
+        .sampleRate = 0,
         .tickRate = 60,
         .tickTimeout = 3000000,
         .frameTime = 1000000 / 60,
@@ -498,20 +485,40 @@ rg_app_t *rg_system_init(int sampleRate, const rg_handlers_t *handlers, void *_u
     app.romPath = app.bootArgs ?: ""; // For whatever reason some of our code isn't NULL-aware, sigh..
 
     rg_gui_draw_hourglass();
-    rg_audio_init(sampleRate);
 
-    rg_system_set_timezone(rg_settings_get_string(NS_GLOBAL, SETTING_TIMEZONE, "EST+5"));
-    rg_system_load_time();
+    if (config)
+    {
+        app.sampleRate = config->sampleRate;
+        app.tickRate = config->frameRate;
+        // app.frameskip = config->frameSkip;
+        if (config->mallocAlwaysInternal > 0)
+        {
+            #ifdef ESP_PLATFORM
+            heap_caps_malloc_extmem_enable(config->mallocAlwaysInternal);
+            #endif
+        }
+        if (config->storageRequired && !rg_storage_ready())
+        {
+            rg_display_clear(C_SKY_BLUE);
+            rg_gui_alert(_("SD Card Error"), _("Storage mount failed.\nMake sure the card is FAT32."));
+            rg_system_exit();
+        }
+        if (config->romRequired && !app.romPath && !*app.romPath)
+        {
+            // show rom picking dialog
+        }
+        app.isLauncher = config->isLauncher;
+        app.handlers = config->handlers;
+    }
 
-    // Do these last to not interfere with panic handling above
-    if (handlers)
-        app.handlers = *handlers;
+    if (app.sampleRate > 0)
+    {
+        rg_audio_init(app.sampleRate);
+    }
 
-#ifdef RG_ENABLE_PROFILING
-    RG_LOGI("Profiling has been enabled at compile time!\n");
-    profile = rg_alloc(sizeof(*profile), MEM_SLOW);
-    profile->lock = rg_mutex_create();
-#endif
+    rg_system_set_tick_rate(app.tickRate);
+    rg_system_set_timezone(rg_settings_get_string(NS_GLOBAL, SETTING_TIMEZONE, "EST+5"));
+    rg_system_load_time();
 
     if (app.lowMemoryMode)
         rg_gui_alert("External memory not detected", "Boot will continue but it will surely crash...");
@@ -522,6 +529,12 @@ rg_app_t *rg_system_init(int sampleRate, const rg_handlers_t *handlers, void *_u
     rg_task_create("rg_sysmon", &system_monitor_task, NULL, 3 * 1024, RG_TASK_PRIORITY_5, -1);
     app.initialized = true;
 
+#ifdef RG_ENABLE_PROFILING
+    RG_LOGI("Profiling has been enabled at compile time!");
+    profile = rg_alloc(sizeof(*profile), MEM_SLOW);
+    profile->lock = rg_mutex_create();
+#endif
+
     update_memory_statistics();
     RG_LOGI("Available memory: %d/%d + %d/%d", statistics.freeMemoryInt / 1024, statistics.totalMemoryInt / 1024,
             statistics.freeMemoryExt / 1024, statistics.totalMemoryExt / 1024);
@@ -530,6 +543,16 @@ rg_app_t *rg_system_init(int sampleRate, const rg_handlers_t *handlers, void *_u
     return &app;
 }
 
+rg_app_t *rg_system_reinit(int sampleRate, const rg_handlers_t *handlers, void *_unused)
+{
+    RG_ASSERT(app.initialized, "App not initialized");
+    rg_audio_set_sample_rate(app.sampleRate);
+    app.sampleRate = sampleRate;
+    if (handlers)
+        app.handlers = *handlers;
+    return &app;
+}
+
 // FIXME: None of this is threadsafe. It works for now, but eventually it needs fixing...
 
 #ifdef ESP_PLATFORM
@@ -810,7 +833,10 @@ rg_stats_t rg_system_get_stats(void)
 void rg_system_set_tick_rate(int tickRate)
 {
     app.tickRate = tickRate;
-    app.frameTime = 1000000 / (app.tickRate * app.speed);
+    if (tickRate > 0)
+        app.frameTime = 1000000 / (app.tickRate * app.speed);
+    else
+        app.frameTime = 1000000;
 }
 
 int rg_system_get_tick_rate(void)

components/retro-go/rg_system.h

@@ -133,25 +133,20 @@ typedef struct
     void (*about)(rg_gui_option_t *dest);                            // Add extra options to rg_gui_about_menu()
 } rg_handlers_t;
 
+// Note: Always make sure that a value of 0 represents a reasonable default...
+// For example: Do not add `enableThing` if it must default to `1` when unspecified
+// Instead, consider adding `disableThing`.
 typedef struct
 {
-    uint8_t id;
-    bool is_used;
-    bool is_lastused;
-    size_t size;
-    time_t mtime;
-    char preview[RG_PATH_MAX];
-    char file[RG_PATH_MAX];
-} rg_emu_slot_t;
-
-typedef struct
-{
-    size_t total;
-    size_t used;
-    rg_emu_slot_t *lastused;
-    rg_emu_slot_t *latest;
-    rg_emu_slot_t slots[];
-} rg_emu_states_t;
+    int sampleRate;
+    int frameRate; // tickRate
+    // int frameSkip;
+    int mallocAlwaysInternal;
+    bool storageRequired;
+    bool romRequired;
+    bool isLauncher;
+    rg_handlers_t handlers;
+} rg_config_t;
 
 typedef struct
 {
@@ -203,7 +198,7 @@ typedef struct
     int freeStackMain;
 } rg_stats_t;
 
-rg_app_t *rg_system_init(int sampleRate, const rg_handlers_t *handlers, void *_unused);
+rg_app_t *rg_system_init(const rg_config_t *config);
 rg_app_t *rg_system_reinit(int sampleRate, const rg_handlers_t *handlers, void *_unused);
 void rg_system_panic(const char *context, const char *message) __attribute__((noreturn));
 void rg_system_shutdown(void) __attribute__((noreturn));
@@ -229,6 +224,7 @@ bool rg_system_save_trace(const char *filename, bool append);
 void rg_system_event(int event, void *data);
 int64_t rg_system_timer(void);
 rg_app_t *rg_system_get_app(void);
+// rg_config_t rg_system_get_config(void);
 rg_stats_t rg_system_get_stats(void);
 
 // Speed and Overclock
@@ -276,6 +272,26 @@ void rg_mutex_free(rg_mutex_t *mutex);
 bool rg_mutex_give(rg_mutex_t *mutex);
 bool rg_mutex_take(rg_mutex_t *mutex, int timeoutMS);
 
+typedef struct
+{
+    uint8_t id;
+    bool is_used;
+    bool is_lastused;
+    size_t size;
+    time_t mtime;
+    char preview[RG_PATH_MAX];
+    char file[RG_PATH_MAX];
+} rg_emu_slot_t;
+
+typedef struct
+{
+    size_t total;
+    size_t used;
+    rg_emu_slot_t *lastused;
+    rg_emu_slot_t *latest;
+    rg_emu_slot_t slots[];
+} rg_emu_states_t;
+
 char *rg_emu_get_path(rg_path_type_t type, const char *arg);
 bool rg_emu_save_state(uint8_t slot);
 bool rg_emu_load_state(uint8_t slot);

fmsx/main/main.c

@@ -419,18 +419,19 @@ static void options_handler(rg_gui_option_t *dest)
 
 void app_main(void)
 {
-    const rg_handlers_t handlers = {
-        .loadState = &load_state_handler,
-        .saveState = &save_state_handler,
-        .reset = &reset_handler,
-        .screenshot = &screenshot_handler,
-        .event = &event_handler,
-        .options = &options_handler,
-    };
-
-    app = rg_system_init(AUDIO_SAMPLE_RATE, &handlers, NULL);
-    // This is probably not right, but the emulator outputs 440 samples per frame??
-    rg_system_set_tick_rate(55);
+    app = rg_system_init(&(const rg_config_t){
+        .sampleRate = AUDIO_SAMPLE_RATE,
+        .frameRate = 55, // This is probably not right, but the emulator outputs 440 samples per frame??
+        .storageRequired = true,
+        .handlers = {
+            .loadState = &load_state_handler,
+            .saveState = &save_state_handler,
+            .reset = &reset_handler,
+            .screenshot = &screenshot_handler,
+            .event = &event_handler,
+            .options = &options_handler,
+        },
+    });
 
     updates[0] = rg_surface_create(WIDTH, HEIGHT, RG_PIXEL_565_BE, MEM_FAST);
     updates[1] = rg_surface_create(WIDTH, HEIGHT, RG_PIXEL_565_BE, MEM_FAST);

gbsp/main/main.c

@@ -119,17 +119,20 @@ static void options_handler(rg_gui_option_t *dest)
 
 void app_main(void)
 {
-    const rg_handlers_t handlers = {
-        .loadState = &load_state_handler,
-        .saveState = &save_state_handler,
-        .reset = &reset_handler,
-        .screenshot = &screenshot_handler,
-        .event = &event_handler,
-        .options = &options_handler,
-    };
-
-    app = rg_system_init(AUDIO_SAMPLE_RATE, &handlers, NULL);
-    // app = rg_system_init(AUDIO_SAMPLE_RATE * 0.7, &handlers, NULL);
+    app = rg_system_init(&(const rg_config_t){
+        .sampleRate = AUDIO_SAMPLE_RATE,
+        .frameRate = 60,
+        .storageRequired = true,
+        .romRequired = true,
+        .handlers = {
+            .loadState = &load_state_handler,
+            .saveState = &save_state_handler,
+            .reset = &reset_handler,
+            .screenshot = &screenshot_handler,
+            .event = &event_handler,
+            .options = &options_handler,
+        },
+    });
     // rg_system_set_overclock(2);
 
     sound_master_enable = rg_settings_get_number(NS_APP, SETTING_SOUND_EMULATION, true);

gwenesis/main/main.c

@@ -251,16 +251,20 @@ static void options_handler(rg_gui_option_t *dest)
 
 void app_main(void)
 {
-    const rg_handlers_t handlers = {
-        .loadState = &load_state_handler,
-        .saveState = &save_state_handler,
-        .reset = &reset_handler,
-        .screenshot = &screenshot_handler,
-        .event = &event_handler,
-        .options = &options_handler,
+    const rg_config_t config = {
+        .sampleRate = AUDIO_SAMPLE_RATE / 2,
+        .frameRate = 60,
+        .storageRequired = true,
+        .romRequired = true,
+        .handlers.loadState = &load_state_handler,
+        .handlers.saveState = &save_state_handler,
+        .handlers.reset = &reset_handler,
+        .handlers.screenshot = &screenshot_handler,
+        .handlers.event = &event_handler,
+        .handlers.options = &options_handler,
     };
-
-    app = rg_system_init(AUDIO_SAMPLE_RATE / 2, &handlers, NULL);
+    app = rg_system_init(&config);
+    app->frameskip = 2;
 
     yfm_enabled = rg_settings_get_number(NS_APP, SETTING_YFM_EMULATION, 1);
     sn76489_enabled = rg_settings_get_number(NS_APP, SETTING_SN76489_EMULATION, 0);
@@ -313,9 +317,6 @@ void app_main(void)
         rg_emu_load_state(app->saveSlot);
     }
 
-    rg_system_set_tick_rate(60);
-    app->frameskip = 2;
-
     extern unsigned char gwenesis_vdp_regs[0x20];
     extern unsigned int gwenesis_vdp_status;
     extern unsigned short CRAM565[256];

launcher/main/main.c

@@ -5,10 +5,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-#ifdef ESP_PLATFORM
-#include <esp_heap_caps.h>
-#endif
-
 #include "applications.h"
 #include "bookmarks.h"
 #include "browser.h"
@@ -450,34 +446,24 @@ static void about_handler(rg_gui_option_t *dest)
 
 void app_main(void)
 {
-    const rg_handlers_t handlers = {
-        .event = &event_handler,
-        .options = &options_handler,
-        .about = &about_handler,
-    };
-
-    app = rg_system_init(32000, &handlers, NULL);
+    app = rg_system_init(&(const rg_config_t){
+        .sampleRate = 32000,
+        .frameRate = 0,
+        // The launcher makes a lot of small allocations and it sometimes fills internal RAM, causing the SD Card driver to
+        // stop working. Lowering CONFIG_SPIRAM_MALLOC_ALWAYSINTERNAL and manually using rg_alloc to do internal allocs when
+        // needed is a better solution, but that would have to be done for every app. This is a good workaround for now.
+        .mallocAlwaysInternal = 1024,
+        .storageRequired = true,
+        .isLauncher = true,
+        .handlers.event = &event_handler,
+        .handlers.options = &options_handler,
+        .handlers.about = &about_handler,
+    });
     app->configNs = "launcher";
-    app->isLauncher = true;
 
-    if (!rg_storage_ready())
-    {
-        rg_display_clear(C_SKY_BLUE);
-        rg_gui_alert(_("SD Card Error"), _("Storage mount failed.\nMake sure the card is FAT32."));
-    }
-    else
-    {
-        rg_storage_mkdir(RG_BASE_PATH_CACHE);
-        rg_storage_mkdir(RG_BASE_PATH_CONFIG);
-        try_migrate();
-    }
-
-#ifdef ESP_PLATFORM
-    // The launcher makes a lot of small allocations and it sometimes fills internal RAM, causing the SD Card driver to
-    // stop working. Lowering CONFIG_SPIRAM_MALLOC_ALWAYSINTERNAL and manually using rg_alloc to do internal allocs when
-    // needed is a better solution, but that would have to be done for every app. This is a good workaround for now.
-    heap_caps_malloc_extmem_enable(1024);
-#endif
+    rg_storage_mkdir(RG_BASE_PATH_CACHE);
+    rg_storage_mkdir(RG_BASE_PATH_CONFIG);
+    try_migrate();
 
     retro_loop();
 }