ui: Revised FPS cap configurability

Author: Avid29

config_spec.yml

@@ -165,6 +165,13 @@ display:
     vsync:
       type: bool
       default: true
+    fps_cap:
+      type: enum
+      values: [none, 15_fps, 30_fps, 60_fps, 120_fps, 144_fps, custom]
+      default: 60_fps
+    custom_fps_cap:
+      type: number
+      default: 60.0
   ui:
     show_menubar:
       type: bool

ui/xemu.c

@@ -106,8 +106,7 @@ static bool alt_grab;
 static bool ctrl_grab;
 static int gui_saved_grab;
 static int gui_fullscreen;
-static int fps_selection = 3;
-static float frame_deadline = (NANOSECONDS_PER_SECOND / 60);
+static float min_frame_duration = (NANOSECONDS_PER_SECOND / 60);
 static int gui_grab_code = KMOD_LALT | KMOD_LCTRL;
 static SDL_Cursor *sdl_cursor_normal;
 static SDL_Cursor *sdl_cursor_hidden;
@@ -134,24 +133,30 @@ void xemu_toggle_fullscreen(void)
     toggle_full_screen(&sdl2_console[0]);
 }
 
-int xemu_get_frame_rate_cap(void)
-{
-    return fps_selection;
-}
 
-void xemu_set_frame_rate_cap(int selection)
+void xemu_update_frame_rate_cap(void)
 {
-    // FIXME: Remove redundent selection
-    fps_selection = selection;
+    int selection = g_config.display.window.fps_cap;
 
     // No framerate cap
     if (!selection) {
-        frame_deadline = 0;
+        min_frame_duration = 0;
+        return;
+    }
+
+    // NOTE: Should we log in someway if the selection escaped its valid range?
+    // For now we default to custom.
+    float frame_rate;
+    const float frame_rates[5] = { 15, 30, 60, 120, 144 };
+    if (selection < CONFIG_DISPLAY_WINDOW_FPS_CAP_CUSTOM) {
+        frame_rate = frame_rates[selection - 1];
+    } else {
+        frame_rate = g_config.display.window.custom_fps_cap;
     }
 
-    const int framerates[6] = { 60, 15, 30, 60, 120, 144 }; 
-    int frame_rate = framerates[selection];
-    frame_deadline = (float)NANOSECONDS_PER_SECOND / frame_rate;
+    // Calculate the minimum time allowed between frames based on
+    // the desired frame rate
+    min_frame_duration = (float)NANOSECONDS_PER_SECOND / frame_rate;
 }
 
 #define SDL2_REFRESH_INTERVAL_BUSY 16
@@ -1026,29 +1031,13 @@ void sdl2_gl_switch(DisplayChangeListener *dcl,
     }
 }
 
-float fps = 1.0;
-
-static void update_fps(void)
-{
-    static int64_t last_update = 0;
-    const float r = 0.5;//0.1;
-    static float avg = 1.0;
-    int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
-    float ms = ((float)(now-last_update)/1000000.0);
-    last_update = now;
-    if (fabs(avg-ms) > 0.25*avg) avg = ms;
-    else avg = avg*(1.0-r)+ms*r;
-    fps = 1000.0/avg;
-}
-
 void sdl2_gl_refresh(DisplayChangeListener *dcl)
 {
     struct sdl2_console *scon = container_of(dcl, struct sdl2_console, dcl);
     assert(scon->opengl);
     bool flip_required = false;
 
     SDL_GL_MakeCurrent(scon->real_window, scon->winctx);
-    update_fps();
 
     /* XXX: Note that this bypasses the usual VGA path in order to quickly
      * get the surface. This is simple and fast, at the cost of accuracy.
@@ -1103,10 +1092,10 @@ void sdl2_gl_refresh(DisplayChangeListener *dcl)
     qemu_mutex_unlock_main_loop();
 
     /*
-     * Throttle to make sure swaps happen at 60Hz
+     * Throttle to make sure swaps happen at the desired frame rate cap
      */
-    static int64_t last_update = 0;
-    int64_t deadline = last_update + frame_deadline;
+    static int64_t last_frame_update = 0;
+    int64_t frame_expiration = last_frame_update + min_frame_duration;
 
 #ifdef DEBUG_XEMU_C
     int64_t sleep_acc = 0;
@@ -1121,8 +1110,8 @@ void sdl2_gl_refresh(DisplayChangeListener *dcl)
 
     while (1) {
         int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
-        int64_t time_remaining = deadline - now;
-        if (now < deadline) {
+        int64_t time_remaining = frame_expiration - now;
+        if (now < frame_expiration) {
             if (time_remaining > sleep_threshold) {
                 // Try to sleep until the until reaching the sleep threshold.
                 sleep_ns(time_remaining - sleep_threshold);
@@ -1139,11 +1128,10 @@ void sdl2_gl_refresh(DisplayChangeListener *dcl)
             }
         } else {
             DPRINTF("zzZz %g %ld\n", (double)sleep_acc/1000000.0, spin_acc);
-            last_update = now;
+            last_frame_update = now;
             break;
         }
     }
-
 }
 
 void sdl2_gl_redraw(struct sdl2_console *scon)
@@ -1413,6 +1401,9 @@ int main(int argc, char **argv)
         set_full_screen(&sdl2_console[0], gui_fullscreen);
     }
 
