fix: resolve shutdown deadlock, unblock quit signal, and fix thread synchronization

Author: ldl805

CHANGELOG.md

@@ -5,7 +5,15 @@ All notable changes to **StreamMatrix** will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
----
+## [1.0.1] - 2026-08-29
+
+### Fixed
+- **Shutdown and Quit Execution**: Connected QML engine `quit` signal to `QGuiApplication::quit` and added window `onClosing` hook, resolving issues where the app ignored quit shortcuts and menu actions.
+- **Worker Thread Deadlock Prevention**: Fixed `requestInterrupt` across decoder waiting queues to properly wake blocked producer threads during shutdown and feed cancellation.
+- **Demuxer Loop Flood on Failure**: Corrected decode error propagation in the demuxer loop to prevent tight infinite loop spinning and event queue saturation.
+- **Thread Concurrency in `wait()`**: Synchronized worker thread completion waiting on condition variables to prevent concurrent `join()` data races.
+- **Video Buffer Plane Count**: Ensured planar video buffer returns accurate active plane counts to prevent out-of-bounds plane sampling in Qt Quick rendering.
+- **Context Double-Free**: Added pointer safety in `Context` destructor.
 
 ## [1.0.0] - 2026-08-24
 

CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.14)
 
 set(VER_MAJ 1)
 set(VER_MIN 0)
-set(VER_PAT 0)
+set(VER_PAT 1)
 set(REL_STATUS "alpha")
 
 set(APP_NAME "StreamMatrix")

src/RootWindow.qml

@@ -22,6 +22,8 @@ ApplicationWindow {
     width: rootWindowSettings.width
     height: rootWindowSettings.height
 
+    onClosing: Qt.quit()
+
     // Right-to-left User Interfaces support
     LayoutMirroring.enabled: Qt.application.layoutDirection == Qt.RightToLeft
     LayoutMirroring.childrenInherit: true

src/context.cpp

@@ -3,7 +3,10 @@
 
 Context::~Context()
 {
-    delete m_config;
+    if (m_config) {
+        delete m_config;
+        m_config = nullptr;
+    }
 }
 
 void Context::init()

src/main.cpp

@@ -98,6 +98,7 @@ int main(int argc, char *argv[])
         if (!obj && url == objUrl)
             QCoreApplication::exit(-1);
     }, Qt::QueuedConnection);
+    QObject::connect(&engine, &QQmlApplicationEngine::quit, &app, &QGuiApplication::quit);
     engine.load(url);
 
     return app.exec();

src/qmlav/src/qmlavdecoder.cpp

@@ -89,8 +89,7 @@ QString QmlAVDecoder::name() const
 bool QmlAVDecoder::decodeAVPacket(const AVPacketPtr &avPacket)
 {
     if (isOpen()) {
-        m_threadTask(this, avPacket);
-        return true;
+        return m_threadTask(this, avPacket);
     }
 
     return false;

src/qmlav/src/qmlavdemuxer.cpp

@@ -160,9 +160,13 @@ void QmlAVDemuxer::start()
         }
 
         if (avPacket->stream_index == m_context->videoDecoder->streamIndex()) {
-            m_context->videoDecoder->decodeAVPacket(avPacket) || stop();
+            if (!m_context->videoDecoder->decodeAVPacket(avPacket)) {
+                return stop();
+            }
         } else if (avPacket->stream_index == m_context->audioDecoder->streamIndex()) {
-            m_context->audioDecoder->decodeAVPacket(avPacket) || stop();
+            if (!m_context->audioDecoder->decodeAVPacket(avPacket)) {
+                return stop();
+            }
         } else {
             return 1; // Minimal sleep time
         }

src/qmlav/src/qmlavdemuxer.h

@@ -22,27 +22,49 @@ class QmlAVInterruptCallback : public AVIOInterruptCB
     QmlAVInterruptCallback() {
         opaque = this;
         callback = [](void *opaque) -> int {
-            assert(opaque);
+            if (!opaque) return 1;
             auto cb = static_cast<QmlAVInterruptCallback *>(opaque);
-            return cb->isAVInterruptRequested() || (cb->m_expireTime > 0 && av_gettime_relative() > cb->m_expireTime);
+            if (cb->isAVInterruptRequested()) return 1;
+            int64_t expire = cb->m_expireTime.load(std::memory_order_relaxed);
+            if (expire > 0 && av_gettime_relative() > expire) return 1;
+            return 0;
         };
     }
 
