fix: address fps limiter review bugs + add unit tests

Bug fixes:
- PresentExtension: nextScheduledUst now uses max(last+interval, now) so
  already-late frames are not penalised with an extra full interval of delay
- PresentExtension: setFrameRateLimit increments a generation counter so
  in-flight scheduled lambdas detect the change and fire immediately instead
  of stalling the game at the old cadence
- PresentExtension: lastScheduledUst watermark is reset on every limit change
  (not just when going to 0) so the new cadence starts clean
- PresentExtension: add close() / Extension.close() default so the scheduler
  thread is shut down when the XServer is released (no more thread leak per
  game session)
- XServerView: setFrameRateLimit now cancels any pending delayed render and
  re-kicks requestRender() on any change, not just when going to 0 — fixes
  stale render cadence when changing e.g. 5fps -> 60fps
- XServerScreen: frameRating.update() moved to runOnUiThread() — was being
  called from the GL thread with no synchronisation
- XServerScreen: LaunchedEffect uses applyFpsLimiterToEngines() helper to
  remove duplicated set calls

Refactor:
- Extract fpsLimiterSteps/CurrentIndex/Progress/Next/Previous to
  FpsLimiterUtils.kt (internal) so they are testable without Compose
- fpsLimiterCurrentIndex uses indexOfLast { it <= value } floor lookup
  instead of exact-match, fixing wrong direction on a restored non-step value

Tests (FpsLimiterUtilsTest — 20 cases):
- fpsLimiterSteps: 60/90/120/144Hz, exact multiples, sub-5 clamp, ordering
- fpsLimiterCurrentIndex: exact match, floor, below-min clamp, 144Hz edge
- nextFpsLimiterValue: normal, clamped at max, non-step floor, 144Hz top
- previousFpsLimiterValue: normal, clamped at min, non-step floor, 144Hz top
- fpsLimiterProgress: min=0, max=1, midpoint, 144Hz, non-step floor

Author: xXJSONDeruloXx

app/src/main/java/app/gamenative/ui/component/FpsLimiterUtils.kt

@@ -0,0 +1,41 @@
+package app.gamenative.ui.component
+
+internal fun fpsLimiterSteps(maxFps: Int): List<Int> {
+    val sanitizedMax = maxFps.coerceAtLeast(5)
+    val flooredMax = (sanitizedMax / 5) * 5
+    return buildList {
+        var value = 5
+        while (value <= flooredMax) {
+            add(value)
+            value += 5
+        }
+        if (sanitizedMax != flooredMax) add(sanitizedMax)
+    }
+}
+
+/**
+ * Returns the index of the step that is the floor of [currentValue] — i.e. the highest
+ * step that is still ≤ currentValue.  Falls back to 0 if currentValue is below the
+ * first step, so navigation never goes in the wrong direction on a restored value that
+ * isn't an exact multiple of 5.
+ */
+internal fun fpsLimiterCurrentIndex(steps: List<Int>, currentValue: Int): Int =
+    steps.indexOfLast { it <= currentValue }.coerceAtLeast(0)
+
+internal fun fpsLimiterProgress(currentValue: Int, maxFps: Int): Float {
+    val steps = fpsLimiterSteps(maxFps)
+    val currentIndex = fpsLimiterCurrentIndex(steps, currentValue)
+    return if (steps.lastIndex <= 0) 1f else currentIndex.toFloat() / steps.lastIndex.toFloat()
+}
+
+internal fun nextFpsLimiterValue(currentValue: Int, maxFps: Int): Int {
+    val steps = fpsLimiterSteps(maxFps)
+    val currentIndex = fpsLimiterCurrentIndex(steps, currentValue)
+    return steps[(currentIndex + 1).coerceAtMost(steps.lastIndex)]
+}
+
+internal fun previousFpsLimiterValue(currentValue: Int, maxFps: Int): Int {
+    val steps = fpsLimiterSteps(maxFps)
+    val currentIndex = fpsLimiterCurrentIndex(steps, currentValue)
+    return steps[(currentIndex - 1).coerceAtLeast(0)]
+}

app/src/main/java/app/gamenative/ui/component/QuickMenu.kt

@@ -212,36 +212,8 @@ private fun matchesPerformanceHudPreset(
         currentConfig.showGpuUsageGraph == presetConfig.showGpuUsageGraph
 }
 
