Merge pull request #300 from winnerspiros/copilot/fix-vulkan-issues-android

Android: hardware offset accuracy + undo; Vulkan investigation follow-up; Draw/Update unlimited validation

Author: winnerspiros

osu.Android.props

@@ -99,7 +99,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2026.504.1" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2026.504.2" />
     <!-- `ppy.osu.Framework.NativeLibs` is a transitive dependency of `ppy.osu.Framework`
          that ships desktop-only natives (Linux/macOS/Windows) under `runtimes/<rid>/native/`
          — including a bare Linux `libbass.so`/`libbass_fx.so`/`libbassmix.so` for linux-arm64.

osu.Android/AndroidManifest.xml

@@ -14,20 +14,86 @@
         <provider android:name="androidx.core.content.FileProvider" android:authorities="sh.ppy.osulazer.fileprovider" android:grantUriPermissions="true" android:exported="false">
             <meta-data android:name="android.support.FILE_PROVIDER_PATHS" android:resource="@xml/filepaths" />
         </provider>
+        <!-- ═══════════════════════════════════════════════════════════════════════════════════
+             Samsung (One UI / Galaxy / DeX)
+             ─────────────────────────────────────────────────────────────────────────────────
+             keepalive.density     — keep app alive across density changes (DeX connect/disconnect).
+             multidisplay.*        — keep process alive when switching between phone and DeX display.
+             game.biz              — register with Game Launcher / Game Booster for CPU+GPU boost,
+                                     thermal management, and display-refresh priority on phones/tablets.
+             dex.game              — register with the DeX Game Engine (One UI 5+): applies the same
+                                     CPU/GPU boost pipeline as Game Booster but on the DeX/external-
+                                     monitor path, where the Game Launcher overlay does not appear. -->
         <meta-data android:name="com.samsung.android.keepalive.density" android:value="true" />
         <meta-data android:name="com.samsung.android.multidisplay.keep_process_alive" android:value="true" />
-        <!-- Register as a game for Samsung Game Launcher / Game Booster.
-             This enables vendor-specific optimizations (performance boost, thermal management,
-             display refresh rate priority) on Samsung devices automatically. -->
         <meta-data android:name="com.samsung.android.game.biz" android:value="true" />
