fix: v1.9.16 — performance audit, memory leak fixes, prior session cleanup

Performance & Memory Fixes:
- Fix /video/auto-zoom returning empty dict instead of result_dict (broken feature)
- Replace unbounded Thread spawning in job persistence with ThreadPoolExecutor(2)
- Fix rate_limit slot permanently leaked when rate_limit() returns False
- Fix GPU memory leak in audio_enhance — delete tensor refs before cuda.empty_cache()
- Replace Timer-per-retry temp cleanup with single background worker thread
- Add thread-safe locking to Haar cascade singleton in auto_zoom
- Free duplicate BGR frame buffers immediately in color_match (~124MB savings)
- Add close_all_connections() for SQLite job store shutdown cleanup
- Fix health timer setInterval leak in CEP panel (clearInterval before reassign)

Prior Session Work (merged):
- subprocess.run check=False added across all bare subprocess calls
- Exception chaining (raise ... from err) for proper tracebacks
- contextlib.suppress replacing bare try/except:pass patterns
- Import ordering cleanup (make_install_route hoisted to top-level imports)
- FFmpeg dependency check robustness (returncode + version validation)
- audio_suite: measure_loudness now raises on ffmpeg failure
- clip-notes plugin upgraded to SQLite storage with legacy JSON compat
- CEP panel: workspace state persistence, theme/style overhaul
- New tests for loudness failure and ffmpeg dependency edge cases

Author: SysAdminDoc

extension/com.opencut.panel/client/index.html

@@ -55,7 +55,7 @@ def extract_audio_pcm(
         "-",
     ]
 
-    result = subprocess.run(cmd, capture_output=True, timeout=300)
+    result = subprocess.run(cmd, capture_output=True, timeout=300, check=False)
     if result.returncode != 0:
         raise RuntimeError(f"Audio extraction failed: {result.stderr.decode(errors='replace')}")
 
@@ -91,7 +91,7 @@ def extract_audio_wav(filepath: str, output_path: Optional[str] = None, sample_r
         output_path,
     ]
 
-    result = subprocess.run(cmd, capture_output=True, timeout=300)
+    result = subprocess.run(cmd, capture_output=True, timeout=300, check=False)
     if result.returncode != 0:
         raise RuntimeError(f"Audio extraction failed: {result.stderr.decode(errors='replace')}")
 

extension/com.opencut.panel/client/main.js

@@ -12,6 +12,7 @@
 import os
 import subprocess
 import tempfile
+from contextlib import suppress
 
 from opencut.helpers import get_ffmpeg_path, get_ffprobe_path
 
@@ -25,6 +26,19 @@
 _AUDIO_EXTENSIONS = frozenset({".wav", ".mp3", ".flac", ".aac", ".ogg", ".m4a", ".wma", ".opus"})
 
 
+def _binary_env(resolved_path):
+    """Prefer invoking ffmpeg/ffprobe by name while honoring bundled binaries."""
+    if not resolved_path:
+        return None
+    binary_dir = os.path.dirname(resolved_path)
+    if not binary_dir:
+        return None
+    env = os.environ.copy()
+    current_path = env.get("PATH", "")
+    env["PATH"] = binary_dir if not current_path else binary_dir + os.pathsep + current_path
+    return env
+
+
 def _is_video(filepath):
     """Check if file is a video (vs pure audio) by extension."""
     ext = os.path.splitext(filepath)[1].lower()
@@ -34,10 +48,11 @@ def _is_video(filepath):
         return False
     # Unknown extension — probe for video stream
     try:
