Merge pull request #105 from winnerspiros/copilot/fix-android-app-crash-on-startup

Fix native library build pipeline, upgrade Oboe/NDK/Vulkan, optimize for lowest latency

Author: winnerspiros

.github/workflows/release.yml

@@ -32,6 +32,34 @@ jobs:
       - name: Install .NET Android workload
         run: dotnet workload install android
 
+      - name: Ensure Android NDK and CMake are available
+        run: |
+          # The ubuntu-latest runner has $ANDROID_HOME pre-installed.
+          # Install latest stable NDK (r29) + CMake.
+          yes | sdkmanager --licenses > /dev/null 2>&1 || true
+          sdkmanager --install "ndk;29.0.14206865" "cmake;3.22.1" > /dev/null 2>&1
+
+      - name: Build native library (libosu_native.so)
+        run: |
+          NDK_HOME="$ANDROID_HOME/ndk/29.0.14206865"
+          CMAKE_BIN="$ANDROID_HOME/cmake/3.22.1/bin/cmake"
+
+          for ABI in arm64-v8a armeabi-v7a x86; do
+            echo "::group::Building osu_native for $ABI"
+            "$CMAKE_BIN" -B "build-native/$ABI" -S osu.Android/Native \
+              -DCMAKE_TOOLCHAIN_FILE="$NDK_HOME/build/cmake/android.toolchain.cmake" \
+              -DANDROID_ABI="$ABI" \
+              -DANDROID_PLATFORM=android-30 \
+              -DCMAKE_BUILD_TYPE=Release
+            "$CMAKE_BIN" --build "build-native/$ABI" --config Release -j "$(nproc)"
+            mkdir -p "osu.Android/libs/$ABI"
+            cp "build-native/$ABI/libosu_native.so" "osu.Android/libs/$ABI/"
+            echo "::endgroup::"
+          done
+
+          echo "Native libraries built successfully:"
+          find osu.Android/libs -name "*.so" -exec ls -lh {} \;
+
       - name: Decode keystore
         id: keystore
         run: |

.gitignore

@@ -344,3 +344,7 @@ FodyWeavers.xsd
 
 .idea/.idea.osu.Desktop/.idea/misc.xml
 .idea/.idea.osu.Android/.idea/deploymentTargetDropDown.xml
+
+# Native library build artifacts (built by CMake/NDK in CI or locally)
+osu.Android/libs/
+build-native/

osu.Android/AndroidNativeBridgeManager.cs

@@ -133,14 +133,18 @@ private static void logVulkanInfo(VulkanProbe probe)
                             + $"VRAM={probe.DeviceLocalMemoryMB}MB, "
                             + $"queueFamilies={probe.QueueFamilyCount}, "
                             + $"dedicatedCompute={probe.HasDedicatedComputeQueue}, "
