diff --git a/app/src/main/cpp/waylandcomp/src/compositor.c b/app/src/main/cpp/waylandcomp/src/compositor.c index e354eb0d67..6a9fdacd26 100644 --- a/app/src/main/cpp/waylandcomp/src/compositor.c +++ b/app/src/main/cpp/waylandcomp/src/compositor.c @@ -2124,7 +2124,21 @@ void droiddeck_stream_frame(AHardwareBuffer *ahb) { unsigned droiddeck_stream_frames(void) { return atomic_load(&g_stream_frames); } +static int64_t g_scene_due_ns; + +static int scene_held_for_limit(int64_t now, int64_t due, int limit, int unpaced) { + if (limit <= 0 || unpaced || due <= 0) return 0; + return now < due - 1000000LL; +} + +static int64_t scene_next_due(int64_t now, int64_t due, int limit) { + if (limit <= 0) return 0; + const int64_t interval = 1000000000LL / limit; + return due > 0 && now - due < interval ? due + interval : now + interval; +} + static void render_scene(void) { + g_scene_due_ns = scene_next_due(now_ns(), g_scene_due_ns, g_fps_limit); if (atomic_load(&g_stream_on)) { g_dirty_since_ns = 0; render_stream(); return; } struct draw_list dl = {0}; struct surface *s; @@ -2302,7 +2316,9 @@ static void render_scene(void) { static int on_fallback_timer(void *data) { g_fallback_armed = 0; - if (g_dirty) render_scene(); + if (!g_dirty) return 0; + if (scene_held_for_limit(now_ns(), g_scene_due_ns, g_fps_limit, g_release_unpaced)) schedule_render(); + else render_scene(); return 0; } @@ -2377,6 +2393,7 @@ static void on_vsync(int64_t frame_time_ns) { g_tick_held = 1; return; } + if (g_dirty && scene_held_for_limit(now, g_scene_due_ns, g_fps_limit, g_release_unpaced)) return; if (g_dirty && !scene_waits_for_game(now)) render_scene(); } diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt index f09ba349aa..067cd71399 100644 --- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt @@ -453,6 +453,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { if (r.resultCode == RESULT_OK) InAppFilePicker.pickedFile(r.data)?.let { importLossless(it) } } private var frameGen by mutableStateOf(FrameGen.Mode.OFF) + private var frameGenPip = false + private val frameGenRequests = java.util.concurrent.atomic.AtomicInteger() private var fexPreset by mutableStateOf("") private var suspendPolicy by mutableStateOf(SessionPrefs.SUSPEND_MANUAL) private var steamDownloadsInBackground by mutableStateOf(false) @@ -830,7 +832,14 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { onDispose { com.droiddeck.launcher.glasses.GlassesMenuMirror.setSessionMenuVisible(this@SessionActivity, false) } } androidx.compose.runtime.LaunchedEffect(drawerOpen, pcKeyboardOpen, achievementsOpen, pipUi) { updatePointerCapture() } - androidx.compose.runtime.LaunchedEffect(pipUi) { hud.setHidden(pipUi) } + androidx.compose.runtime.LaunchedEffect(pipUi) { + hud.setHidden(pipUi) + applyOutputPacing() + if (pipUi != frameGenPip) { + frameGenPip = pipUi + if (FrameGen.engine(this@SessionActivity) != FrameGen.ENGINE_OFF && ::surfaceView.isInitialized) applyFrameGen() + } + } androidx.compose.runtime.LaunchedEffect(AgentGuest.steamKeyboard) { updateOnScreenControls() } androidx.compose.runtime.LaunchedEffect(AgentGuest.desktopTextField) { onDesktopTextField(AgentGuest.desktopTextField) } androidx.compose.runtime.LaunchedEffect(pipUi, pcKeyboardOpen) { updateDesktopKeyboardButton() } @@ -2225,10 +2234,13 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private fun mirrorRefreshLimit(): Int = GlassesRendering.mirrorRefreshLimit(glassesSettings, glasses, glassesScreen != null) - private fun outputFpsLimit(): Int = SessionPrefs.compositorFpsLimit(mirrorRefreshLimit(), if (noSteamSession()) SessionState.fpsLimit else 0) + private fun outputFpsLimit(): Int = outputFpsLimit(pipUi) + + private fun outputFpsLimit(pip: Boolean): Int = + SessionPrefs.compositorFpsLimit(mirrorRefreshLimit(), if (noSteamSession()) SessionState.fpsLimit else 0, pip) private fun applyOutputPacing() { - Log.i(TAG, "perf: " + PerfMode.apply(this, outputFpsLimit(), mirrorRefreshLimit())) + Log.i(TAG, "perf: " + PerfMode.apply(this, outputFpsLimit(false), mirrorRefreshLimit())) if (CompositorHost.isStarted) { val hz = refreshHz() val changed = kotlin.math.abs(SessionState.refreshHz - hz) > 0.1f @@ -2240,8 +2252,13 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private fun applyFrameGen() { val hz = refreshHz() + val pip = pipUi && mirrorRefreshLimit() <= 0 + val request = frameGenRequests.incrementAndGet() Thread({ - val problem = FrameGen.apply(this, hz) + val problem = synchronized(frameGenRequests) { + if (request != frameGenRequests.get()) return@Thread + if (pip) FrameGen.apply(this, FrameGen.Mode.OFF, hz) else FrameGen.apply(this, hz) + } val state = Lossless.state(this) runOnUiThread { lossless = state diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt index ec13849d93..306375cd80 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt @@ -1096,11 +1096,16 @@ object SessionPrefs { * Steam's Frame Limit in the Quick Access menu caps Steam games, and the drawer's limit caps games * launched without Steam. Mirroring still follows the glasses' refresh rate. */ - fun compositorFpsLimit(mirrorRefreshLimit: Int, sessionLimit: Int = 0): Int = when { - mirrorRefreshLimit <= 0 && sessionLimit <= 0 -> FPS_UNPACED - mirrorRefreshLimit <= 0 -> sessionLimit - sessionLimit <= 0 -> mirrorRefreshLimit - else -> minOf(mirrorRefreshLimit, sessionLimit) + const val PIP_FPS = 30 + + fun compositorFpsLimit(mirrorRefreshLimit: Int, sessionLimit: Int = 0, pip: Boolean = false): Int { + val limit = when { + mirrorRefreshLimit <= 0 && sessionLimit <= 0 -> FPS_UNPACED + mirrorRefreshLimit <= 0 -> sessionLimit + sessionLimit <= 0 -> mirrorRefreshLimit + else -> minOf(mirrorRefreshLimit, sessionLimit) + } + return if (pip && mirrorRefreshLimit <= 0 && (limit <= 0 || limit > PIP_FPS)) PIP_FPS else limit } val upscalerChoices = listOf( diff --git a/app/src/test/java/com/droiddeck/launcher/session/OutputPacingTest.kt b/app/src/test/java/com/droiddeck/launcher/session/OutputPacingTest.kt index 824888822a..c2d0ca8356 100644 --- a/app/src/test/java/com/droiddeck/launcher/session/OutputPacingTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/session/OutputPacingTest.kt @@ -17,6 +17,16 @@ class OutputPacingTest { assertEquals(30, SessionPrefs.compositorFpsLimit(60, 30)) } + @Test fun pictureInPictureHoldsTheSessionToThirty() { + assertEquals(SessionPrefs.PIP_FPS, SessionPrefs.compositorFpsLimit(0, pip = true)) + assertEquals(SessionPrefs.PIP_FPS, SessionPrefs.compositorFpsLimit(0, 60, pip = true)) + assertEquals(20, SessionPrefs.compositorFpsLimit(0, 20, pip = true)) + } + + @Test fun pictureInPictureKeepsTheGlassesRate() { + assertEquals(60, SessionPrefs.compositorFpsLimit(60, pip = true)) + } + @Test fun mirroringKeepsTheGlassesRate() { assertEquals(60, SessionPrefs.compositorFpsLimit(60)) } diff --git a/tools/tests/test_render_on_commit.py b/tools/tests/test_render_on_commit.py index d27c7646e1..698944f844 100644 --- a/tools/tests/test_render_on_commit.py +++ b/tools/tests/test_render_on_commit.py @@ -32,6 +32,8 @@ static int64_t g_hold_missed_ns; static int64_t g_refresh_ns = 16666667; volatile int g_render_on_commit = 1; volatile int g_release_unpaced = 1; +volatile int g_fps_limit; +static int64_t g_scene_due_ns; static atomic_int g_stream_on; static struct { unsigned ticks, ticks_late_2ms, commit_renders; int64_t tick_late_ns, tick_late_max_ns; } g_pace; static struct { unsigned ticks; } g_perf; @@ -204,7 +206,7 @@ class RenderOnCommitTest(unittest.TestCase): render = extract_function(source, 'render_scene') self.assertIn('g_rendered_tick_ns = g_tick_vsync_ns;', render) self.assertIn('g_tick_held = 0;', render) - functions = ('commit_renders_on', 'render_on_commit', 'schedule_render', 'scene_waits_for_game', 'on_commit_idle', 'on_vsync') + functions = ('scene_held_for_limit', 'commit_renders_on', 'render_on_commit', 'schedule_render', 'scene_waits_for_game', 'on_commit_idle', 'on_vsync') harness = PREAMBLE + '\n'.join(extract_function(source, name) for name in functions) + CHECKS with tempfile.TemporaryDirectory(prefix='droiddeck-render-on-commit-') as folder: path = Path(folder) diff --git a/tools/tests/test_scene_limit_hold.py b/tools/tests/test_scene_limit_hold.py new file mode 100644 index 0000000000..e2c32937eb --- /dev/null +++ b/tools/tests/test_scene_limit_hold.py @@ -0,0 +1,105 @@ +import os +from pathlib import Path +import re +import shutil +import subprocess +import tempfile +import unittest + + +ROOT = Path(__file__).resolve().parents[2] +SOURCE = ROOT / 'app/src/main/cpp/waylandcomp/src/compositor.c' + + +def extract_function(source, name): + match = re.search(r'^static int(?:64_t)? ' + re.escape(name) + r'\([^;]*?\) \{', source, re.MULTILINE) + if match is None: + raise AssertionError(f'Missing compositor function: {name}') + cursor, depth = match.end(), 1 + while depth: + depth += (source[cursor] == '{') - (source[cursor] == '}') + cursor += 1 + return source[match.start():cursor] + + +HARNESS = r''' +#include +#include +#include + +@FUNCTIONS@ + +#define MS 1000000LL + +static int run(int64_t refresh, int limit, int64_t jitter, int seconds) { + int renders = 0; + int64_t due = 0; + for (int64_t tick = 0; tick * refresh < seconds * 1000 * MS; tick++) { + int64_t now = 1000 * MS + tick * refresh + (tick % 2 ? jitter : -jitter); + if (scene_held_for_limit(now, due, limit, 0)) continue; + renders++; + due = scene_next_due(now, due, limit); + } + return renders; +} + +int main(void) { + assert(!scene_held_for_limit(100 * MS, 0, 30, 0)); + assert(!scene_held_for_limit(100 * MS, 130 * MS, 0, 0)); + assert(!scene_held_for_limit(100 * MS, 130 * MS, 30, 1)); + assert(scene_held_for_limit(100 * MS, 130 * MS, 30, 0)); + assert(scene_held_for_limit(100 * MS, 102 * MS, 30, 0)); + assert(!scene_held_for_limit(100 * MS, 101 * MS, 30, 0)); + assert(!scene_held_for_limit(100 * MS, 90 * MS, 30, 0)); + assert(scene_next_due(100 * MS, 0, 0) == 0); + assert(scene_next_due(100 * MS, 0, 25) == 140 * MS); + assert(scene_next_due(101 * MS, 100 * MS, 25) == 140 * MS); + assert(scene_next_due(200 * MS, 100 * MS, 25) == 240 * MS); + const struct { int64_t refresh; int limit; int expected; } cases[] = { + {8333333, 30, 300}, {8333333, 60, 600}, {16666667, 25, 250}, {16666667, 30, 300}, + {10000000, 30, 300}, {11111111, 30, 300}, {6944444, 40, 400}, {16666667, 120, 600}, + }; + for (unsigned i = 0; i < sizeof cases / sizeof cases[0]; i++) { + int got = run(cases[i].refresh, cases[i].limit, 0, 10); + if (got > cases[i].expected + 1 || got < cases[i].expected - 2) { + fprintf(stderr, "refresh %lld limit %d: %d renders, expected %d\n", + (long long)cases[i].refresh, cases[i].limit, got, cases[i].expected); + return 1; + } + got = run(cases[i].refresh, cases[i].limit, 300000, 10); + if (got > cases[i].expected + 1 || got < cases[i].expected - 2) { + fprintf(stderr, "jittered refresh %lld limit %d: %d renders, expected %d\n", + (long long)cases[i].refresh, cases[i].limit, got, cases[i].expected); + return 1; + } + } + int fallback = run(8 * MS, 30, 0, 10); + assert(fallback <= 301 && fallback >= 290); + puts("PASS"); + return 0; +} +''' + + +class SceneLimitHoldTest(unittest.TestCase): + def test_a_frame_limit_holds_scene_renders_to_its_rate_without_slowing_paced_frames(self): + compiler = shutil.which(os.environ.get('CC', 'cc')) + if compiler is None: + self.skipTest('A host C compiler is required') + source = SOURCE.read_text() + harness = HARNESS.replace('@FUNCTIONS@', '\n'.join(extract_function(source, name) for name in ('scene_held_for_limit', 'scene_next_due'))) + with tempfile.TemporaryDirectory(prefix='droiddeck-scene-hold-') as folder: + path = Path(folder) + (path / 'hold.c').write_text(harness) + binary = path / 'hold-test' + build = subprocess.run([compiler, '-std=c11', '-Wall', '-Wextra', '-Werror', '-O2', + str(path / 'hold.c'), '-o', str(binary)], + capture_output=True, text=True) + self.assertEqual(0, build.returncode, build.stderr) + result = subprocess.run([str(binary)], capture_output=True, text=True, timeout=10) + self.assertEqual(0, result.returncode, result.stderr) + self.assertEqual('PASS', result.stdout.strip()) + + +if __name__ == '__main__': + unittest.main()