rg_system: Renamed rg_emu_get/set_speed to rg_system_get/set_app_speed

Author: ducalex

components/retro-go/rg_gui.c

@@ -625,16 +625,16 @@ void rg_gui_draw_status_bars(void)
     char footer[max_len];
 
     const rg_app_t *app = rg_system_get_app();
-    rg_stats_t stats = rg_system_get_counters();
+    rg_stats_t stats = rg_system_get_stats();
 
     if (!app->initialized || app->isLauncher)
         return;
 
     snprintf(header, max_len, "SPEED: %d%% (%d %d) / BUSY: %d%%",
-        (int)round(stats.totalFPS / app->tickRate * 100.f),
-        (int)round(stats.totalFPS),
+        (int)roundf(stats.speedPercent),
+        (int)roundf(stats.totalFPS),
         (int)app->frameskip,
-        (int)round(stats.busyPercent));
+        (int)roundf(stats.busyPercent));
 
     if (app->romPath && strlen(app->romPath) > max_len - 1)
         snprintf(footer, max_len, "...%s", app->romPath + (strlen(app->romPath) - (max_len - 4)));
@@ -1566,9 +1566,9 @@ static rg_gui_event_t speedup_update_cb(rg_gui_option_t *option, rg_gui_event_t
     if (event == RG_DIALOG_PREV || event == RG_DIALOG_NEXT)
     {
         float change = (event == RG_DIALOG_NEXT) ? 0.5f : -0.5f;
-        rg_emu_set_speed(rg_emu_get_speed() + change);
+        rg_system_set_app_speed(rg_system_get_app_speed() + change);
     }
-    sprintf(option->value, "%.1fx", rg_emu_get_speed());
+    sprintf(option->value, "%.1fx", rg_system_get_app_speed());
     return RG_DIALOG_VOID;
 }
 
@@ -2094,7 +2094,7 @@ void rg_gui_debug_menu(void)
     char screen_res[20], source_res[20], scaled_res[20];
     char stack_hwm[20], heap_free[20], block_free[20];
     char local_time[32], timezone[32], uptime[20];
-    char battery_info[25], frame_time[32];
+    char battery_info[20], frame_time[20], overclock[20];
     char app_name[32], network_str[64];
 
     const rg_gui_option_t options[] = {
@@ -2111,8 +2111,8 @@ void rg_gui_debug_menu(void)
         {0, "Uptime    ", uptime,       RG_DIALOG_FLAG_NORMAL, NULL},
         {0, "Battery   ", battery_info, RG_DIALOG_FLAG_NORMAL, NULL},
         {0, "Blit time ", frame_time,   RG_DIALOG_FLAG_NORMAL, NULL},
+        {0, "Overclock",  overclock,    RG_DIALOG_FLAG_NORMAL, NULL},
         RG_DIALOG_SEPARATOR,
-        {0, "Overclock",            "-", RG_DIALOG_FLAG_NORMAL, &overclock_cb},
         {1, "Reboot to firmware",   NULL, RG_DIALOG_FLAG_NORMAL, NULL},
         {2, "Clear cache    ",      NULL, RG_DIALOG_FLAG_NORMAL, NULL},
         {3, "Save screenshot",      NULL, RG_DIALOG_FLAG_NORMAL, NULL},
@@ -2125,7 +2125,7 @@ void rg_gui_debug_menu(void)
 
     const rg_display_t *display = rg_display_get_info();
     rg_display_counters_t display_stats = rg_display_get_counters();
-    rg_stats_t stats = rg_system_get_counters();
+    rg_stats_t stats = rg_system_get_stats();
     time_t now = time(NULL);
 
     strftime(local_time, 32, "%F %T", localtime(&now));
@@ -2146,6 +2146,7 @@ void rg_gui_debug_menu(void)
     snprintf(block_free, 20, "%d+%d", stats.freeBlockInt, stats.freeBlockExt);
     snprintf(app_name, 32, "%s", rg_system_get_app()->name);
     snprintf(uptime, 20, "%ds", (int)(rg_system_timer() / 1000000));
+    snprintf(overclock, 20, "%d (%dMhz)", rg_system_get_overclock(), rg_system_get_cpu_speed());
 
     rg_battery_t battery;
     if (rg_input_read_battery_raw(&battery))

components/retro-go/rg_system.c

@@ -87,6 +87,7 @@ static RTC_NOINIT_ATTR panic_trace_t panicTrace;
 static RTC_NOINIT_ATTR time_t rtcValue;
 static bool panicTraceCleared = false;
 static bool exitCalled = false;
+static int overclockLevel, overclockMhz;
 static uint32_t indicators;
 static rg_color_t ledColor = -1;
 static rg_stats_t statistics;
@@ -209,11 +210,12 @@ static void update_statistics(void)
         // Hard to fix this sync issue without a lock, which I don't want to use...
         ticks = RG_MAX(ticks, frames);
 
-        statistics.busyPercent = busyTime / totalTime * 100.f;
         statistics.totalFPS = ticks / totalTimeSecs;
         statistics.skippedFPS = (ticks - frames) / totalTimeSecs;
         statistics.fullFPS = fullFrames / totalTimeSecs;
         statistics.partialFPS = partFrames / totalTimeSecs;
+        statistics.busyPercent = busyTime / totalTime * 100.f;
+        statistics.speedPercent = app.tickRate > 0 ? (statistics.totalFPS / app.tickRate * 100.f) : 100.f;
     }
     statistics.uptime = rg_system_timer() / 1000000;
 