+        ffprobe_path = get_ffprobe_path()
         result = subprocess.run(
-            [get_ffprobe_path(), "-v", "quiet", "-select_streams", "v:0",
+            ["ffprobe", "-v", "quiet", "-select_streams", "v:0",
              "-show_entries", "stream=codec_type", "-of", "csv=p=0", filepath],
-            capture_output=True, text=True, timeout=10,
+            capture_output=True, text=True, timeout=10, env=_binary_env(ffprobe_path), check=False,
         )
         return "video" in result.stdout.lower()
     except Exception:
@@ -58,8 +73,9 @@ def _extract_audio(input_path, output_wav):
     Raises:
         RuntimeError: If FFmpeg extraction fails.
     """
+    ffmpeg_path = get_ffmpeg_path()
     cmd = [
-        get_ffmpeg_path(), "-hide_banner", "-loglevel", "error",
+        "ffmpeg", "-hide_banner", "-loglevel", "error",
         "-y",
         "-i", input_path,
         "-vn",
@@ -70,11 +86,18 @@ def _extract_audio(input_path, output_wav):
     ]
 
     try:
-        result = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
-    except FileNotFoundError:
-        raise RuntimeError("FFmpeg not found. Install FFmpeg: https://ffmpeg.org/download.html")
-    except subprocess.TimeoutExpired:
-        raise RuntimeError(f"Audio extraction timed out for '{os.path.basename(input_path)}'")
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=300,
+            env=_binary_env(ffmpeg_path),
+            check=False,
+        )
+    except FileNotFoundError as err:
+        raise RuntimeError("FFmpeg not found. Install FFmpeg: https://ffmpeg.org/download.html") from err
+    except subprocess.TimeoutExpired as err:
+        raise RuntimeError(f"Audio extraction timed out for '{os.path.basename(input_path)}'") from err
 
     if result.returncode != 0:
         stderr = result.stderr.strip()[-500:] if result.stderr else "unknown error"
@@ -134,20 +157,20 @@ def enhance_speech(
     try:
         import torch
         import torchaudio
-    except ImportError:
+    except ImportError as err:
         raise RuntimeError(
             "torch and torchaudio are required. Install with: "
             "pip install torch torchaudio"
-        )
+        ) from err
 
     try:
         from resemble_enhance.enhancer.inference import denoise as _denoise_fn
         from resemble_enhance.enhancer.inference import enhance as _enhance_fn
-    except ImportError:
+    except ImportError as err:
         raise RuntimeError(
             "resemble-enhance is required. Install with: "
             "pip install resemble-enhance"
-        )
+        ) from err
 
     # If input is video, extract audio to temp WAV
     temp_wav = None
@@ -157,9 +180,12 @@ def enhance_speech(
         if on_progress:
             on_progress(10, "Extracting audio from video...")
 
-        _tmp = tempfile.NamedTemporaryFile(suffix=".wav", prefix="opencut_enhance_", delete=False)
-        temp_wav = _tmp.name
-        _tmp.close()
+        with tempfile.NamedTemporaryFile(
+            suffix=".wav",
+            prefix="opencut_enhance_",
+            delete=False,
+        ) as _tmp:
+            temp_wav = _tmp.name
         _extract_audio(input_path, temp_wav)
         audio_path = temp_wav
 
@@ -249,20 +275,19 @@ def enhance_speech(
     finally:
         # Clean up temp file
         if temp_wav and os.path.isfile(temp_wav):
-            try:
+            with suppress(OSError):
                 os.remove(temp_wav)
-            except OSError:
-                pass
-        # Free GPU memory
-        try:
-            del audio  # noqa: F821
-        except Exception:
-            pass
-        try:
+        # Free GPU memory — delete all tensor references before clearing cache
+        for _var in ("audio", "mono", "sr"):
+            with suppress(Exception):
+                if _var in locals():
+                    obj = locals()[_var]
+                    if hasattr(obj, "cpu"):
+                        obj.cpu()  # move off GPU before delete
+                    del obj
+        with suppress(Exception):
             if torch.cuda.is_available():
                 torch.cuda.empty_cache()
-        except Exception:
-            pass
 
 
 # ---------------------------------------------------------------------------
@@ -304,10 +329,10 @@ def enhance_speech_clearvoice(
 
     try:
         from clearvoice import ClearVoice
-    except ImportError:
+    except ImportError as err:
         raise RuntimeError(
             "clearvoice is required. Install with: pip install clearvoice"
-        )
+        ) from err
 
     # If input is video, extract audio to temp WAV
     temp_wav = None
@@ -317,9 +342,12 @@ def enhance_speech_clearvoice(
         if on_progress:
             on_progress(10, "Extracting audio from video...")
 
-        _tmp = tempfile.NamedTemporaryFile(suffix=".wav", prefix="opencut_cv_", delete=False)
-        temp_wav = _tmp.name
-        _tmp.close()
+        with tempfile.NamedTemporaryFile(
+            suffix=".wav",
+            prefix="opencut_cv_",
+            delete=False,
+        ) as _tmp:
+            temp_wav = _tmp.name
         _extract_audio(input_path, temp_wav)
         audio_path = temp_wav
 
@@ -361,13 +389,14 @@ def enhance_speech_clearvoice(
 
     finally:
         if temp_wav and os.path.isfile(temp_wav):
-            try:
+            with suppress(OSError):
                 os.remove(temp_wav)
-            except OSError:
-                pass
-        try:
+        # Release model and result tensors before clearing GPU cache
+        for _var in ("cv", "result"):
+            with suppress(Exception):
+                if _var in locals():
+                    del locals()[_var]
+        with suppress(Exception):
             import torch
             if torch.cuda.is_available():
                 torch.cuda.empty_cache()
-        except Exception:
-            pass

extension/com.opencut.panel/client/style.css

@@ -119,7 +119,7 @@ def denoise_audio(
         output_path,
     ]
 
-    result = subprocess.run(cmd, capture_output=True, timeout=600)
+    result = subprocess.run(cmd, capture_output=True, timeout=600, check=False)
     if result.returncode != 0:
         raise RuntimeError(f"Noise reduction failed: {result.stderr.decode(errors='replace')}")
 
@@ -183,7 +183,7 @@ def isolate_voice(
         output_path,
     ]
 
-    result = subprocess.run(cmd, capture_output=True, timeout=600)
+    result = subprocess.run(cmd, capture_output=True, timeout=600, check=False)
     if result.returncode != 0:
         raise RuntimeError(f"Voice isolation failed: {result.stderr.decode(errors='replace')}")
 
@@ -222,7 +222,10 @@ def measure_loudness(input_path: str) -> LoudnessInfo:
         "-f", "null", "-",
     ]
 
-    result = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
+    result = subprocess.run(cmd, capture_output=True, text=True, timeout=300, check=False)
+    if result.returncode != 0:
+        stderr = result.stderr.strip()[-500:] if result.stderr else "unknown error"
+        raise RuntimeError(f"Loudness analysis failed: {stderr}")
     # loudnorm prints JSON to stderr
     output = result.stderr
 
@@ -318,7 +321,7 @@ def normalize_loudness(
         output_path,
     ]
 
-    result = subprocess.run(cmd, capture_output=True, text=True, timeout=600)
+    result = subprocess.run(cmd, capture_output=True, text=True, timeout=600, check=False)
     if result.returncode != 0:
         stderr = result.stderr.strip()[-500:] if result.stderr else "unknown error"
         raise RuntimeError(f"Loudness normalization failed: {stderr}")
@@ -367,7 +370,7 @@ def detect_beats(
         "-f", "s16le", "-",
     ]
 
-    result = subprocess.run(cmd, capture_output=True, timeout=300)
+    result = subprocess.run(cmd, capture_output=True, timeout=300, check=False)
     if result.returncode != 0:
         raise RuntimeError(f"Audio extraction failed: {result.stderr.decode(errors='replace')}")
 
@@ -520,7 +523,7 @@ def generate_ducking_keyframes(
         "-f", "s16le", "-",
     ]
 
-    result = subprocess.run(cmd, capture_output=True, timeout=300)
+    result = subprocess.run(cmd, capture_output=True, timeout=300, check=False)
     if result.returncode != 0:
         raise RuntimeError(f"Audio extraction failed: {result.stderr.decode(errors='replace')}")
 
@@ -707,7 +710,7 @@ def apply_audio_effect(
         output_path,
     ]
 
-    result = subprocess.run(cmd, capture_output=True, timeout=600)
+    result = subprocess.run(cmd, capture_output=True, timeout=600, check=False)
     if result.returncode != 0:
         raise RuntimeError(f"Audio effect failed: {result.stderr.decode(errors='replace')}")
 

opencut/core/audio.py

@@ -64,6 +64,7 @@ def check_auto_editor_version():
         result = subprocess.run(
             ["auto-editor", "--version"],
             capture_output=True, text=True, timeout=10,
+            check=False,
         )
         if result.returncode == 0:
             return result.stdout.strip()
@@ -75,6 +76,7 @@ def check_auto_editor_version():
         result = subprocess.run(
             [sys.executable, "-m", "auto_editor", "--version"],
             capture_output=True, text=True, timeout=10,
+            check=False,
         )
         if result.returncode == 0:
             return result.stdout.strip()
@@ -374,11 +376,12 @@ def _run_auto_edit(input_path, method, threshold, margin, min_clip_length,
     try:
         result = subprocess.run(
             cmd, capture_output=True, text=True, timeout=timeout,
+            check=False,
         )
-    except subprocess.TimeoutExpired:
+    except subprocess.TimeoutExpired as err:
         raise RuntimeError(
             f"auto-editor timed out after {timeout}s processing '{os.path.basename(input_path)}'"
-        )
+        ) from err
 
     if result.returncode != 0:
         stderr = result.stderr.strip()[-500:] if result.stderr else "unknown error"

opencut/core/audio_enhance.py

@@ -8,6 +8,7 @@
 
 import logging
 import os
+import threading
 from typing import List, Optional
 
 logger = logging.getLogger("opencut")
@@ -70,39 +71,45 @@ def _ease(t: float, mode: str) -> float:
 # ---------------------------------------------------------------------------
 
 _CASCADE: Optional[object] = None
+_CASCADE_LOCK = threading.Lock()
 
 
 def _get_cascade():
-    """Load the frontal-face Haar cascade (cached after first load)."""
+    """Load the frontal-face Haar cascade (cached after first load). Thread-safe."""
     global _CASCADE
     if _CASCADE is not None:
         return _CASCADE
 
-    # Try the built-in OpenCV data path first
-    cascade_name = "haarcascade_frontalface_default.xml"
-    builtin_path = cv2.data.haarcascades + cascade_name  # type: ignore[union-attr]
-    if os.path.exists(builtin_path):
-        _CASCADE = cv2.CascadeClassifier(builtin_path)
-        return _CASCADE
+    with _CASCADE_LOCK:
+        # Double-check after acquiring lock
+        if _CASCADE is not None:
+            return _CASCADE
 
-    # Fallback: search common locations
-    candidates = [
-        os.path.join(os.path.dirname(__file__), cascade_name),
-        os.path.join(os.path.expanduser("~"), ".opencut", cascade_name),
-    ]
-    for path in candidates:
-        if os.path.exists(path):
-            _CASCADE = cv2.CascadeClassifier(path)
+        # Try the built-in OpenCV data path first
+        cascade_name = "haarcascade_frontalface_default.xml"
+        builtin_path = cv2.data.haarcascades + cascade_name  # type: ignore[union-attr]
+        if os.path.exists(builtin_path):
+            _CASCADE = cv2.CascadeClassifier(builtin_path)
             return _CASCADE
 
-    # Return empty classifier — detection will always return no faces,
-    # and we fall back to centre-crop anchors.
-    logger.warning(
-        "Haar cascade not found at %s; face detection disabled, using centre crop.",
-        builtin_path,
-    )
-    _CASCADE = cv2.CascadeClassifier()
-    return _CASCADE
+        # Fallback: search common locations
+        candidates = [
+            os.path.join(os.path.dirname(__file__), cascade_name),
+            os.path.join(os.path.expanduser("~"), ".opencut", cascade_name),
+        ]
+        for path in candidates:
+            if os.path.exists(path):
+                _CASCADE = cv2.CascadeClassifier(path)
+                return _CASCADE
+
+        # Return empty classifier — detection will always return no faces,
+        # and we fall back to centre-crop anchors.
+        logger.warning(
+            "Haar cascade not found at %s; face detection disabled, using centre crop.",
+            builtin_path,
+        )
+        _CASCADE = cv2.CascadeClassifier()
+        return _CASCADE
 
 
 # ---------------------------------------------------------------------------