-        <!-- Android 13+ Game Mode opt-out (https://developer.android.com/games/gamemode/gamemode-api).
-             We explicitly disable Battery- and Performance-mode interventions, FPS override, and
-             downscaling. A rhythm game's input-to-audio latency budget is hard-bound by the
-             active refresh rate and the audio burst cadence — letting the OS Game Manager cap
-             our framerate (typical "battery saver" downscale: 60Hz → 30Hz) or downscale our
-             render resolution (typical "battery saver" downscale: 100% → 75%) breaks both
-             timing accuracy AND visual hit-circle alignment. We already manage thermals, refresh
-             rate, and sustained performance ourselves (see OsuGameAndroid.LoadComplete). -->
+        <meta-data android:name="com.samsung.android.dex.game" android:value="true" />
+
+        <!-- ═══════════════════════════════════════════════════════════════════════════════════
+             Xiaomi / Redmi / POCO (MIUI / HyperOS Game Turbo)
+             ─────────────────────────────────────────────────────────────────────────────────
+             xiaomi.game.engine    — Game Turbo main registration; activates CPU/GPU boost,
+                                     network QoS priority, and touch-sampling boost.
+             miui.intent.category.GAME — legacy MIUI category used by older Game Turbo builds
+                                         (MIUI 12 and below) to identify the package as a game. -->
+        <meta-data android:name="xiaomi.game.engine" android:value="true" />
+        <meta-data android:name="miui.intent.category.GAME" android:value="true" />
+
+        <!-- ═══════════════════════════════════════════════════════════════════════════════════
+             Vivo / iQOO (FunTouch OS / OriginOS Game Space)
+             ─────────────────────────────────────────────────────────────────────────────────
+             vivo.game.mode        — registers with Game Space for performance mode, touch boost,
+                                     and background-process suspension during gameplay. -->
+        <meta-data android:name="vivo.game.mode" android:value="true" />
+
+        <!-- ═══════════════════════════════════════════════════════════════════════════════════
+             Oppo / OnePlus / Realme (ColorOS / OxygenOS / realme UI — all OPPO-derived)
+             ─────────────────────────────────────────────────────────────────────────────────
+             oppo.intent.category.GAME — ColorOS / OxygenOS 14+ Game Space registration;
+                                          enables CPU boost, network priority, and Do-Not-Disturb.
+             com.oplus.games           — supplementary key read by newer ColorOS Game Driver. -->
+        <meta-data android:name="oppo.intent.category.GAME" android:value="true" />
+        <meta-data android:name="com.oplus.games" android:value="true" />
+
+        <!-- ═══════════════════════════════════════════════════════════════════════════════════
+             Honor (MagicOS — independent of Huawei since 2020)
+             ─────────────────────────────────────────────────────────────────────────────────
+             com.hihonor.intent.category.GAME — MagicOS Game Space registration;
+                                                 activates GPU Turbo and performance scheduling. -->
+        <meta-data android:name="com.hihonor.intent.category.GAME" android:value="true" />
+
+        <!-- ═══════════════════════════════════════════════════════════════════════════════════
+             Huawei (EMUI / HarmonyOS — devices with Google Play)
+             ─────────────────────────────────────────────────────────────────────────────────
+             com.huawei.gamebox     — Game Assistant registration; activates GPU Turbo,
+                                      touch-sampling boost, and background-process suspension. -->
+        <meta-data android:name="com.huawei.gamebox" android:value="true" />
+
+        <!-- ═══════════════════════════════════════════════════════════════════════════════════
+             Asus (ROG Phone / Zenfone — ROG UI / ZenUI)
+             ─────────────────────────────────────────────────────────────────────────────────
+             asus.intent.category.GAME — Armoury Crate / Game Genie registration;
+                                          activates X-Mode CPU/GPU boost and network priority. -->
+        <meta-data android:name="asus.intent.category.GAME" android:value="true" />
+
+        <!-- ═══════════════════════════════════════════════════════════════════════════════════
+             Lenovo / Legion (Legion OS / ZUI)
+             ─────────────────────────────────────────────────────────────────────────────────
+             com.lenovo.gameassistant — Legion Game Assistant registration;
+                                         activates CPU/GPU performance mode and shoulder-trigger
+                                         mappings on Legion Phone hardware. -->
+        <meta-data android:name="com.lenovo.gameassistant" android:value="true" />
+
+        <!-- ═══════════════════════════════════════════════════════════════════════════════════
+             Android 13+ AOSP Game Mode API (opt-out of OS interventions)
+             ─────────────────────────────────────────────────────────────────────────────────
+             We explicitly disable Battery- and Performance-mode interventions, FPS override,
+             and downscaling. A rhythm game's input-to-audio latency budget is hard-bound by
+             the active refresh rate and the audio burst cadence — letting the OS Game Manager
+             cap our framerate (typical "battery saver" downscale: 60 Hz → 30 Hz) or downscale
+             our render resolution breaks both timing accuracy AND visual hit-circle alignment.
+             We already manage thermals, refresh rate, and sustained performance ourselves
+             (see OsuGameAndroid.LoadComplete). -->
         <meta-data android:name="android.game_mode_config" android:resource="@xml/gamemode_config" />
     </application>
 </manifest>

osu.Android/AndroidNativeBridgeManager.cs

@@ -122,8 +122,8 @@ public void StartOboeBridge(IntPtr provider, int sampleRate = 0, Action<int>? on
         /// <summary>
         /// Public hook for the user-facing "Resync hardware audio offset" button. Polls the
         /// AAudio-reported output latency every <c>sample_interval_ms</c> for a fixed
-        /// <c>window_ms</c> measurement window, drops the very first reading (warm-up
-        /// transient), and applies the MEDIAN of the remaining positive readings via
+        /// <c>window_ms</c> measurement window, skips the first two ticks (300 ms warm-up —
+        /// no samples are collected during this period), and applies the MEDIAN of the remainingpositive readings via
         /// <paramref name="onLatencyMeasured"/>. Median is robust against the occasional
         /// outlier AAudio reports right after a presentation glitch — strictly better than
         /// the previous "first positive reading wins" policy.
@@ -154,6 +154,14 @@ public void ResyncHardwareAudioOffset(Scheduler scheduler, Action<double> onLate
             const int window_ms = 2000;
             const int max_samples = window_ms / sample_interval_ms; // ~13
 
+            // Warm-up ticks to drop before collecting samples.
+            // AAudio's getTimestamp() requires the hardware pipeline to be full before
+            // the presentation latency stabilises — typically 200–400 ms of real audio
+            // output. Two ticks (= 300 ms) is a conservative but safe boundary.
+            // Previously only 1 tick (150 ms) was dropped, which could admit a biased
+            // warm-up reading on devices with longer pipeline fill times.
+            const int warmup_ticks = 2;
+
             // Fixed-size buffer rather than List<double>: max_samples is known at
             // compile time, so the List's heap-allocated backing T[] + per-Add
             // bounds-check / count-bump is wasted work for a 13-element buffer
@@ -173,13 +181,17 @@ public void ResyncHardwareAudioOffset(Scheduler scheduler, Action<double> onLate
                     return;
                 }
 
-                double latency = b.GetOutputLatencyMs();
+                // GetInstantLatencyMs() calls calculateLatencyMillis() directly on the
+                // stream rather than reading the cached latencyMs_ value. The cache is
+                // only refreshed every ~1 s from onAudioReady, so in a 2 s window most
+                // of the 13 GetOutputLatencyMs() calls were reading the same stale value.
+                // GetInstantLatencyMs() gives a fresh reading at every 150 ms poll.
+                double latency = b.GetInstantLatencyMs();
                 ticks++;
 
-                // Drop the very first reading: AAudio's getTimestamp() needs a few hundred
-                // milliseconds of pulled frames before its reported presentation latency
-                // stabilises, and the warm-up sample tends to be biased high.
-                if (ticks > 1 && latency > 0 && samplesCount < samples.Length)
+                // Drop the first warmup_ticks readings — AAudio needs time to fill its
+                // hardware pipeline before getTimestamp() reports stable values.
+                if (ticks > warmup_ticks && latency > 0 && samplesCount < samples.Length)
                     samples[samplesCount++] = latency;
 
                 if (ticks * sample_interval_ms >= window_ms)
@@ -198,7 +210,16 @@ public void ResyncHardwareAudioOffset(Scheduler scheduler, Action<double> onLate
                         ? samples[samplesCount / 2]
                         : 0.5 * (samples[samplesCount / 2 - 1] + samples[samplesCount / 2]);
 
-                    Logger.Log($"[osu!] Hardware audio latency measured: median={median:F1} ms (n={samplesCount}, range=[{samples[0]:F1}, {samples[samplesCount - 1]:F1}] ms)");
+                    // Compute standard deviation for diagnostic logging (no heap alloc —
+                    // plain loops over the stack-allocated samples span).
+                    double sum = 0;
+                    for (int i = 0; i < samplesCount; i++) sum += samples[i];
+                    double mean = sum / samplesCount;
+                    double variance = 0;
+                    for (int i = 0; i < samplesCount; i++) variance += (samples[i] - mean) * (samples[i] - mean);
+                    double stdDev = Math.Sqrt(variance / samplesCount);
+
+                    Logger.Log($"[osu!] Hardware audio latency measured: median={median:F1} ms (n={samplesCount}, σ={stdDev:F1} ms, range=[{samples[0]:F1}, {samples[samplesCount - 1]:F1}] ms)");
 
                     try { onLatencyMeasured(median); }
                     catch (Exception ex) { Logger.Log($"[osu!] Hardware-latency callback failed: {ex.Message}", level: LogLevel.Error); }

osu.Android/Native/OboeAudioBridge.cs

@@ -100,6 +100,19 @@ public double GetOutputLatencyMs()
             catch { return -1; }
         }
 
+        /// <summary>
+        /// Returns a fresh hardware-latency reading by calling calculateLatencyMillis()
+        /// directly on the stream, bypassing the cached value that onAudioReady only
+        /// refreshes every ~1 second. Use this for measurement loops that need
+        /// accurate per-poll readings.
+        /// </summary>
+        public double GetInstantLatencyMs()
+        {
+            if (disposed || nativePtr == IntPtr.Zero) return -1;
+            try { return nOboeGetInstantLatencyMs(nativePtr); }
+            catch { return -1; }
+        }
+
         public string GetLastErrorMessage()
         {
             if (disposed || nativePtr == IntPtr.Zero) return "Not initialized";
@@ -201,6 +214,7 @@ public void Dispose()
         [DllImport(lib_name)] private static extern byte nOboeStart(IntPtr ptr);
         [DllImport(lib_name)] private static extern void nOboeStop(IntPtr ptr);
         [DllImport(lib_name)] private static extern double nOboeGetLatencyMs(IntPtr ptr);
+        [DllImport(lib_name)] private static extern double nOboeGetInstantLatencyMs(IntPtr ptr);
         [DllImport(lib_name)] private static extern byte nOboeIsActive(IntPtr ptr);
         [DllImport(lib_name)] private static extern int nOboeGetSampleRate(IntPtr ptr);
         [DllImport(lib_name)] private static extern int nOboeGetFramesPerBurst(IntPtr ptr);

osu.Android/Native/oboe_bridge.cpp

@@ -239,6 +239,17 @@ double OboeBridge::getOutputLatencyMs() const {
     return latencyMs_.load();
 }
 
+double OboeBridge::getInstantLatencyMs() const {
+    std::lock_guard<std::mutex> lock(streamLock_);
+    if (!stream_) return -1.0;
+    // calculateLatencyMillis() is documented as thread-safe in Oboe and is
+    // backed by AAudioStream_getTimestamp(). Calling it here (scheduler thread,
+    // outside of onAudioReady) is safe: we hold streamLock_ so stream_ cannot
+    // be reset underneath us, and the AAudio syscall itself is re-entrant.
+    auto result = stream_->calculateLatencyMillis();
+    return result ? result.value() : -1.0;
+}
+
 bool OboeBridge::isActive() const {
     return active_.load();
 }
@@ -487,6 +498,11 @@ OSU_EXPORT double nOboeGetLatencyMs(intptr_t ptr) {
     return bridge ? bridge->getOutputLatencyMs() : -1.0;
 }
 
+OSU_EXPORT double nOboeGetInstantLatencyMs(intptr_t ptr) {
+    auto* bridge = reinterpret_cast<OboeBridge*>(ptr);
+    return bridge ? bridge->getInstantLatencyMs() : -1.0;
+}
+
 OSU_EXPORT byte nOboeIsActive(intptr_t ptr) {
     auto* bridge = reinterpret_cast<OboeBridge*>(ptr);
     return (bridge && bridge->isActive()) ? 1 : 0;

osu.Android/Native/oboe_bridge.h

@@ -26,6 +26,11 @@ class OboeBridge : public oboe::AudioStreamCallback {
     void stop();
 
     double getOutputLatencyMs() const;
+    /// Calls calculateLatencyMillis() directly on the stream (thread-safe per
+    /// Oboe docs) and returns the result. Unlike getOutputLatencyMs() this is
+    /// NOT a cached value, so callers always receive a fresh measurement.
+    /// Returns -1.0 if the stream is not open or the query fails.
+    double getInstantLatencyMs() const;
     bool isActive() const;
     int32_t getSampleRate() const;
     int32_t getFramesPerBurst() const;