@@ -276,9 +278,9 @@ static void system_monitor_task(void *arg)
 
         // Auto frameskip
         // TODO: Use a rolling average of frameTimes instead of this mess
-        if (statistics.ticks > app.tickRate * 2)
+        if (app.tickRate > 0 && statistics.ticks > app.tickRate * 2)
         {
-            float speed = ((float)statistics.totalFPS / app.tickRate) * 100.f / app.speed;
+            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
             // borderline in power and going back to 0 is just asking for stuttering...
             if (speed > 99.f && statistics.busyPercent < 85.f && app.frameskip > 1)
@@ -411,8 +413,6 @@ rg_app_t *rg_system_init(int sampleRate, const rg_handlers_t *handlers, void *_u
         .tickTimeout = 3000000,
         .frameTime = 1000000 / 60,
         .frameskip = 1, // This can be overriden on a per-app basis if needed, do not set 0 here!
-        .overclock_level = 0,
-        .overclock_mhz = 240,
         .lowMemoryMode = false,
         .enWatchdog = true,
         .isColdBoot = true,
@@ -802,7 +802,7 @@ rg_app_t *rg_system_get_app(void)
     return &app;
 }
 
-rg_stats_t rg_system_get_counters(void)
+rg_stats_t rg_system_get_stats(void)
 {
     return statistics;
 }
@@ -1092,9 +1092,24 @@ int rg_system_get_log_level(void)
     return app.logLevel;
 }
 
-int rg_system_get_cpu_speed(void)
+void rg_system_set_app_speed(float speed)
 {
-    return app.overclock_mhz;
+    float newSpeed = RG_MIN(2.5f, RG_MAX(0.5f, speed));
+    if (newSpeed == app.speed)
+        return;
+    // FIXME: We need to store the actual default frameskip so we can return to it...
+    app.frameskip = (newSpeed - 0.5f) * 3;
+    app.frameTime = 1000000.f / (app.tickRate * newSpeed);
+    app.speed = newSpeed;
+    // There's a bug in esp-idf v4.4.8 where many frequencies play at the wrong speed.
+    // Still trying to find how to work around that...
+    rg_audio_set_sample_rate(app.sampleRate * newSpeed);
+    rg_system_event(RG_EVENT_SPEEDUP, NULL);
+}
+
+float rg_system_get_app_speed(void)
+{
+    return app.speed;
 }
 
 void rg_system_set_overclock(int level)
@@ -1157,10 +1172,11 @@ void rg_system_set_overclock(int level)
     if (!original_tickRate)
         original_tickRate = app.tickRate;
     app.tickRate = original_tickRate * (240.f / real_mhz);
-    app.overclock_level = level;
-    app.overclock_mhz = real_mhz;
     app.frameskip = 1;
 
+    overclockLevel = level;
+    overclockMhz = real_mhz;
+
     RG_LOGW("Overclock level %d applied: %dMhz", level, real_mhz);
 #else
     RG_LOGE("Overclock not supported on this platform!");
