Add MAILBOX present mode detection and Oboe audio offset auto-suggest

Co-authored-by: winnerspiros <1675249+winnerspiros@users.noreply.github.com>
Agent-Logs-Url: https://github.com/winnerspiros/osu/sessions/75739364-5690-4028-9d88-98f465b77bbc

Author: Copilot

osu.Android/Native/VulkanProbe.cs

@@ -193,6 +193,28 @@ public bool HasDedicatedTransferQueue
             }
         }
 
+        /// <summary>
+        /// Whether the device likely supports MAILBOX present mode for low-latency triple-buffered rendering.
+        /// Detected via the <c>VK_GOOGLE_display_timing</c> extension, which is present on Android GPUs
+        /// (Adreno, Mali) that also expose MAILBOX present mode.
+        /// </summary>
+        public bool SupportsMailboxPresentMode
+        {
+            get
+            {
+                if (disposed || nativePtr == 0) return false;
+
+                try
+                {
+                    return nVulkanSupportsMailboxPresentMode(nativePtr) != 0;
+                }
+                catch
+                {
+                    return false;
+                }
+            }
+        }
+
         public void Dispose()
         {
             if (disposed) return;
@@ -247,5 +269,8 @@ public void Dispose()
 
         [DllImport("osu_native")]
         private static extern byte nVulkanHasDedicatedTransferQueue(long ptr);
+
+        [DllImport("osu_native")]
+        private static extern byte nVulkanSupportsMailboxPresentMode(long ptr);
     }
 }

osu.Android/Native/vulkan_bridge.cpp

@@ -20,7 +20,7 @@ VulkanProbe::VulkanProbe() {
 
     if (available_) {
         LOGI("Vulkan available: %s (API %u.%u.%u, driver %u, VRAM %u MB, "
-             "queues %u, dedicatedCompute=%d, dedicatedTransfer=%d, swapchain=%d)",
+             "queues %u, dedicatedCompute=%d, dedicatedTransfer=%d, swapchain=%d, mailbox=%d)",
              deviceInfo_.deviceName.c_str(),
              VK_VERSION_MAJOR(deviceInfo_.apiVersion),
              VK_VERSION_MINOR(deviceInfo_.apiVersion),
@@ -30,7 +30,8 @@ VulkanProbe::VulkanProbe() {
              deviceInfo_.queueFamilyCount,
              deviceInfo_.hasDedicatedComputeQueue ? 1 : 0,
              deviceInfo_.hasDedicatedTransferQueue ? 1 : 0,
-             deviceInfo_.supportsSwapchain ? 1 : 0);
+             deviceInfo_.supportsSwapchain ? 1 : 0,
+             deviceInfo_.supportsMailboxPresentMode ? 1 : 0);
     } else {
         LOGI("Vulkan not available on this device");
     }
@@ -127,6 +128,7 @@ bool VulkanProbe::queryDevice() {
     // Query additional performance-relevant capabilities.
     queryMemory(selected);
     queryQueueFamilies(selected);
+    queryMailboxSupport(selected);
 
     return true;
 }
@@ -175,6 +177,31 @@ void VulkanProbe::queryQueueFamilies(VkPhysicalDevice device) {
     }
 }
 