-                            + $"dedicatedTransfer={probe.HasDedicatedTransferQueue}");
+                            + $"dedicatedTransfer={probe.HasDedicatedTransferQueue}, "
+                            + $"vk1.3={probe.MeetsVulkan13}, "
+                            + $"dynamicRendering={probe.SupportsDynamicRendering}, "
+                            + $"synchronization2={probe.SupportsSynchronization2}");
         }
 
         [MethodImpl(MethodImplOptions.NoInlining)]
         private static void logOboeInfo(OboeAudioBridge bridge)
         {
             Debug.WriteLine($"[osu!] Oboe audio: active={bridge.IsActive}, "
                             + $"api={(bridge.IsAAudio ? "AAudio" : "OpenSLES")}, "
+                            + $"mmap={bridge.IsMMap}, "
                             + $"sampleRate={bridge.SampleRate}Hz, "
                             + $"burst={bridge.FramesPerBurst}frames, "
                             + $"bufferSize={bridge.BufferSizeInFrames}frames");

osu.Android/Native/CMakeLists.txt

@@ -3,11 +3,37 @@ project(osu_native LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 17)
 
-# Release build optimizations for low-latency performance.
-set(CMAKE_CXX_FLAGS_RELEASE "-O2 -flto -fvisibility=hidden -DNDEBUG")
-set(CMAKE_C_FLAGS_RELEASE "-O2 -flto -fvisibility=hidden -DNDEBUG")
+# Maximum release optimizations for lowest-latency audio callback path.
+# -O3:           aggressive inlining & vectorisation
+# -flto:         link-time optimisation across translation units
+# -ffast-math:   enable SIMD-friendly FP (safe — we only memset + store a double)
+# -ffunction/data-sections + --gc-sections:  dead-code elimination
+# -fvisibility=hidden:  only OSU_EXPORT symbols are visible
+set(CMAKE_CXX_FLAGS_RELEASE "-O3 -flto -ffast-math -ffunction-sections -fdata-sections -fvisibility=hidden -DNDEBUG")
+set(CMAKE_C_FLAGS_RELEASE   "-O3 -flto -ffast-math -ffunction-sections -fdata-sections -fvisibility=hidden -DNDEBUG")
+set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "-Wl,--gc-sections -s")
+
+# Disable Oboe's flowgraph module — we don't use any audio processing/conversion
+# features (our bridge outputs silence for latency measurement only).
+# This reduces the Oboe portion of the binary by ~50%.
+set(OBOE_ENABLE_FLOWGRAPH OFF CACHE BOOL "Disable Oboe flowgraph to reduce binary size")
+
+# Try pre-installed Oboe first (e.g. via Android NDK prefab or local install).
+# If not found, download and build from source for CI/hermetic builds.
+find_package(oboe QUIET CONFIG)
+
+if(oboe_FOUND)
+    set(OBOE_LIB oboe::oboe)
+else()
+    include(FetchContent)
+    FetchContent_Declare(oboe
+        URL https://github.com/google/oboe/archive/refs/tags/1.10.0.tar.gz
+        URL_HASH SHA256=0e4245f8860c4287040a5d76501c588490bcc9cb57614c486c0c201a5dde3e9f
+    )
+    FetchContent_MakeAvailable(oboe)
+    set(OBOE_LIB oboe)
+endif()
 
-find_package(oboe REQUIRED CONFIG)
 find_library(vulkan-lib vulkan)
 find_library(log-lib log)
 find_library(android-lib android)
@@ -18,7 +44,7 @@ add_library(osu_native SHARED
 )
 
 target_link_libraries(osu_native
-    oboe::oboe
+    ${OBOE_LIB}
     ${vulkan-lib}
     ${log-lib}
     ${android-lib}

osu.Android/Native/OboeAudioBridge.cs

@@ -227,6 +227,28 @@ public bool IsAAudio
             }
         }
 
+        /// <summary>
+        /// Whether the stream is using the hardware MMAP path (lowest possible latency).
+        /// MMAP provides direct memory-mapped access to audio hardware buffers,
+        /// bypassing the normal kernel copy path.
+        /// </summary>
+        public bool IsMMap
+        {
+            get
+            {
+                if (disposed || nativePtr == IntPtr.Zero) return false;
+
+                try
+                {
+                    return nOboeIsMMap(nativePtr) != 0;
+                }
+                catch
+                {
+                    return false;
+                }
+            }
+        }
+
         public void Dispose()
         {
             if (disposed) return;
@@ -284,5 +306,8 @@ public void Dispose()
 
         [DllImport(lib_name)]
         private static extern byte nOboeIsAAudio(IntPtr ptr);
+
+        [DllImport(lib_name)]
+        private static extern byte nOboeIsMMap(IntPtr ptr);
     }
 }

osu.Android/Native/VulkanProbe.cs

@@ -233,6 +233,69 @@ public bool SupportsMailboxPresentMode
             }
         }
 