@@ -1169,7 +1185,19 @@ void rg_system_set_overclock(int level)
 
 int rg_system_get_overclock(void)
 {
-    return app.overclock_level;
+    return overclockLevel;
+}
+
+int rg_system_get_cpu_speed(void)
+{
+    if (overclockMhz)
+        return overclockMhz;
+    #if CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ
+        return CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ;
+    #elif CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ
+        return CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ;
+    #endif
+    return 0;
 }
 
 char *rg_emu_get_path(rg_path_type_t pathType, const char *filename)
@@ -1403,28 +1431,12 @@ rg_emu_states_t *rg_emu_get_states(const char *romPath, size_t slots)
 
 bool rg_emu_reset(bool hard)
 {
-    if (app.speed != 1.f)
-        rg_emu_set_speed(1.f);
+    rg_system_set_app_speed(1.f);
     if (app.handlers.reset)
         return app.handlers.reset(hard);
     return false;
 }
 
-void rg_emu_set_speed(float speed)
-{
-    app.speed = RG_MIN(2.5f, RG_MAX(0.5f, speed));
-    // FIXME: We need to store the actual default frameskip so we can return to it...
-    app.frameskip = (app.speed - 0.5f) * 3;
-    app.frameTime = 1000000.f / (app.tickRate * app.speed);
-    rg_audio_set_sample_rate(app.sampleRate * app.speed);
-    rg_system_event(RG_EVENT_SPEEDUP, NULL);
-}
-
-float rg_emu_get_speed(void)
-{
-    return app.speed;
-}
-
 #ifdef RG_ENABLE_PROFILING
 // Note this profiler might be inaccurate because of:
 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=28205

components/retro-go/rg_system.h

@@ -169,8 +169,6 @@ typedef struct
     int tickTimeout;
     int frameTime;
     int frameskip;
-    int overclock_level;
-    int overclock_mhz;
     bool lowMemoryMode;
     bool enWatchdog;
     bool isColdBoot;
@@ -190,6 +188,7 @@ typedef struct
     float partialFPS;
     float fullFPS;
     float totalFPS;
+    float speedPercent;
     float busyPercent;
     int64_t busyTime;
     int64_t lastTick;
@@ -230,9 +229,11 @@ 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_stats_t rg_system_get_counters(void);
+rg_stats_t rg_system_get_stats(void);
 
-// Overclock
+// Speed and Overclock
+void rg_system_set_app_speed(float speed);
+float rg_system_get_app_speed(void);
 void rg_system_set_overclock(int level);
 int rg_system_get_overclock(void);
 int rg_system_get_cpu_speed(void);
@@ -282,8 +283,6 @@ bool rg_emu_reset(bool hard);
 bool rg_emu_screenshot(const char *filename, int width, int height);
 rg_emu_states_t *rg_emu_get_states(const char *romPath, size_t slots);
 uint8_t rg_emu_get_last_used_slot(const char *romPath);
-void rg_emu_set_speed(float speed);
-float rg_emu_get_speed(void);
 
 /* Utilities */
 

prboom-go/main/main.c

@@ -439,7 +439,7 @@ void I_StartTic(void)
             Z_FreeTags(PU_CACHE, PU_CACHE); // At this point the heap is usually full. Let's reclaim some!
             rg_gui_game_menu();
         }
-        realtic_clock_rate = app->speed * 100;
+        realtic_clock_rate = rg_system_get_app_speed() * 100;
         R_InitInterpolation();
     }
     else

retro-core/main/main_nes.c

@@ -298,13 +298,12 @@ void nes_main(void)
 
         if (skipFrames == 0)
         {
-            int frameTime = 1000000 / (nes->refresh_rate * app->speed);
             int elapsed = rg_system_timer() - startTime;
             if (nsfPlayer)
                 skipFrames = 10, nsf_draw_overlay();
             else if (app->frameskip > 0)
                 skipFrames = app->frameskip;
-            else if (elapsed > frameTime + 1500) // Allow some jitter
+            else if (elapsed > app->frameTime + 1500) // Allow some jitter
                 skipFrames = 1; // (elapsed / frameTime)
             else if (drawFrame && slowFrame)
                 skipFrames = 1;

updater/main/main.c

@@ -14,6 +14,12 @@
 #define DOWNLOAD_LOCATION RG_BASE_PATH
 #endif
 
+#if CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED
+#define CAN_UPDATE_PARTITION_TABLE 1
+#else
+#define CAN_UPDATE_PARTITION_TABLE 0
+#endif
+
 void app_main(void)
 {
     rg_app_t *app = rg_system_init(32000, NULL, NULL);