+void VulkanProbe::queryMailboxSupport(VkPhysicalDevice device) {
+    // MAILBOX present mode requires a VkSurface to query definitively, but we detect
+    // it using VK_GOOGLE_display_timing — a device extension that is present exclusively
+    // on Android GPUs (Adreno, Mali) that also expose MAILBOX present mode support.
+    // This gives us a reliable indication without needing an active surface.
+    deviceInfo_.supportsMailboxPresentMode = false;
+
+    uint32_t extCount = 0;
+
+    if (vkEnumerateDeviceExtensionProperties(device, nullptr, &extCount, nullptr) != VK_SUCCESS || extCount == 0)
+        return;
+
+    std::vector<VkExtensionProperties> extensions(extCount);
+
+    if (vkEnumerateDeviceExtensionProperties(device, nullptr, &extCount, extensions.data()) != VK_SUCCESS)
+        return;
+
+    for (const auto& ext : extensions) {
+        if (strcmp(ext.extensionName, "VK_GOOGLE_display_timing") == 0) {
+            deviceInfo_.supportsMailboxPresentMode = true;
+            return;
+        }
+    }
+}
+
 void VulkanProbe::cleanup() {
     if (instance_ != VK_NULL_HANDLE) {
         vkDestroyInstance(instance_, nullptr);
@@ -231,4 +258,9 @@ unsigned char nVulkanHasDedicatedTransferQueue(long ptr) {
     return (probe && probe->getDeviceInfo().hasDedicatedTransferQueue) ? 1 : 0;
 }
 
+unsigned char nVulkanSupportsMailboxPresentMode(long ptr) {
+    auto* probe = reinterpret_cast<VulkanProbe*>(ptr);
+    return (probe && probe->getDeviceInfo().supportsMailboxPresentMode) ? 1 : 0;
+}
+
 } // extern "C"

osu.Android/Native/vulkan_bridge.h

@@ -27,6 +27,10 @@ class VulkanProbe {
         bool hasDedicatedComputeQueue;
         /// Whether the device has a dedicated transfer queue.
         bool hasDedicatedTransferQueue;
+        /// Whether the device likely supports VK_PRESENT_MODE_MAILBOX_KHR for low-latency rendering.
+        /// Detected via the VK_GOOGLE_display_timing device extension, which is present on
+        /// Android GPUs (Adreno, Mali) that also expose MAILBOX present mode.
+        bool supportsMailboxPresentMode;
     };
 
     VulkanProbe();
@@ -47,5 +51,6 @@ class VulkanProbe {
     bool queryDevice();
     void queryMemory(VkPhysicalDevice device);
     void queryQueueFamilies(VkPhysicalDevice device);
+    void queryMailboxSupport(VkPhysicalDevice device);
     void cleanup();
 };

osu.Android/OsuGameAndroid.cs

@@ -34,6 +34,7 @@ public partial class OsuGameAndroid : OsuGame
         private readonly Bindable<bool> performanceMode = new Bindable<bool>();
         private readonly Bindable<bool> lowLatencyAudio = new Bindable<bool>();
         private readonly Bindable<bool> vulkanProbeEnabled = new Bindable<bool>();
+        private readonly BindableDouble audioOffset = new BindableDouble();
 
         private OboeAudioBridge? oboeBridge;
         private VulkanProbe? vulkanProbe;
@@ -64,6 +65,7 @@ private void load(OsuConfigManager config)
             config.BindWith(OsuSetting.AndroidPerformanceMode, performanceMode);
             config.BindWith(OsuSetting.AndroidLowLatencyAudio, lowLatencyAudio);
             config.BindWith(OsuSetting.AndroidVulkanProbe, vulkanProbeEnabled);
+            config.BindWith(OsuSetting.AudioOffset, audioOffset);
         }
 
         protected override void LoadComplete()
@@ -114,7 +116,13 @@ private void startOboeBridge()
 
                     if (started)
                     {
+                        // Log basic stream info immediately.
                         logOboeInfo();
+
+                        // Latency is measured asynchronously by the audio callback.
+                        // Schedule a check after a short warm-up period to get a stable reading
+                        // and apply the auto-suggested audio offset if appropriate.
+                        Scheduler.AddDelayed(applyMeasuredLatencyOffset, 2000);
                     }
                     else
                     {
@@ -173,6 +181,7 @@ private void logVulkanInfo()
             Debug.WriteLine($"[osu!] Vulkan GPU: available={vulkanProbe.IsAvailable}, "
                             + $"API={major}.{minor}.{patch}, "
                             + $"swapchain={vulkanProbe.SupportsSwapchain}, "
+                            + $"mailbox={vulkanProbe.SupportsMailboxPresentMode}, "
                             + $"VRAM={vulkanProbe.DeviceLocalMemoryMB}MB, "
                             + $"queueFamilies={vulkanProbe.QueueFamilyCount}, "
                             + $"dedicatedCompute={vulkanProbe.HasDedicatedComputeQueue}, "
@@ -187,8 +196,34 @@ private void logOboeInfo()
                             + $"api={(oboeBridge.IsAAudio ? "AAudio" : "OpenSLES")}, "
                             + $"sampleRate={oboeBridge.SampleRate}Hz, "
                             + $"burst={oboeBridge.FramesPerBurst}frames, "
-                            + $"bufferSize={oboeBridge.BufferSizeInFrames}frames, "
-                            + $"latency={oboeBridge.GetOutputLatencyMs():F1}ms");
+                            + $"bufferSize={oboeBridge.BufferSizeInFrames}frames");
+        }
+
+        /// <summary>
+        /// Called after a warm-up delay to read the stable measured latency and apply it
+        /// as an auto-suggested audio offset when the user hasn't set a manual value.
+        /// </summary>
+        private void applyMeasuredLatencyOffset()
+        {
+            if (oboeBridge == null) return;
+
+            double latency = oboeBridge.GetOutputLatencyMs();
+
+            Debug.WriteLine($"[osu!] Oboe measured latency after warm-up: {latency:F1}ms");
+
+            if (latency <= 0)
+                return;
+
+            // Only auto-suggest when the user hasn't already configured a manual offset.
+            // Use a small epsilon to safely compare against the default value of 0.
+            if (Math.Abs(audioOffset.Value) >= 0.01)
+                return;
+
+            // The audio offset compensates for hardware output delay: if audio arrives
+            // 20 ms late, we need to set the offset to -20 ms so osu! plays notes earlier.
+            double suggested = Math.Clamp(-latency, audioOffset.MinValue, audioOffset.MaxValue);
+            audioOffset.Value = suggested;
+            Debug.WriteLine($"[osu!] Audio offset auto-suggested: {suggested:F1}ms (hardware latency={latency:F1}ms)");
         }
 
         /// <summary>