Changes before error encountered

Co-authored-by: winnerspiros <1675249+winnerspiros@users.noreply.github.com>
Agent-Logs-Url: https://github.com/winnerspiros/osu/sessions/44e3613f-a823-43ff-87a1-b2becbebcf08

Author: Copilot

osu.Android/Native/CMakeLists.txt

@@ -3,6 +3,10 @@ project(osu_native LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 17)
 
+# Release build optimizations for low-latency performance.
+set(CMAKE_CXX_FLAGS_RELEASE "-O2 -flto -DNDEBUG")
+set(CMAKE_C_FLAGS_RELEASE "-O2 -flto -DNDEBUG")
+
 find_package(oboe REQUIRED CONFIG)
 find_library(vulkan-lib vulkan)
 find_library(log-lib log)

osu.Android/Native/OboeAudioBridge.cs

@@ -10,6 +10,7 @@ namespace osu.Android.Native
     /// <summary>
     /// Managed wrapper around the native Oboe low-latency audio bridge.
     /// Provides accurate audio output latency measurement for rhythm-game synchronisation.
+    /// Optimised for lowest possible latency: AAudio preferred, exclusive mode, 1× burst buffer.
     /// </summary>
     public sealed class OboeAudioBridge : IDisposable
     {
@@ -125,6 +126,89 @@ public bool IsActive
             }
         }
 
+        /// <summary>
+        /// The negotiated sample rate of the stream (e.g. 48000).
+        /// </summary>
+        public int SampleRate
+        {
+            get
+            {
+                if (disposed || nativePtr == 0) return 0;
+
+                try
+                {
+                    return nOboeGetSampleRate(nativePtr);
+                }
+                catch
+                {
+                    return 0;
+                }
+            }
+        }
+
+        /// <summary>
+        /// The burst size in frames — the optimal callback quantum.
+        /// Lower burst = lower latency. Typical Android values: 96–192 frames.
+        /// </summary>
+        public int FramesPerBurst
+        {
+            get
+            {
+                if (disposed || nativePtr == 0) return 0;
+
+                try
+                {
+                    return nOboeGetFramesPerBurst(nativePtr);
+                }
+                catch
+                {
+                    return 0;
+                }
+            }
+        }
+
+        /// <summary>
+        /// The actual buffer size in frames. When optimised, this equals <see cref="FramesPerBurst"/>
+        /// for minimum latency (1× burst).
+        /// </summary>
+        public int BufferSizeInFrames
+        {
+            get
+            {
+                if (disposed || nativePtr == 0) return 0;
+
+                try
+                {
+                    return nOboeGetBufferSizeInFrames(nativePtr);
+                }
+                catch
+                {
+                    return 0;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Whether the stream is using AAudio (true) or OpenSL ES (false).
+        /// AAudio provides the lowest latency path on Android 8.1+.
+        /// </summary>
+        public bool IsAAudio
+        {
+            get
+            {
+                if (disposed || nativePtr == 0) return false;
+
+                try
+                {
+                    return nOboeIsAAudio(nativePtr) != 0;
+                }
+                catch
+                {
+                    return false;
+                }
+            }
+        }
+
         public void Dispose()
         {
             if (disposed) return;
@@ -170,5 +254,17 @@ public void Dispose()
 
         [DllImport("osu_native")]
         private static extern byte nOboeIsActive(long ptr);
+
+        [DllImport("osu_native")]
+        private static extern int nOboeGetSampleRate(long ptr);
+
+        [DllImport("osu_native")]
+        private static extern int nOboeGetFramesPerBurst(long ptr);
+
+        [DllImport("osu_native")]
+        private static extern int nOboeGetBufferSizeInFrames(long ptr);
+
+        [DllImport("osu_native")]
+        private static extern byte nOboeIsAAudio(long ptr);
     }
 }

osu.Android/Native/VulkanProbe.cs

@@ -9,7 +9,8 @@ namespace osu.Android.Native
 {
     /// <summary>
     /// Probes Vulkan GPU capability on the current Android device.
-    /// Used to report hardware information and determine optimal rendering strategy.
+    /// Used to report hardware information and determine optimal rendering strategy
+    /// for low-latency gameplay.
     /// </summary>
     public sealed class VulkanProbe : IDisposable
     {
@@ -110,6 +111,88 @@ public bool SupportsSwapchain
             }
         }
 
+        /// <summary>
+        /// Total device-local GPU memory in megabytes.
+        /// </summary>
+        public int DeviceLocalMemoryMB
+        {
+            get
+            {
+                if (disposed || nativePtr == 0) return 0;
+
+                try
+                {
+                    return nVulkanGetDeviceLocalMemoryMB(nativePtr);
+                }
+                catch
+                {
+                    return 0;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Number of queue families available on the device.
+        /// </summary>
+        public int QueueFamilyCount
+        {
+            get
+            {
+                if (disposed || nativePtr == 0) return 0;
+
+                try
+                {
+                    return nVulkanGetQueueFamilyCount(nativePtr);
+                }
+                catch
+                {
+                    return 0;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Whether the device has a dedicated compute queue (separate from graphics).
+        /// Enables async compute for better frame pacing.
+        /// </summary>
+        public bool HasDedicatedComputeQueue
+        {
+            get
+            {
+                if (disposed || nativePtr == 0) return false;
+
+                try
+                {
+                    return nVulkanHasDedicatedComputeQueue(nativePtr) != 0;
+                }
+                catch
+                {
+                    return false;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Whether the device has a dedicated transfer queue.
+        /// Enables async upload for reduced frame stalls.
+        /// </summary>
+        public bool HasDedicatedTransferQueue
+        {
+            get
+            {
+                if (disposed || nativePtr == 0) return false;
+
+                try
+                {
+                    return nVulkanHasDedicatedTransferQueue(nativePtr) != 0;
+                }
+                catch
+                {
+                    return false;
+                }
+            }
+        }
+
         public void Dispose()
         {
             if (disposed) return;
@@ -152,5 +235,17 @@ public void Dispose()
 
         [DllImport("osu_native")]
         private static extern byte nVulkanSupportsSwapchain(long ptr);
+
+        [DllImport("osu_native")]
+        private static extern int nVulkanGetDeviceLocalMemoryMB(long ptr);
+
+        [DllImport("osu_native")]
+        private static extern int nVulkanGetQueueFamilyCount(long ptr);
+
+        [DllImport("osu_native")]
+        private static extern byte nVulkanHasDedicatedComputeQueue(long ptr);
+
+        [DllImport("osu_native")]
+        private static extern byte nVulkanHasDedicatedTransferQueue(long ptr);
     }
 }