-private fun fpsLimiterSteps(maxFps: Int): List<Int> {
-    val sanitizedMax = maxFps.coerceAtLeast(5)
-    val flooredMax = (sanitizedMax / 5) * 5
-    return buildList {
-        var value = 5
-        while (value <= flooredMax) {
-            add(value)
-            value += 5
-        }
-        if (sanitizedMax != flooredMax) add(sanitizedMax)
-    }
-}
-
-private fun fpsLimiterProgress(currentValue: Int, maxFps: Int): Float {
-    val steps = fpsLimiterSteps(maxFps)
-    val currentIndex = steps.indexOfFirst { it == currentValue }.takeIf { it >= 0 } ?: (steps.lastIndex)
-    return if (steps.lastIndex <= 0) 1f else currentIndex.toFloat() / steps.lastIndex.toFloat()
-}
-
-private fun nextFpsLimiterValue(currentValue: Int, maxFps: Int): Int {
-    val steps = fpsLimiterSteps(maxFps)
-    val currentIndex = steps.indexOfFirst { it == currentValue }.takeIf { it >= 0 } ?: steps.lastIndex
-    return steps[(currentIndex + 1).coerceAtMost(steps.lastIndex)]
-}
-
-private fun previousFpsLimiterValue(currentValue: Int, maxFps: Int): Int {
-    val steps = fpsLimiterSteps(maxFps)
-    val currentIndex = steps.indexOfFirst { it == currentValue }.takeIf { it >= 0 } ?: steps.lastIndex
-    return steps[(currentIndex - 1).coerceAtLeast(0)]
-}
+// fpsLimiterSteps / fpsLimiterCurrentIndex / fpsLimiterProgress /
+// nextFpsLimiterValue / previousFpsLimiterValue live in FpsLimiterUtils.kt
 
 @Composable
 fun QuickMenu(

app/src/main/java/app/gamenative/ui/screen/xserver/XServerScreen.kt

@@ -499,10 +499,7 @@ fun XServerScreen(
             fpsLimiterTarget = clampedTarget
         }
         val appliedLimit = if (fpsLimiterEnabled) clampedTarget else 0
-        xServerView?.setFrameRateLimit(appliedLimit)
-        xServerView?.getxServer()
-            ?.getExtension<PresentExtension>(PresentExtension.MAJOR_OPCODE.toInt())
-            ?.setFrameRateLimit(appliedLimit)
+        applyFpsLimiterToEngines(appliedLimit)
     }
 
     fun restorePerformanceHudPosition() {
@@ -1426,7 +1423,9 @@ fun XServerScreen(
                 renderer.isCursorVisible = false
                 renderer.setOnFrameRenderedListener {
                     if (shouldTrackDisplayedFrames.get()) {
-                        frameRating?.update()
+                        (context as? Activity)?.runOnUiThread {
+                            frameRating?.update()
+                        }
                     }
                 }
                 getxServer().renderer = renderer
@@ -1920,6 +1919,9 @@ fun XServerScreen(
                 // Remove the WindowManager listener associated with the released AndroidView.
                 binding.xServerView.renderer.setOnFrameRenderedListener(null)
                 binding.xServerView.getxServer().windowManager.removeOnWindowModificationListener(binding.windowModificationListener)
+                binding.xServerView.getxServer()
+                    .getExtension<PresentExtension>(PresentExtension.MAJOR_OPCODE.toInt())
+                    ?.close()
                 if (PluviaApp.xServerView === binding.xServerView) {
                     PluviaApp.xServerView = null
                 }

app/src/main/java/com/winlator/widget/XServerView.java

@@ -77,22 +77,23 @@ public int getFrameRateLimit() {
     }
 
     public void setFrameRateLimit(int frameRateLimit) {
-        final boolean shouldKickRender;
+        final boolean shouldRecomputeRender;
         synchronized (renderThrottleLock) {
+            boolean hadScheduledRender = renderRequestScheduled;
             this.frameRateLimit = Math.max(0, frameRateLimit);
             minRenderIntervalMs = this.frameRateLimit > 0
                 ? Math.max(1L, Math.round(1000f / (float) this.frameRateLimit))
                 : 0L;
 
-            if (this.frameRateLimit == 0 && renderRequestScheduled) {
+            if (hadScheduledRender) {
                 renderThrottleHandler.removeCallbacks(throttledRenderRunnable);
                 renderRequestScheduled = false;
             }
-            shouldKickRender = this.frameRateLimit == 0;
+            shouldRecomputeRender = this.frameRateLimit == 0 || hadScheduledRender;
         }
 
-        if (shouldKickRender) {
-            super.requestRender();
+        if (shouldRecomputeRender) {
+            requestRender();
         }
     }
 

app/src/main/java/com/winlator/xserver/extensions/Extension.java

@@ -17,4 +17,6 @@ public interface Extension {
     byte getFirstEventId();
 
     void handleRequest(XClient client, XInputStream inputStream, XOutputStream outputStream) throws IOException, XRequestError;
+
+    default void close() {}
 }

app/src/main/java/com/winlator/xserver/extensions/PresentExtension.java

@@ -31,6 +31,7 @@
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
 
 public class PresentExtension implements Extension {
     public static final byte MAJOR_OPCODE = -103;
@@ -47,6 +48,9 @@ public enum Mode {COPY, FLIP, SKIP}
     private volatile long targetIntervalUs = 0L;
     private long lastScheduledUst = 0L; // guarded by scheduleLock
     private final Object scheduleLock = new Object();
+    // Incremented on every setFrameRateLimit call so in-flight lambdas can detect
+    // that the limit changed and fire immediately instead of stalling the game.
+    private final AtomicInteger limitGeneration = new AtomicInteger(0);
     private final ScheduledExecutorService presentScheduler =
         Executors.newSingleThreadScheduledExecutor(r -> {
             Thread t = new Thread(r, "PresentExt-FpsLimiter");
@@ -55,22 +59,23 @@ public enum Mode {COPY, FLIP, SKIP}
         });
 
     public void setFrameRateLimit(int limit) {
-        frameRateLimit = Math.max(0, limit);
-        if (frameRateLimit > 0) {
-            targetIntervalUs = 1_000_000L / frameRateLimit;
-        } else {
-            targetIntervalUs = 0L;
-            synchronized (scheduleLock) {
-                lastScheduledUst = 0L;
-            }
+        synchronized (scheduleLock) {
+            frameRateLimit = Math.max(0, limit);
+            targetIntervalUs = frameRateLimit > 0 ? 1_000_000L / frameRateLimit : 0L;
+            lastScheduledUst = 0L; // reset pacing watermark on every change
         }
+        limitGeneration.incrementAndGet(); // invalidate any in-flight scheduled notifies
+    }
+
+    public void close() {
+        presentScheduler.shutdownNow();
     }
 
-    /** Returns the UST (microseconds) at which this present should be signalled,
-     *  advancing the internal watermark by targetIntervalUs each call. */
     private long nextScheduledUst(long nowUst) {
         synchronized (scheduleLock) {
-            long next = Math.max(nowUst, lastScheduledUst) + targetIntervalUs;
+            // Use the later of (last watermark + interval) or now so that already-late
+            // frames are not penalised by an extra full interval of delay.
+            long next = Math.max(lastScheduledUst + targetIntervalUs, nowUst);
             lastScheduledUst = next;
             return next;
         }
@@ -200,12 +205,22 @@ private void presentPixmap(XClient client, XInputStream inputStream, XOutputStre
                 final int finalIdleFence = idleFence;
                 final long finalScheduledUst = scheduledUst;
                 final long finalInterval = targetInterval;
+                final int capturedGen = limitGeneration.get();
                 presentScheduler.schedule(() -> {
                     try {
-                        long msc = finalScheduledUst / finalInterval;
-                        sendIdleNotify(finalWindow, finalPixmap, finalSerial, finalIdleFence);
-                        sendCompleteNotify(finalWindow, finalSerial, Kind.PIXMAP, Mode.COPY,
-                                finalScheduledUst, msc);
+                        if (limitGeneration.get() == capturedGen) {
+                            long msc = finalScheduledUst / finalInterval;
+                            sendIdleNotify(finalWindow, finalPixmap, finalSerial, finalIdleFence);
+                            sendCompleteNotify(finalWindow, finalSerial, Kind.PIXMAP, Mode.COPY,
+                                    finalScheduledUst, msc);
+                        } else {
+                            // Limit changed while this frame was queued — fire immediately
+                            // so the game is not stalled at the old cadence.
+                            long ustNow = System.nanoTime() / 1000;
+                            sendIdleNotify(finalWindow, finalPixmap, finalSerial, finalIdleFence);
+                            sendCompleteNotify(finalWindow, finalSerial, Kind.PIXMAP, Mode.COPY,
+                                    ustNow, ustNow / FAKE_INTERVAL_DEFAULT_US);
+                        }
                     } catch (Exception ignored) {
                         // Client may have disconnected before the scheduled notify fired.
                     }