Merge pull request #304 from winnerspiros/copilot/fix-vulkan-crash-issue

Android audio: replace dual Oboe/AAudio checkboxes with unified backend dropdown; show active backend in FPS additional info

Author: winnerspiros

osu.Android.props

@@ -99,7 +99,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2026.505.1" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2026.506.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/AndroidStartupFlags.cs

@@ -53,6 +53,20 @@ internal static class AndroidStartupFlags
         /// </summary>
         public const string FLAG_VERBOSE_LOGGING_ENABLED = "android_startup_enable_verbose_logging.flag";
 
+        /// <summary>
+        /// BASS AAudio opt-in sentinel. Presence ⇒ "user has enabled BASS AAudio output".
+        /// Absence ⇒ "default — BASS uses AudioTrack".
+        /// When set, <see cref="OsuGameActivity.OnCreate"/> calls <c>Bass.AndroidAAudio = true</c>
+        /// and <c>Bass.DevicePeriod = -512</c> before any BASS initialisation, so BASS opens
+        /// an AAudio device instead of AudioTrack. On Android ≥ 8.0 this gives lower intrinsic
+        /// BASS output latency; on older devices BASS falls back to AudioTrack automatically.
+        /// Orthogonal to the Oboe bridge (<see cref="osu.Game.Configuration.OsuSetting.AndroidLowLatencyAudio"/>):
+        /// when Oboe is also enabled it overrides BASS's output backend entirely via the
+        /// GlobalMixerHandle decode-only path, so this flag only has a perceptible effect
+        /// when Oboe is disabled.
+        /// </summary>
+        public const string FLAG_BASS_AAUDIO_ENABLED = "android_startup_enable_bass_aaudio.flag";
+
         /// <summary>
         /// "Startup in progress" sentinel. Dropped near the very top of <see cref="OsuGameActivity.OnCreate"/>
         /// and cleared a few seconds after <c>OsuGame.LoadComplete</c> by <see cref="OsuGameAndroid"/>.

osu.Android/AndroidStartupSafeMode.cs

@@ -61,10 +61,11 @@ internal static class AndroidStartupSafeMode
         public static bool IsActive => isActive;
 
         /// <summary>
-        /// True iff <see cref="IsActive"/> was set by the Draw-thread native-crash trigger
+        /// True iff <see cref="IsActive"/> was set by the native-crash trigger
         /// (rather than by the <see cref="AndroidStartupFlags.FLAG_STARTUP_IN_PROGRESS"/>
         /// "previous launch died before LoadComplete" sentinel). Lets log lines explain
         /// WHICH safety net forced the conservative defaults.
+        /// The crash may have been on the Draw thread or the SDL/Vulkan-init thread.
         /// </summary>
         public static bool DrawThreadNativeCrashTriggered => drawThreadNativeCrashTriggered;
 
