Optimize all native features for lowest possible latency

Audio (Oboe):
- Enable MMAP (hardware DMA path, bypasses kernel copy, ~1-2ms lower)
- Switch to Mono output (halves buffer for measurement stream)
- Disable all internal conversions (channel/format/sample-rate)
- Sample latency every 128 callbacks (avoid syscall jitter in hot path)
- Reset callback counter on stop/recovery

Build:
- CMake: -O3 -ffast-math -ffunction-sections -fdata-sections (max vectorization)
- Linker: --gc-sections -s (dead code elimination + strip symbols)

Agent-Logs-Url: https://github.com/winnerspiros/osu/sessions/89b53171-bb76-44d0-9986-affb5059fb3c

Co-authored-by: winnerspiros <1675249+winnerspiros@users.noreply.github.com>

Author: Copilot

osu.Android/Native/CMakeLists.txt

@@ -3,9 +3,15 @@ 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).

osu.Android/Native/oboe_bridge.cpp

@@ -23,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)
@@ -123,6 +136,7 @@ void OboeBridge::stop() {
     }
 
     latencyMs_.store(-1.0);
+    callbackCount_.store(0);
     LOGI("Oboe stream stopped");
 }
 
@@ -170,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;
 }

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:
@@ -56,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();