SG-40625 - Play Forward/Pause button stops responding when playing media files (Linux) (#994)

SG-40625 - Play Forward/Pause button stops responding when playing media
files (Linux)

### Linked issues
n/a

### Summarize your change.

### Describe the reason for the change.

There was a stability problem where calling `stop()` or `reset()` on the
`QAudioOutput` object would cause audio playback to break after multiple
play/stop cycles. To work around this, suspend() was used instead, which
solved the instability. However, this introduced a second problem:
`suspend()` does not clear the audio device's internal buffer. This
resulted in an audio bleed issue, where sound from the previously played
media could be heard for a fraction of a second when starting a new one.

### Describe what you have tested and on which operating system.

This change introduces a new flushing mechanism that resolves the audio
bleed on Linux while avoiding the unstable `stop() `and `reset()` calls.

When playback is stopped, instead of immediately suspending the audio
device, a new flushing process is initiated. The audio device is kept
active momentarily while it is fed with silent audio data, completely
overwriting the contents of its internal buffer. Once the buffer is
flushed, the device is safely suspended.

This ensures that the audio buffer is clear before the next playback
begins, eliminating audio bleed. Because this approach continues to use
`suspend()` to halt the device, it maintains the stability of the audio
system.

**This logic is confined to the Linux platform and does not affect the
behavior on MacOS or Windows.**

### Add a list of changes, and note any that might need special
attention during the review.

### If possible, provide screenshots.

---------

Signed-off-by: Cédrik Fuoco <[email protected]>

Author: cedrik-fuoco-adsk

src/lib/audio/QTAudioRenderer/QTAudioRenderer.cpp

@@ -659,7 +659,8 @@ namespace IPCore
     //      with the audio thread.
     //----------------------------------------------------------------------
     QTAudioIODevice::QTAudioIODevice(QTAudioThread& audiothread)
-        : m_thread(audiothread){QTAUDIO_DEBUG("QTAudioIODevice:")}
+        : m_thread(audiothread)
+        , m_silence(false){QTAUDIO_DEBUG("QTAudioIODevice:")}
 
         QTAudioIODevice::~QTAudioIODevice()
     {
@@ -686,6 +687,23 @@ namespace IPCore
     qint64 QTAudioIODevice::readData(char* data, qint64 maxLenInBytes)
     {
         //  QTAUDIO_DEBUG("QTAudioIODevice::readData")
+        if (m_thread.audioOutput()->isFlushing())
+        {
+            memset(data, 0, maxLenInBytes);
+            m_thread.audioOutput()->accumulateFlushedBytes(maxLenInBytes);
+            if (m_thread.audioOutput()->flushedEnough())
+            {
+                m_thread.audioOutput()->suspendAudio();
+                m_thread.audioOutput()->doneFlushing();
+            }
+            return maxLenInBytes;
+        }
+
+        if (m_silence)
+        {
+            memset(data, 0, maxLenInBytes);
+            return maxLenInBytes;
+        }
         int bytesWritten = m_thread.qIODeviceCallback(data, maxLenInBytes);
         return bytesWritten;
     }
@@ -712,7 +730,9 @@ namespace IPCore
         , m_device(audioDevice)
         , m_format(audioFormat)
         , m_ioDevice(ioDevice)
-        , m_thread(audioThread){QTAUDIO_DEBUG("QTAudioOutput")}
+        , m_thread(audioThread)
+        , m_isFlushing(false)
+        , m_flushedBytes(0){QTAUDIO_DEBUG("QTAudioOutput")}
 
         QTAudioOutput::~QTAudioOutput()
     {
@@ -739,6 +759,8 @@ namespace IPCore
     {
         QTAUDIO_DEBUG("QTAudioOutput::startAudio check")
 
+        doneFlushing();
+
         if (state() == QAudio::StoppedState)
         {
             m_thread.startOfInitialization();
@@ -753,6 +775,7 @@ namespace IPCore
             // again before calling start().
             setAudioOutputBufferSize();
 #endif
+            m_ioDevice.stopProducingSilence();
             m_thread.setStartSample(0);
             m_thread.setProcessedSamples(0);
             m_thread.setPreRollDelay(0);
@@ -764,6 +787,7 @@ namespace IPCore
 #ifdef PLATFORM_LINUX
             m_thread.setPreRollDelay(0);
 #endif
+            m_ioDevice.stopProducingSilence();
             resume();
         }
     }
@@ -783,7 +807,12 @@ namespace IPCore
 
         if (state() != QAudio::StoppedState)
         {
+#ifdef PLATFORM_LINUX
+            // On Linux, use suspend() instead of stop() to avoid audio corruption after multiple cycles
+            suspend();
+#else
             stop();
+#endif
         }
     }
 
@@ -797,16 +826,39 @@ namespace IPCore
         }
     }
 
+    void QTAudioOutput::startFlushing()
+    {
+        m_isFlushing = true;
+        m_flushedBytes = 0;
+    }
+
     void QTAudioOutput::suspendAndResetAudio()
     {
         QTAUDIO_DEBUG("QTAudioOutput::suspendAndResetAudio")
 
         if (state() != QAudio::StoppedState)
         {
+#ifdef PLATFORM_LINUX
+            // On Linux, to avoid audio corruption after multiple cycles, we
+            // cannot call reset() or suspend() directly as the internal
+            // buffer will not be cleared, causing audio bleed. Instead,
+            // we start a flushing process that will feed the sink with
+            // silence until its buffer is cleared, and then suspend it.
+            if (state() == QAudio::ActiveState)
+            {
+                startFlushing();
+            }
+            else
+            {
+                suspend();
+            }
+#else
             suspend();
+            // On non-Linux platforms, do a full reset to clear buffers immediately
             QTAUDIO_DEBUG("QTAudioOutput::suspendAndResetAudio - before reset")
             reset();
             QTAUDIO_DEBUG("QTAudioOutput::suspendAndResetAudio - after reset")
+#endif
         }
     }
 

src/lib/audio/QTAudioRenderer/QTAudioRenderer/QTAudioRenderer.h

@@ -48,12 +48,17 @@ namespace IPCore
 
         void start();
 
+        void startProducingSilence() { m_silence = true; }
+
+        void stopProducingSilence() { m_silence = false; }
+
     public slots:
         void resetDevice();
         void stopDevice();
 
     private:
         QTAudioThread& m_thread;
+        bool m_silence = false;
     };
 
     class QTAudioOutput : public QAudioSink
@@ -64,6 +69,16 @@ namespace IPCore
         QTAudioOutput(QAudioDevice& audioDevice, QAudioFormat& audioFormat, QTAudioIODevice& ioDevice, QTAudioThread& audioThread);
         ~QTAudioOutput();
 
+        bool isFlushing() const { return m_isFlushing; }
+
+        void startFlushing();
+
+        void doneFlushing() { m_isFlushing = false; }
+
+        void accumulateFlushedBytes(qint64 n) { m_flushedBytes += n; }
+
+        bool flushedEnough() const { return m_flushedBytes >= bufferSize(); }
+
     public slots:
         void startAudio();
         void resetAudio();
@@ -82,6 +97,8 @@ namespace IPCore
         QAudioFormat& m_format;
         QTAudioIODevice& m_ioDevice;
         QTAudioThread& m_thread;
+        bool m_isFlushing = false;
+        qint64 m_flushedBytes;
     };
 
     class QTAudioThread : public QThread