@@ -151,9 +152,9 @@ private static void applyIfPreviousDrawThreadNativeCrash()
                 {
                     CrashDiagnostics.AppendDiagnosticBlock(
                         "\n=========================================================\n"
-                        + "=== ANDROID STARTUP SAFE-MODE ACTIVATED (Draw-thread crash trigger) ===\n"
+                        + "=== ANDROID STARTUP SAFE-MODE ACTIVATED (native crash trigger) ===\n"
                         + $"  utc_time     = {DateTime.UtcNow:O}\n"
-                        + "  reason       = previous launch crashed natively on the Draw thread\n"
+                        + "  reason       = previous launch crashed natively on the Draw/SDL thread\n"
                         + $"  signal       = {crash.Value.Signal}\n"
                         + $"  thread_name  = {crash.Value.ThreadName}\n"
                         + $"  top_frame    = {crash.Value.TopFrame}\n"

osu.Android/CrashDiagnostics.cs

@@ -624,11 +624,17 @@ public DrawThreadNativeCrashInfo(string fingerprint, string signal, string threa
                                      || signal.StartsWith("SIGABRT", StringComparison.Ordinal);
                 if (!isFatalSignal) return null;
 
-                // Match the framework's draw thread name. The native handler
+                // Match threads that host Veldrid/Vulkan work. The native handler
                 // writes a TRUNCATED thread name (Linux pthread_setname is
                 // capped at 16 chars including NUL) so "Draw (GameThread)"
                 // appears as "Draw (GameThrea" — substring match is correct.
-                if (!threadName.StartsWith("Draw", StringComparison.Ordinal)) return null;
+                // SDL names its main render/init thread "SDLThread" (9 chars, well
+                // under the 16-char limit — never truncated); a null-function-pointer
+                // Vulkan crash (SIGSEGV pc=0x0) on this thread during startup should
+                // also activate safe-mode.
+                bool isKnownCrashThread = threadName.StartsWith("Draw", StringComparison.Ordinal)
+                                          || threadName.StartsWith("SDL", StringComparison.Ordinal);
+                if (!isKnownCrashThread) return null;
 
                 string topFrame = extractTopFrame(block);
 
@@ -677,7 +683,12 @@ public DrawThreadNativeCrashInfo(string fingerprint, string signal, string threa
                                  || signal.StartsWith("SIGABRT", StringComparison.Ordinal);
             if (!isFatalSignal) return null;
 
-            if (!thread.StartsWith("Draw", StringComparison.Ordinal)) return null;
+            // Match the same thread set as the full-header path above.
+            // "SDLThread" (9 chars) is below the 16-char truncation limit and
+            // matches the "SDL" prefix check without ambiguity.
+            bool isKnownCrashThread = thread.StartsWith("Draw", StringComparison.Ordinal)
+                                      || thread.StartsWith("SDL", StringComparison.Ordinal);
+            if (!isKnownCrashThread) return null;
 
             string fingerprint = (uptime != null && pid != null)
                 ? $"u{uptime}-p{pid}"

osu.Android/OsuGameActivity.cs

@@ -16,6 +16,7 @@
 using System.Threading.Tasks;
 using System;
 using Uri = Android.Net.Uri;
+using ManagedBass; // Required for Bass.AndroidAAudio + Bass.DevicePeriod startup init (FLAG_BASS_AAUDIO_ENABLED path in OnCreate)
 using osu.Android.Input;
 using osu.Framework.Android;
 using osu.Game.Database;
@@ -264,6 +265,31 @@ protected override void OnCreate(Bundle? savedInstanceState)
                 }
             }
 
+            // BASS AAudio: if the user opted in, tell BASS to open an AAudio device instead
+            // of AudioTrack before the host creates its AudioThread and calls Bass.Init().
+            // Bass.AndroidAAudio must be set before Bass.Init() — reading the sentinel here
+            // (before base.OnCreate, which starts the SDL+game machinery) is the earliest
+            // safe point. On Android < 8.0 BASS falls back to AudioTrack automatically.
+            // When the Oboe bridge (AndroidLowLatencyAudio) is also active it overrides
+            // BASS's own output via the GlobalMixerHandle decode path anyway, so this flag
+            // only materially changes behaviour when Oboe is disabled.
+            if (AndroidStartupFlags.IsSet(AndroidStartupFlags.FLAG_BASS_AAUDIO_ENABLED))
+            {
+                try
+                {
+                    Bass.AndroidAAudio = true;
+                    // -512 requests a 512-sample AAudio buffer (≈ 11.6 ms at 44 100 Hz),
+                    // giving a good latency/stability trade-off. The negative sign means
+                    // "specify in samples rather than milliseconds" (BASS 4Android convention).
+                    Bass.DevicePeriod = -512;
+                    CrashDiagnostics.WriteAliveMarker("Bass.AndroidAAudio = true (DevicePeriod = -512)");
+                }
+                catch (Exception e)
+                {
+                    Debug.WriteLine($"[osu!] Bass.AndroidAAudio init failed (non-fatal): {e.Message}");
+                }
+            }
+
             base.OnCreate(savedInstanceState);
 
             // Wrap Platform.Init defensively: MAUI Essentials pulls in workload-version-sensitive
@@ -763,11 +789,24 @@ public void SurfaceCreated(ISurfaceHolder holder)
             if (handle == IntPtr.Zero)
                 return;
 
-            // Reset per-lifecycle flags. The new surface has not yet reported its format
-            // (SurfaceChanged fires after SurfaceCreated), and any previous pending-format
-            // stamp no longer applies to this new surface instance.
+            // Reset the format-tracking field: the new surface has not yet reported its
+            // format (SurfaceChanged fires after SurfaceCreated).
+            //
+            // Intentionally do NOT reset setFormatPending here. If we previously called
+            // SetFormat(Rgba8888) to fix an RGB565 surface, setFormatPending stays true
+            // across the resulting SurfaceDestroyed → SurfaceCreated cycle so that if the
+            // new surface ALSO arrives as RGB565 (i.e. the SetFormat had no effect on this
+            // device) we do not fire the reactive guard a second time — that would chain
+            // another teardown and produce a duplicate "[osu!] Android surface pixel format
+            // RGB565 detected (Vulkan path)" log message in the overlay.
+            //
+            // The flag lifecycle is:
+            //   false  → set to true when RGB565 guard fires and SetFormat is called
+            //   true   → released back to false in SurfaceChanged when RGBA8888 is confirmed
+            //              (the SetFormat worked; future RGB565 events can fire the guard again)
+            //   true   → stays true if the next SurfaceChanged also reports RGB565
+            //              (SetFormat had no effect; guard is suppressed to avoid chaining)
             lastSurfaceFormat = 0;
-            setFormatPending = false;
 
             IntPtr newRef = global::Android.Runtime.JNIEnv.NewGlobalRef(handle);
 
@@ -822,7 +861,24 @@ public void SurfaceChanged(ISurfaceHolder holder, global::Android.Graphics.Forma
             // the surface that arrives after the first teardown also briefly reports RGB565
             // (e.g. during a compositor mode transition), which would chain teardowns and
             // prevent the draw thread from ever acknowledging either one within 250 ms.
-            if (format == global::Android.Graphics.Format.Rgb565 && LogManagement.IsVulkanConfigured() && !setFormatPending)
+            // Unlike the old design (where setFormatPending was reset in SurfaceCreated),
+            // the flag now persists across the SurfaceDestroyed→SurfaceCreated cycle and is
+            // only released here when the surface is confirmed as RGBA8888. That prevents
+            // the duplicate "[osu!] Android surface pixel format RGB565 detected" log message
+            // that appeared when SetFormat did not change the format on certain Samsung/Adreno
+            // devices (surface born as RGB565 again after the teardown).
+            //
+            // !AndroidStartupSafeMode.IsActive: safe-mode sessions always run OpenGL (via
+            // ForceOpenGLRendererIfSafeMode). After LoadComplete, RestoreRendererAfterSafeMode
+            // writes "Vulkan" back to framework.ini so IsVulkanConfigured() returns true for
+            // the rest of that session — but the runtime renderer is still OpenGL. Firing the
+            // RGB565 guard in that window would call SetFormat unnecessarily (RGB565 is fine
+            // for OpenGL) and produce a mid-session surface teardown with a confusing
+            // "(Vulkan path)" log message in the overlay.
+            if (format == global::Android.Graphics.Format.Rgb565
+                && LogManagement.IsVulkanConfigured()
+                && !setFormatPending
+                && !AndroidStartupSafeMode.IsActive)
             {
                 setFormatPending = true;
 
@@ -860,6 +916,16 @@ public void SurfaceChanged(ISurfaceHolder holder, global::Android.Graphics.Forma
                 return;
             }
 
+            // Release the pending-format guard once the surface is confirmed RGBA8888.
+            // This allows future RGB565 detection (e.g. after a display-mode change that
+            // would legitimately reset the format) while still blocking a second spurious
+            // fire during the immediate teardown+recreate that follows our own SetFormat call.
+            if (format == global::Android.Graphics.Format.Rgba8888 && setFormatPending)
+            {
+                setFormatPending = false;
+                Debug.WriteLine("[osu!] Surface format confirmed RGBA8888 — pending-format guard released.");
+            }
+
             if (width > 0 && height > 0)
             {
                 surfaceEvent.Set();
@@ -898,7 +964,7 @@ public void SurfaceDestroyed(ISurfaceHolder holder)
             }
         }
 
-        public override void OnConfigurationChanged(Configuration newConfig)
+        public override void OnConfigurationChanged(global::Android.Content.Res.Configuration newConfig)
         {
             base.OnConfigurationChanged(newConfig);
             bool wasDeX = IsDeX;
@@ -921,7 +987,7 @@ public override void OnConfigurationChanged(Configuration newConfig)
             }
         }
 
-        private void updateDeXStatus(Configuration? config)
+        private void updateDeXStatus(global::Android.Content.Res.Configuration? config)
         {
             bool wasDeX = IsDeX;
             IsDeX = (config ?? Resources?.Configuration)?.UiMode.HasFlag(UiMode.TypeDesk) ?? false;