Harden Win10 audio path by moving RX feed off SDL callback thread

Author: secup

src/gui/app.cpp

@@ -1491,6 +1491,10 @@ void App::render() {
         ultra::gui::startupTrace("App", "render-set-output-gain-exit");
     }
 
+    // Process captured RX audio in the main thread.
+    // Avoids feeding modem state directly from SDL callback threads.
+    pollRadioRx();
+
     // Safe-startup mode: auto-start audio shortly after first frame.
     // Keeps process bring-up lightweight while preserving "auto-listen" behavior.
     if (deferred_audio_auto_init_pending_ &&
@@ -1719,12 +1723,8 @@ void App::startRadioRx() {
         return;
     }
 
-    audio_.setRxCallback([this](const std::vector<float>& samples) {
-        modem_.feedAudio(samples);
-        if (waterfall_) {
-            waterfall_->addSamples(samples.data(), samples.size());
-        }
-    });
+    // Main thread polls captured samples via pollRadioRx().
+    audio_.setRxCallback(AudioEngine::RxCallback{});
 
     audio_.setLoopbackEnabled(false);
     audio_.startCapture();
@@ -1734,9 +1734,31 @@ void App::startRadioRx() {
 void App::stopRadioRx() {
     audio_.stopCapture();
     audio_.closeInput();
+    audio_.setRxCallback(AudioEngine::RxCallback{});
     radio_rx_enabled_ = false;
 }
 
+void App::pollRadioRx() {
+    if (!audio_initialized_ || simulation_enabled_ || !radio_rx_enabled_) {
+        return;
+    }
+
+    // Bounded drain per frame to keep UI responsive while preventing RX backlog.
+    constexpr size_t kChunkSamples = 2048;
+    constexpr int kMaxChunksPerFrame = 8;
+    for (int i = 0; i < kMaxChunksPerFrame; ++i) {
+        auto samples = audio_.getRxSamples(kChunkSamples);
+        if (samples.empty()) {
+            break;
+        }
+
+        modem_.feedAudio(samples);
+        if (waterfall_) {
+            waterfall_->addSamples(samples.data(), samples.size());
+        }
+    }
+}
+
 void App::stopTxNow(const char* reason) {
     size_t dropped_audio = audio_.getTxQueueSize();
     if (dropped_audio > 0) {

src/gui/app.hpp

@@ -197,6 +197,7 @@ class App {
     void updateAdaptiveAdvisory(float snr_db, float fading_index);
     void startRadioRx();
     void stopRadioRx();
+    void pollRadioRx();
 
     // Helper to get device name from settings (returns empty string for "Default")
     std::string getInputDeviceName() const;

src/gui/audio_engine.cpp

@@ -81,6 +81,11 @@ std::vector<std::string> AudioEngine::getInputDevices() {
     return devices;
 }
 
+void AudioEngine::setRxCallback(RxCallback callback) {
+    std::lock_guard<AudioEngineMutex> lock(rx_callback_mutex_);
+    rx_callback_ = std::move(callback);
+}
+
 bool AudioEngine::openOutput(const std::string& device) {
     if (!initialized_) {
         if (!initialize()) return false;
@@ -159,7 +164,7 @@ void AudioEngine::closeInput() {
 }
 
 void AudioEngine::queueTxSamples(const std::vector<float>& samples) {
-    std::lock_guard<std::mutex> lock(tx_mutex_);
+    std::lock_guard<AudioEngineMutex> lock(tx_mutex_);
     for (float s : samples) {
         tx_queue_.push(s);
     }
@@ -170,7 +175,7 @@ void AudioEngine::queueTxSamples(const std::vector<float>& samples) {
         std::vector<float> loopback_samples = samples;
         addChannelNoise(loopback_samples);
 
-        std::lock_guard<std::mutex> rx_lock(rx_mutex_);
+        std::lock_guard<AudioEngineMutex> rx_lock(rx_mutex_);
 
         // Cap buffer size to prevent unbounded growth
         if (rx_buffer_.size() + loopback_samples.size() > MAX_RX_BUFFER_SAMPLES) {
@@ -191,23 +196,23 @@ void AudioEngine::queueTxSamples(const std::vector<float>& samples) {
 }
 
 void AudioEngine::clearTxQueue() {
-    std::lock_guard<std::mutex> lock(tx_mutex_);
+    std::lock_guard<AudioEngineMutex> lock(tx_mutex_);
     std::queue<float> empty;
     std::swap(tx_queue_, empty);
 }
 
 bool AudioEngine::isTxQueueEmpty() const {
-    std::lock_guard<std::mutex> lock(tx_mutex_);
+    std::lock_guard<AudioEngineMutex> lock(tx_mutex_);
     return tx_queue_.empty();
 }
 
 size_t AudioEngine::getTxQueueSize() const {
-    std::lock_guard<std::mutex> lock(tx_mutex_);
+    std::lock_guard<AudioEngineMutex> lock(tx_mutex_);
     return tx_queue_.size();
 }
 
 std::vector<float> AudioEngine::getRxSamples(size_t max_samples) {
-    std::lock_guard<std::mutex> lock(rx_mutex_);
+    std::lock_guard<AudioEngineMutex> lock(rx_mutex_);
 
     size_t count = std::min(max_samples, rx_buffer_.size());
     std::vector<float> samples(rx_buffer_.begin(), rx_buffer_.begin() + count);
@@ -217,7 +222,7 @@ std::vector<float> AudioEngine::getRxSamples(size_t max_samples) {
 }
 
 size_t AudioEngine::getRxBufferSize() const {
-    std::lock_guard<std::mutex> lock(rx_mutex_);
+    std::lock_guard<AudioEngineMutex> lock(rx_mutex_);
     return rx_buffer_.size();
 }
 
@@ -250,7 +255,7 @@ void AudioEngine::stopCapture() {
 }
 
 void AudioEngine::clearRxBuffer() {
-    std::lock_guard<std::mutex> lock(rx_mutex_);
+    std::lock_guard<AudioEngineMutex> lock(rx_mutex_);
     rx_buffer_.clear();
 }
 
@@ -267,7 +272,7 @@ void AudioEngine::outputCallback(void* userdata, Uint8* stream, int len) {
     float sum_sq = 0.0f;
     float gain = engine->output_gain_.load();
 
-    std::lock_guard<std::mutex> lock(engine->tx_mutex_);
+    std::lock_guard<AudioEngineMutex> lock(engine->tx_mutex_);
 
     for (int i = 0; i < samples; ++i) {
         float out = 0.0f;
@@ -318,7 +323,7 @@ void AudioEngine::inputCallback(void* userdata, Uint8* stream, int len) {
     engine->input_level_ = rms;
 
     {
-        std::lock_guard<std::mutex> lock(engine->rx_mutex_);
+        std::lock_guard<AudioEngineMutex> lock(engine->rx_mutex_);
 
         // Cap buffer size to prevent unbounded growth if main loop stalls
         if (engine->rx_buffer_.size() + captured.size() > MAX_RX_BUFFER_SAMPLES) {
@@ -333,8 +338,13 @@ void AudioEngine::inputCallback(void* userdata, Uint8* stream, int len) {
     }
 
     // Notify via callback (skip if muted during TX)
-    if (engine->rx_callback_ && !engine->rx_muted_.load()) {
-        engine->rx_callback_(captured);
+    AudioEngine::RxCallback rx_cb;
+    {
+        std::lock_guard<AudioEngineMutex> cb_lock(engine->rx_callback_mutex_);
+        rx_cb = engine->rx_callback_;
+    }
+    if (rx_cb && !engine->rx_muted_.load()) {
+        rx_cb(captured);
     }
 }
 

src/gui/audio_engine.hpp

@@ -7,10 +7,36 @@
 #include <atomic>
 #include <string>
 #include <functional>
+#ifdef _WIN32
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
+#ifdef ERROR
+#undef ERROR
+#endif
+#endif
 
 namespace ultra {
 namespace gui {
 
+#ifdef _WIN32
+class AudioEngineMutex {
+public:
+    AudioEngineMutex() noexcept = default;
+    AudioEngineMutex(const AudioEngineMutex&) = delete;
+    AudioEngineMutex& operator=(const AudioEngineMutex&) = delete;
+
+    void lock() noexcept { AcquireSRWLockExclusive(&lock_); }
+    void unlock() noexcept { ReleaseSRWLockExclusive(&lock_); }
+
+private:
+    SRWLOCK lock_ = SRWLOCK_INIT;
+};
+#else
+using AudioEngineMutex = std::mutex;
+#endif
+
 // Audio engine for real-time audio I/O using SDL2
 class AudioEngine {
 public:
@@ -80,7 +106,7 @@ class AudioEngine {
 
     // Callback for when RX has data ready
     using RxCallback = std::function<void(const std::vector<float>&)>;
-    void setRxCallback(RxCallback callback) { rx_callback_ = callback; }
+    void setRxCallback(RxCallback callback);
 
 private:
     // SDL audio callbacks
@@ -95,11 +121,11 @@ class AudioEngine {
 
     // TX buffer (samples waiting to be played)
     std::queue<float> tx_queue_;
-    mutable std::mutex tx_mutex_;
+    mutable AudioEngineMutex tx_mutex_;
 
     // RX buffer (captured samples)
     std::vector<float> rx_buffer_;
-    mutable std::mutex rx_mutex_;
+    mutable AudioEngineMutex rx_mutex_;
 
     // Loopback settings
     std::atomic<bool> loopback_enabled_{false};
@@ -121,6 +147,7 @@ class AudioEngine {
 
     // RX callback
     RxCallback rx_callback_;
+    mutable AudioEngineMutex rx_callback_mutex_;
 
     // Random generator for noise
     uint32_t noise_seed_ = 12345;