+    // Check settings and update the frame rate cap
+    xemu_update_frame_rate_cap();
+
     /*
      * FIXME: May want to create a callback mechanism for main QEMU thread
      * to just run functions to avoid TLS bugs and locking issues.

ui/xui/main-menu.cc

@@ -554,9 +554,34 @@ void MainMenuDisplayView::Draw()
                      "3840x2160\0",
                      "Select preferred startup window size")) {
     }
+
     Toggle("Vertical refresh sync", &g_config.display.window.vsync,
            "Sync to screen vertical refresh to reduce tearing artifacts");
 
+    if (ChevronCombo("Frame rate cap", &g_config.display.window.fps_cap,
+                     "None\0"
+                     "15fps\0"
+                     "30fps\0"
+                     "60fps\0"
+                     "120fps\0"
+                     "144fps\0"
+                     "Custom\0",
+                     "Limit the maximum frames per second")) {
+        xemu_update_frame_rate_cap();
+    }
+
+    char custom_refresh_rate[32];
+    snprintf(custom_refresh_rate, sizeof(custom_refresh_rate),
+             "Limit refresh rate to %dfps\0",
+             (int)g_config.display.window.custom_fps_cap);
+    if (g_config.display.window.fps_cap ==
+        CONFIG_DISPLAY_WINDOW_FPS_CAP_CUSTOM) {
+        if (Slider("Custom FPS Limit", &g_config.display.window.custom_fps_cap,
+                   10, 300, custom_refresh_rate)) {
+            xemu_update_frame_rate_cap();
+        }
+    }
+
     SectionTitle("Interface");
     Toggle("Show main menu bar", &g_config.display.ui.show_menubar,
            "Show main menu bar when mouse is activated");

ui/xui/menubar.cc

@@ -194,16 +194,51 @@ void ShowMainMenu()
                 nv2a_set_surface_scale_factor(rendering_scale + 1);
             }
 
-            int max_fps = xemu_get_frame_rate_cap();
-            if(ImGui::Combo("Frame Rate Cap", &max_fps,
-                "none\0"
-                "15fps\0"
-                "30fps\0"
-                "60fps\0"
-                "120fps\0"
-                "144fps\0")) {
-                    xemu_set_frame_rate_cap(max_fps);
-                }
+
+// Define the string array used for fps selection in the menu bar
+// Split the string into a set and custom region, since we will have
+// to format a section of the string, but can't format the whole string
+// due to the null terminations.
+//
+// We need to both allocate a string beginning with the base options
+// and track the substring size, so just use a macro.
+#ifndef FPS_BASE_OPTIONS_STR
+#define FPS_BASE_OPTIONS_STR \
+    "None\0"                 \
+    "15fps\0"                \
+    "30fps\0"                \
+    "60fps\0"                \
+    "120fps\0"               \
+    "144fps"
+#endif
+
+            // Allocate the fps options buffer
+            char fps_options[64] = FPS_BASE_OPTIONS_STR;
+            // Split into regions
+            const size_t fps_options_set_region_size =
+                sizeof(FPS_BASE_OPTIONS_STR);
+            char *fps_options_custom_region =
+                fps_options + fps_options_set_region_size;
+            size_t fps_options_custom_region_size =
+                sizeof(fps_options) - fps_options_set_region_size;
+// Clean up the macro (kinda gross we that we need one, but better than a magic
+// number)
+#undef FPS_BASE_OPTIONS_STR
+
+            // Format the custom region to specifc the custom FPS.
+            // Clear the custom region first! If the custom FPS jumps by over a
+            // digit and the custom region is not cleared, an additional
+            // selection option may be created.
+            memset(fps_options_custom_region, '\0',
+                   fps_options_custom_region_size);
+            snprintf(fps_options_custom_region, fps_options_custom_region_size,
+                     "Custom (%dfps)",
+                     (int)g_config.display.window.custom_fps_cap);
+
+            if (ImGui::Combo("Frame Rate Cap", &g_config.display.window.fps_cap,
+                             fps_options)) {
+                xemu_update_frame_rate_cap();
+            }
 
             ImGui::Combo("Display Mode", &g_config.display.ui.fit,
                          "Center\0Scale\0Stretch\0");

ui/xui/widgets.cc

@@ -222,8 +222,17 @@ bool Toggle(const char *str_id, bool *v, const char *description)
     return status;
 }
 
-void Slider(const char *str_id, float *v, const char *description)
+bool Slider(const char *str_id, float *v, const char *description)
 {
+    return Slider(str_id, v, 0, 1, description);
+}
+
+bool Slider(const char *str_id, float *v, float min, float max,
+            const char *description)
+{
+    float initial = *v;
+    float pos = (initial - min) / (max - min);
+
     ImGui::PushStyleColor(ImGuiCol_Button, IM_COL32_BLACK_TRANS);
 
     ImGuiStyle &style = ImGui::GetStyle();
@@ -261,13 +270,13 @@ void Slider(const char *str_id, float *v, const char *description)
             ImGui::IsKeyPressed(ImGuiKey_GamepadDpadLeft) ||
             ImGui::IsKeyPressed(ImGuiKey_GamepadLStickLeft) ||
             ImGui::IsKeyPressed(ImGuiKey_GamepadRStickLeft)) {
-                *v -= 0.05;
+            pos -= 0.05;
         }
         if (ImGui::IsKeyPressed(ImGuiKey_RightArrow) ||
             ImGui::IsKeyPressed(ImGuiKey_GamepadDpadRight) ||
             ImGui::IsKeyPressed(ImGuiKey_GamepadLStickRight) ||
             ImGui::IsKeyPressed(ImGuiKey_GamepadRStickRight)) {
-                *v += 0.05;
+            pos += 0.05;
         }
 
         if (
@@ -286,16 +295,19 @@ void Slider(const char *str_id, float *v, const char *description)
 
     if (ImGui::IsItemActive()) {
         ImVec2 mouse = ImGui::GetMousePos();
-        *v = GetSliderValueForMousePos(mouse, slider_pos, slider_size);
+        pos = GetSliderValueForMousePos(mouse, slider_pos, slider_size);
     }
-    *v = fmax(0, fmin(*v, 1));
-    DrawSlider(*v, ImGui::IsItemHovered() || ImGui::IsItemActive(), slider_pos,
+    pos = fmax(0, fmin(pos, 1));
+    DrawSlider(pos, ImGui::IsItemHovered() || ImGui::IsItemActive(), slider_pos,
                slider_size);
 
     ImVec2 slider_max = ImVec2(slider_pos.x + slider_size.x, slider_pos.y + slider_size.y);
     ImGui::RenderNavHighlight(ImRect(slider_pos, slider_max), window->GetID("###slider"));
 
     ImGui::PopStyleColor();
+
+    *v = (pos * (max - min)) + min;
+    return *v != initial;
 }
 
 bool FilePicker(const char *str_id, const char **buf, const char *filters,

ui/xui/widgets.hh

@@ -34,7 +34,9 @@ float GetSliderValueForMousePos(ImVec2 mouse, ImVec2 pos, ImVec2 size);
 void DrawSlider(float v, bool hovered, ImVec2 pos, ImVec2 size);
 void DrawToggle(bool enabled, bool hovered, ImVec2 pos, ImVec2 size);
 bool Toggle(const char *str_id, bool *v, const char *description = nullptr);
-void Slider(const char *str_id, float *v, const char *description = nullptr);
+bool Slider(const char *str_id, float *v, const char *description = nullptr);
+bool Slider(const char *str_id, float *v, float min, float max,
+            const char *description = nullptr);
 bool FilePicker(const char *str_id, const char **buf, const char *filters,
                 bool dir = false);
 void DrawComboChevron();

ui/xui/xemu-hud.h

@@ -33,8 +33,7 @@ extern "C" {
 // Implemented in xemu.c
 int xemu_is_fullscreen(void);
 void xemu_toggle_fullscreen(void);
-int xemu_get_frame_rate_cap(void);
-void xemu_set_frame_rate_cap(int selection);
+void xemu_update_frame_rate_cap(void);
 void xemu_eject_disc(Error **errp);
 void xemu_load_disc(const char *path, Error **errp);