+        /// <summary>
+        /// Whether the device reports Vulkan 1.3+ API version.
+        /// </summary>
+        public bool MeetsVulkan13
+        {
+            get
+            {
+                if (disposed || nativePtr == IntPtr.Zero) return false;
+
+                try
+                {
+                    return nVulkanMeetsVulkan13(nativePtr) != 0;
+                }
+                catch
+                {
+                    return false;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Whether the device supports VkPhysicalDeviceVulkan13Features::dynamicRendering.
+        /// Dynamic rendering eliminates VkRenderPass/VkFramebuffer boilerplate for simpler,
+        /// more flexible rendering.
+        /// </summary>
+        public bool SupportsDynamicRendering
+        {
+            get
+            {
+                if (disposed || nativePtr == IntPtr.Zero) return false;
+
+                try
+                {
+                    return nVulkanSupportsDynamicRendering(nativePtr) != 0;
+                }
+                catch
+                {
+                    return false;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Whether the device supports VkPhysicalDeviceVulkan13Features::synchronization2.
+        /// Provides a cleaner, less error-prone GPU synchronization model.
+        /// </summary>
+        public bool SupportsSynchronization2
+        {
+            get
+            {
+                if (disposed || nativePtr == IntPtr.Zero) return false;
+
+                try
+                {
+                    return nVulkanSupportsSynchronization2(nativePtr) != 0;
+                }
+                catch
+                {
+                    return false;
+                }
+            }
+        }
+
         public void Dispose()
         {
             if (disposed) return;
@@ -290,5 +353,14 @@ public void Dispose()
 
         [DllImport(lib_name)]
         private static extern byte nVulkanSupportsMailboxPresentMode(IntPtr ptr);
+
+        [DllImport(lib_name)]
+        private static extern byte nVulkanMeetsVulkan13(IntPtr ptr);
+
+        [DllImport(lib_name)]
+        private static extern byte nVulkanSupportsDynamicRendering(IntPtr ptr);
+
+        [DllImport(lib_name)]
+        private static extern byte nVulkanSupportsSynchronization2(IntPtr ptr);
     }
 }

osu.Android/Native/oboe_bridge.cpp

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 #include "oboe_bridge.h"
+#include <oboe/OboeExtensions.h>
 #include <android/log.h>
 #include <cstdint>
 #include <cstring>
@@ -22,16 +23,29 @@ OboeBridge::~OboeBridge() {
 bool OboeBridge::open() {
     std::lock_guard<std::mutex> lock(streamLock_);
 
+    // Request MMAP mode globally before opening the stream.
+    // MMAP provides a hardware-level DMA path that bypasses the kernel audio
+    // copy, shaving ~1-2 ms off the round-trip latency on supported devices.
+    oboe::OboeExtensions::setMMapEnabled(true);
+
     oboe::AudioStreamBuilder builder;
     builder.setDirection(oboe::Direction::Output)
            ->setPerformanceMode(oboe::PerformanceMode::LowLatency)
            ->setSharingMode(oboe::SharingMode::Exclusive)
            ->setFormat(oboe::AudioFormat::Float)
-           ->setChannelCount(oboe::ChannelCount::Stereo)
+           // Mono — this stream outputs silence for latency measurement only.
+           // Mono halves the per-callback buffer vs stereo, reducing the
+           // minimum achievable latency.
+           ->setChannelCount(oboe::ChannelCount::Mono)
            // Let Oboe pick the device's native sample rate.
            // Hardcoding (e.g. 48000) would force Android's SRC resampler when the
            // device native rate differs, adding measurable latency.
            ->setSampleRate(oboe::kUnspecified)
+           // Explicitly forbid all internal conversions so that no resampler,
+           // channel mixer, or format converter sits in the audio path.
+           ->setChannelConversionAllowed(false)
+           ->setFormatConversionAllowed(false)
+           ->setSampleRateConversionQuality(oboe::SampleRateConversionQuality::None)
            // Semantic hints help Android route through the optimal audio path.
            ->setContentType(oboe::ContentType::Music)
            ->setUsage(oboe::Usage::Game)
@@ -62,13 +76,14 @@ bool OboeBridge::open() {
     optimiseBufferSize();
 
     LOGI("Oboe stream opened: api=%s, sampleRate=%d, framesPerBurst=%d, "
-         "bufferSize=%d, bufferCapacity=%d, sharingMode=%s",
+         "bufferSize=%d, bufferCapacity=%d, sharingMode=%s, mmap=%s",
          stream_->getAudioApi() == oboe::AudioApi::AAudio ? "AAudio" : "OpenSLES",
          stream_->getSampleRate(),
          stream_->getFramesPerBurst(),
          stream_->getBufferSizeInFrames(),
          stream_->getBufferCapacityInFrames(),
-         stream_->getSharingMode() == oboe::SharingMode::Exclusive ? "Exclusive" : "Shared");
+         stream_->getSharingMode() == oboe::SharingMode::Exclusive ? "Exclusive" : "Shared",
+         oboe::OboeExtensions::isMMapUsed(stream_.get()) ? "yes" : "no");
 
     return true;
 }
@@ -121,6 +136,7 @@ void OboeBridge::stop() {
     }
 
     latencyMs_.store(-1.0);
+    callbackCount_.store(0);
     LOGI("Oboe stream stopped");
 }
 
@@ -152,6 +168,11 @@ bool OboeBridge::isAAudio() const {
     return stream_ && stream_->getAudioApi() == oboe::AudioApi::AAudio;
 }
 
+bool OboeBridge::isMMap() const {
+    std::lock_guard<std::mutex> lock(const_cast<std::mutex&>(streamLock_));
+    return stream_ && oboe::OboeExtensions::isMMapUsed(stream_.get());
+}
+
 oboe::DataCallbackResult OboeBridge::onAudioReady(
     oboe::AudioStream* stream, void* audioData, int32_t numFrames) {
 
@@ -163,7 +184,13 @@ oboe::DataCallbackResult OboeBridge::onAudioReady(
                      * sizeof(float);
     memset(audioData, 0, byteCount);
 
-    updateLatency();
+    // Sample latency every 128 callbacks (~250 ms at typical burst/sample rates)
+    // instead of every single callback. calculateLatencyMillis() issues a
+    // system call; keeping it out of the majority of callbacks reduces jitter
+    // in this real-time audio thread.
+    if ((callbackCount_.fetch_add(1, std::memory_order_relaxed) & 127) == 0) {
+        updateLatency();
+    }
 
     return oboe::DataCallbackResult::Continue;
 }
@@ -297,4 +324,9 @@ OSU_EXPORT unsigned char nOboeIsAAudio(intptr_t ptr) {
     return (bridge && bridge->isAAudio()) ? 1 : 0;
 }
 
+OSU_EXPORT unsigned char nOboeIsMMap(intptr_t ptr) {
+    auto* bridge = reinterpret_cast<OboeBridge*>(ptr);
+    return (bridge && bridge->isMMap()) ? 1 : 0;
+}
+
 } // extern "C"

osu.Android/Native/oboe_bridge.h

@@ -10,8 +10,12 @@
 /// Low-latency audio bridge using Google's Oboe library.
 /// Optimised for rhythm-game audio-visual synchronization with:
 ///  - AAudio preferred (lowest latency path on Android 8.1+)
+///  - MMAP enabled (hardware-level DMA, bypasses kernel copy)
 ///  - Exclusive sharing mode (bypass system mixer)
+///  - Mono output (minimum buffer for latency-measurement stream)
 ///  - Buffer size tuned to 1× burst for minimum latency
+///  - All format/rate/channel conversions disabled (zero resampler overhead)
+///  - Latency sampled every 128 callbacks (avoids syscall overhead in hot path)
 ///  - Automatic stream recovery on disconnect / route change
 class OboeBridge : public oboe::AudioStreamCallback {
 public:
@@ -40,6 +44,10 @@ class OboeBridge : public oboe::AudioStreamCallback {
     /// Returns true if the stream is using AAudio (vs OpenSL ES fallback).
     bool isAAudio() const;
 
+    /// Returns true if the stream is using the hardware MMAP path (lowest possible latency).
+    /// MMAP provides direct memory-mapped access to audio hardware buffers.
+    bool isMMap() const;
+
     // oboe::AudioStreamCallback
     oboe::DataCallbackResult onAudioReady(
         oboe::AudioStream* stream, void* audioData, int32_t numFrames) override;
@@ -52,6 +60,7 @@ class OboeBridge : public oboe::AudioStreamCallback {
     std::mutex streamLock_;
     std::atomic<bool> active_{false};
     std::atomic<double> latencyMs_{-1.0};
+    std::atomic<uint32_t> callbackCount_{0};
 
     void updateLatency();
     void optimiseBufferSize();