Fix locking, camera check, and writer finalization

Minimize time holding the DLCLiveProcessor lifecycle lock by moving expensive operations (frame.copy and timestamp handling) outside the lock and re-checking state before starting the worker to avoid races. Correct a duplicated condition in MultiCameraController so normal shutdown is detected using self._running. Move writer cleanup into a dedicated _finalize_writer(), add a warning when Queue.task_done() is called too many times, and centralize writer close/exception handling.

Author: C-Achard

dlclivegui/services/dlc_processor.py

@@ -14,8 +14,6 @@
 from typing import Any
 
 import numpy as np
-
-# from dlclive import DLCLive
 from PySide6.QtCore import QObject, Signal
 
 from dlclivegui.config import DLCProcessorSettings, ModelType
@@ -216,16 +214,30 @@ def shutdown(self) -> None:
         self._initialized = False
 
     def enqueue_frame(self, frame: np.ndarray, timestamp: float) -> None:
+        # Keep lifecycle lock held only for quick state checks and snapshots.
         with self._lifecycle_lock:
             if self._state in (WorkerState.STOPPING, WorkerState.FAULTED) or self._stop_event.is_set():
                 return
-            frame_c = frame.copy()
-            enq_time = time.perf_counter()
             t = self._worker_thread
-            if t is None or not t.is_alive():
-                self._start_worker_locked(frame_c, timestamp)
-                return
-            q = self._queue  # snapshot under lock
+            q = self._queue
+            should_start = t is None or not t.is_alive()
+
+        frame_c = frame.copy()
+        enq_time = time.perf_counter()
+
+        if should_start:
+            # Re-acquire the lifecycle lock to safely (re)start the worker if needed.
+            with self._lifecycle_lock:
+                # Re-check state in case it changed while we were copying the frame.
+                if self._state in (WorkerState.STOPPING, WorkerState.FAULTED) or self._stop_event.is_set():
+                    return
+                t = self._worker_thread
+                if t is None or not t.is_alive():
+                    # _start_worker_locked expects the lifecycle lock to be held.
+                    self._start_worker_locked(frame_c, timestamp)
+                    return
+                # Worker is now running; refresh queue snapshot.
+                q = self._queue
 
         if q is None:
             return

dlclivegui/services/multi_camera_controller.py

@@ -514,7 +514,7 @@ def _on_camera_stopped(self, camera_id: str) -> None:
         # Check if all running cameras have stopped (normal shutdown)
         if (
             not self._started_cameras
-            and not self._started_cameras
+            and self._running
             and all(not t.isRunning() for t in self._threads.values() if t is not None)
         ):
             self._running = False

dlclivegui/services/video_recorder.py

@@ -340,15 +340,11 @@ def _writer_loop(self) -> None:
                     try:
                         q.task_done()
                     except ValueError:
+                        logger.warning("Queue task_done() called too many times in writer loop")
                         pass
 
         finally:
-            writer = self._writer
-            if writer is not None:
-                try:
-                    writer.close()
-                except Exception:
-                    logger.exception("Failed to close WriteGear during writer loop finalization")
+            self._finalize_writer()
 
     def _finalize_writer(self) -> None:
         writer = self._writer