-    void requestAVInterrupt() { m_avInterruptRequested.store(true, std::memory_order_relaxed); }
-    bool isAVInterruptRequested() const { return m_avInterruptRequested.load(std::memory_order_relaxed); }
+    QmlAVInterruptCallback(const QmlAVInterruptCallback &other) : AVIOInterruptCB() {
+        opaque = this;
+        callback = other.callback;
+        m_timeout.store(other.m_timeout.load(std::memory_order_relaxed), std::memory_order_relaxed);
+        m_expireTime.store(other.m_expireTime.load(std::memory_order_relaxed), std::memory_order_relaxed);
+        m_avInterruptRequested.store(other.m_avInterruptRequested.load(std::memory_order_relaxed), std::memory_order_relaxed);
+    }
+
+    QmlAVInterruptCallback &operator=(const QmlAVInterruptCallback &other) {
+        if (this != &other) {
+            opaque = this;
+            callback = other.callback;
+            m_timeout.store(other.m_timeout.load(std::memory_order_relaxed), std::memory_order_relaxed);
+            m_expireTime.store(other.m_expireTime.load(std::memory_order_relaxed), std::memory_order_relaxed);
+            m_avInterruptRequested.store(other.m_avInterruptRequested.load(std::memory_order_relaxed), std::memory_order_relaxed);
+        }
+        return *this;
+    }
+
+    void requestAVInterrupt() { m_avInterruptRequested.store(true, std::memory_order_release); }
+    bool isAVInterruptRequested() const { return m_avInterruptRequested.load(std::memory_order_acquire); }
 
-    // NOTE: Not thread safe!
     void setTimeout(int64_t timeout) {
-        m_timeout = timeout;
+        m_timeout.store(timeout, std::memory_order_relaxed);
         resetTimer();
     }
     void resetTimer() {
-        m_expireTime = av_gettime_relative() + m_timeout;
+        int64_t t = m_timeout.load(std::memory_order_relaxed);
+        m_expireTime.store(t > 0 ? (av_gettime_relative() + t) : 0, std::memory_order_relaxed);
     }
 
 private:
-    int64_t m_timeout = 0;
-    int64_t m_expireTime = 0;
+    std::atomic<int64_t> m_timeout = 0;
+    std::atomic<int64_t> m_expireTime = 0;
     std::atomic<bool> m_avInterruptRequested = false;
 };
 

src/qmlav/src/qmlavthread.h

@@ -61,7 +61,7 @@ class QmlAVWorkerResultImpl : public QmlAVAbstractWorker
     }
 
     virtual void requestInterrupt() override {
-        m_results.setConsumerLimit(0);
+        m_results.requestInterrupt();
     }
 
 protected:
@@ -173,7 +173,7 @@ class QmlAVWorker<Callable, std::shared_ptr<ArgsQueue>> : public QmlAVWorkerInvo
 
     virtual void requestInterrupt() override final {
         if (m_argsQueue) {
-            m_argsQueue->setConsumerLimit(0);
+            m_argsQueue->requestInterrupt();
         }
 
         __Super::requestInterrupt();
@@ -194,6 +194,9 @@ class QmlAVWorkerThread
     virtual ~QmlAVWorkerThread() {
         requestInterrupt();
         wait();
+        if (m_thread.joinable() && std::this_thread::get_id() != m_thread.get_id()) {
+            m_thread.join();
+        }
     }
 
     void start() {
@@ -202,8 +205,8 @@ class QmlAVWorkerThread
         }
     }
     void wait() {
-        if (m_thread.joinable() && std::this_thread::get_id() != m_thread.get_id()) {
-            m_thread.join();
+        if (std::this_thread::get_id() == m_thread.get_id()) {
+            return;
         }
         std::unique_lock<std::mutex> lock(m_mutex);
         m_waitCond.wait(lock, [&] {
@@ -355,8 +358,8 @@ class QmlAVThreadTask
     auto argsQueue() const { return m_argsQueue; }
 
     template<typename ...URef>
-    void operator() (URef &&...args) {
-        m_argsQueue->enqueue(std::forward_as_tuple(args...));
+    bool operator() (URef &&...args) {
+        return m_argsQueue->enqueue(std::forward_as_tuple(args...));
     }
 
     auto getLiveController() {

src/qmlav/src/qmlavvideobuffer.cpp

@@ -30,14 +30,21 @@ int QmlAVVideoBuffer::map(QAbstractVideoBuffer::MapMode mode, int *numBytes, int
 
     auto mapData = map(mode);
 
-    int i = 0;
-    for (*numBytes = 0; i < QMLAV_NUM_DATA_POINTERS; ++i) {
-        *numBytes += mapData.size[i];
-        bytesPerLine[i] = mapData.bytesPerLine[i];
-        data[i] = mapData.data[i];
+    int planesCount = 0;
+    *numBytes = 0;
+    for (int i = 0; i < QMLAV_NUM_DATA_POINTERS; ++i) {
+        if (mapData.data[i] && mapData.size[i] > 0) {
+            *numBytes += mapData.size[i];
+            bytesPerLine[i] = mapData.bytesPerLine[i];
+            data[i] = mapData.data[i];
+            planesCount = i + 1;
+        } else {
+            bytesPerLine[i] = 0;
+            data[i] = nullptr;
+        }
     }
 
-    return i;
+    return planesCount;
 }
 
 bool QmlAVVideoBuffer::planeSizes(int size[]) const