fix(qso-recorder): lock-free fast path on audio feeds (#3895 review #3)

ten9876 · claude · ten9876 · commit db3387fda350 · 2026-06-30T08:36:11.000-07:00
feedTxAudio/feedRxAudio took m_writeMutex *before* their fast-path checks. The new CW record pump calls feedTxAudio ~100x/s from the real-time audio thread; if the GUI thread holds m_writeMutex during stopRecording/finalize disk I/O, the audio thread blocks inside the real-time path -> xrun. (RX feed has the same shape and is fed continuously from the RX audio thread.) Make m_recording std::atomic<bool> and check the atomics (m_recording + m_transmitting) lock-free before taking the mutex, returning early in the common not-recording / wrong-direction case. The post-lock re-check stays authoritative, so behavior is unchanged — only the lock is skipped when there's nothing to write. Per maintainer call on the other items: #1 (CW pump architecture) is not a blocker; #2 (RecordingMode "Client" default) is approved as-is. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
diff --git a/src/core/QsoRecorder.cpp b/src/core/QsoRecorder.cpp
@@ -125,6 +125,13 @@ static QByteArray float32ToInt16(const QByteArray& pcm)
 
 void QsoRecorder::feedRxAudio(const QByteArray& pcm)
 {
+    // Lock-free fast path off the real-time audio thread: skip the mutex when
+    // we're not recording an RX over, so a GUI thread holding m_writeMutex
+    // during finalize/stop can't stall audio. The post-lock check stays
+    // authoritative (m_recording/m_transmitting can flip after this read).
+    if (!m_recording.load(std::memory_order_acquire)
+        || m_transmitting.load(std::memory_order_acquire))
+        return;
     std::lock_guard<std::mutex> lock(m_writeMutex);
     // While transmitting the radio mutes RX (this stream would be silence), and
     // the TX monitor is recorded instead — skip RX so the two don't double-write
@@ -137,6 +144,13 @@ void QsoRecorder::feedRxAudio(const QByteArray& pcm)
 
 void QsoRecorder::feedTxAudio(const QByteArray& int16Stereo)
 {
+    // Lock-free fast path: the CW record pump calls this ~100×/s from the
+    // real-time audio thread. Skip the mutex when we're not recording a TX over
+    // so a GUI thread holding m_writeMutex during finalize/stop can't stall
+    // audio (xrun). The post-lock check stays authoritative.
+    if (!m_recording.load(std::memory_order_acquire)
+        || !m_transmitting.load(std::memory_order_acquire))
+        return;
     std::lock_guard<std::mutex> lock(m_writeMutex);
     // Only capture the TX monitor while actually transmitting (the tap can fire
     // whenever mic capture runs), so RX and TX never both write.
diff --git a/src/core/QsoRecorder.h b/src/core/QsoRecorder.h
@@ -133,7 +133,7 @@ private slots:
     bool preparePlaybackPcm(int sinkRateHz);
 
     // Recording state
-    bool        m_recording{false};
+    std::atomic<bool> m_recording{false};  // checked lock-free on the audio feed fast path
     std::atomic<bool> m_transmitting{false};  // MOX state; gates RX vs TX writes (#3556)
     QFile*      m_file{nullptr};
     QDateTime   m_startTime;
