Improve lifecycle handling and stale-writer cleanup

dlclivegui/services/dlc_processor.py: Move the frame copy and enqueue timestamp into the lifecycle lock to avoid unnecessary copying when the processor is stopped; on initialization errors set WorkerState.FAULTED under the lifecycle lock before emitting the error.

dlclivegui/services/multi_camera_controller.py: Reformat the running-cameras shutdown check into a multi-line condition (keeps the same intent of detecting normal shutdown when no cameras are started and all threads are stopped).

dlclivegui/services/video_recorder.py: Add best-effort cleanup for a stale video writer in start() by attempting to call its close() and logging any errors before clearing writer/queue/thread references. Wrap stop() logic with the lifecycle lock to avoid races when stopping, preserve timeout/abandon behavior for a non-terminating writer thread, and ensure writer closure and timestamp saving are handled with proper error logging.

Author: C-Achard

dlclivegui/services/dlc_processor.py

@@ -216,17 +216,15 @@ def shutdown(self) -> None:
         self._initialized = False
 
     def enqueue_frame(self, frame: np.ndarray, timestamp: float) -> None:
-        frame_c = frame.copy()
-        enq_time = time.perf_counter()
-
         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
 
         if q is None:
@@ -492,6 +490,8 @@ def _worker_loop(self, init_frame: np.ndarray, init_timestamp: float) -> None:
 
         except Exception as exc:
             logger.exception("Failed to initialize DLCLive", exc_info=exc)
+            with self._lifecycle_lock:
+                self._state = WorkerState.FAULTED
             self.error.emit(str(exc))
             self.initialized.emit(False)
             return

dlclivegui/services/multi_camera_controller.py

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

dlclivegui/services/video_recorder.py

@@ -93,9 +93,21 @@ def start(self) -> None:
             if self._abandoned:
                 raise RuntimeError("Cannot restart VideoRecorder, as a leftover thread is still running.")
             if self._writer is not None:
-                self._writer = None
-                self._queue = None
-                self._writer_thread = None
+                # Best-effort cleanup of a stale writer to avoid leaking resources.
+                logger.warning(
+                    "VideoRecorder.start() found an existing writer while not running; "
+                    "attempting to close the stale writer before restarting."
+                )
+                try:
+                    close_method = getattr(self._writer, "close", None)
+                    if callable(close_method):
+                        close_method()
+                except Exception:
+                    logger.exception("Error while closing stale video writer in start().")
+                finally:
+                    self._writer = None
+                    self._queue = None
+                    self._writer_thread = None
 
             fps_value = float(self._frame_rate) if self._frame_rate else 30.0
 
@@ -195,46 +207,47 @@ def write(self, frame: np.ndarray, timestamp: float | None = None) -> bool:
         return True
 
     def stop(self) -> None:
-        if self._writer is None and not self.is_running:
-            return
+        with self._lifecycle_lock:
+            if self._writer is None and not self.is_running:
+                return
 
-        self._stop_event.set()
+            self._stop_event.set()
 
-        q = self._queue
-        if q is not None:
-            try:
-                q.put_nowait(_SENTINEL)
-            except queue.Full:
-                pass
-
-        t = self._writer_thread
-        if t is not None:
-            t.join(timeout=5.0)
-            if t.is_alive():
-                with self._stats_lock:
-                    self._encode_error = RuntimeError(
-                        "Failed to stop VideoRecorder within timeout; thread is still alive."
-                    )
-                    self._abandoned = True
-                    logger.critical(
-                        "Failed to stop VideoRecorder within timeout; thread is still alive. "
-                        "Marking recorder as abandoned to prevent restart."
-                    )
-                    return
+            q = self._queue
+            if q is not None:
+                try:
+                    q.put_nowait(_SENTINEL)
+                except queue.Full:
+                    pass
+
+            t = self._writer_thread
+            if t is not None:
+                t.join(timeout=5.0)
+                if t.is_alive():
+                    with self._stats_lock:
+                        self._encode_error = RuntimeError(
+                            "Failed to stop VideoRecorder within timeout; thread is still alive."
+                        )
+                        self._abandoned = True
+                        logger.critical(
+                            "Failed to stop VideoRecorder within timeout; thread is still alive. "
+                            "Marking recorder as abandoned to prevent restart."
+                        )
+                        return
 
-        if self._writer is not None:
-            try:
-                self._writer.close()
-            except Exception:
-                logger.exception("Failed to close WriteGear cleanly")
+            if self._writer is not None:
+                try:
+                    self._writer.close()
+                except Exception:
+                    logger.exception("Failed to close WriteGear cleanly")
 
-        self._save_timestamps()
+            self._save_timestamps()
 
-        self._writer = None
-        self._writer_thread = None
-        self._queue = None
-        self._stop_event.clear()
-        self._abandoned = False
+            self._writer = None
+            self._writer_thread = None
+            self._queue = None
+            self._stop_event.clear()
+            self._abandoned = False
 
     def get_stats(self) -> RecorderStats | None:
         if (