Update processing/video/video_processor.py

processing/video/video_processor.py

@@ -1,9 +1,101 @@
-# ... (all your imports and CoreVideoProcessor class header/attributes as above)
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Core Video Processor for BackgroundFX Pro
+
+- Minimal, safe implementation used by core/app.py
+- Works with split/legacy loaders
+- Keeps exact behavior you shared; only fixes typing imports + integrates
+  prepare_background() and related helpers.
+
+NOTE:
+- Requires utils.cv_processing helpers already present in your project:
+  segment_person_hq, refine_mask_hq, replace_background_hq,
+  create_professional_background, PROFESSIONAL_BACKGROUNDS,
+  _create_gradient_background_local, validate_video_file
+"""
+
+from __future__ import annotations
+
+import os
+import time
+import shutil
+import logging
+import threading
+from typing import Optional, Any, Dict, Callable, Tuple, List
+
+import numpy as np
+import cv2
+
+# ---------------------------------------------------------------------
+# Project logger (non-fatal fallback to std logging)
+# ---------------------------------------------------------------------
+try:
+    from utils.logger import get_logger
+    _log = get_logger("processing.video.video_processor")
+except Exception:
+    logging.basicConfig(level=logging.INFO)
+    _log = logging.getLogger("processing.video.video_processor")
+
+# ---------------------------------------------------------------------
+# Config type (import if available; otherwise annotations are postponed)
+# ---------------------------------------------------------------------
+try:
+    from config.processor_config import ProcessorConfig  # your project config
+except Exception:  # keep runtime happy if only used for typing
+    ProcessorConfig = Any  # type: ignore
+
+# ---------------------------------------------------------------------
+# Small env helpers (use project ones if you have them)
+# ---------------------------------------------------------------------
+try:
+    from utils.system.env_utils import env_bool as _env_bool  # type: ignore
+    from utils.system.env_utils import env_int as _env_int    # type: ignore
+except Exception:
+    def _env_bool(name: str, default: bool = False) -> bool:
+        v = os.environ.get(name)
+        if v is None:
+            return bool(default)
+        return str(v).strip().lower() in ("1", "true", "yes", "y", "on")
+
+    def _env_int(name: str, default: int = 0) -> int:
+        try:
+            return int(os.environ.get(name, default))
+        except Exception:
+            return int(default)
+
+# ---------------------------------------------------------------------
+# CV helpers from your utils module
+# ---------------------------------------------------------------------
+from utils.cv_processing import (
+    segment_person_hq,
+    refine_mask_hq,
+    replace_background_hq,
+    create_professional_background,
+    PROFESSIONAL_BACKGROUNDS,
+    validate_video_file,
+)
+
+# Optional local gradient helper (present in some layouts)
+try:
+    from utils.cv_processing import _create_gradient_background_local  # type: ignore
+except Exception:
+    _create_gradient_background_local = None  # type: ignore
+
+# ---------------------------------------------------------------------
+# Optional FFmpeg pipe; code falls back to OpenCV if unavailable
+# ---------------------------------------------------------------------
+try:
+    from utils.video.ffmpeg_pipe import FFmpegPipe as _FFmpegPipe  # type: ignore
+except Exception:
+    _FFmpegPipe = None  # type: ignore
+
 
 class CoreVideoProcessor:
     """
     Minimal, safe implementation used by core/app.py.
-    ...
+    Orchestrates SAM2 → MatAnyone refinement → background compositing,
+    with robust fallbacks (OpenCV writer when FFmpeg/NVENC unavailable).
     """
 
     def __init__(self, config: Optional[ProcessorConfig] = None, models: Optional[Any] = None):
@@ -13,7 +105,6 @@ def __init__(self, config: Optional[ProcessorConfig] = None, models: Optional[An
         if self.models is None:
             self.log.warning("CoreVideoProcessor initialized without a models provider; will use fallbacks.")
         self._ffmpeg = shutil.which("ffmpeg")
-        # (rest as before...)
 
         # -------- Back-compat safe config flags (do not require attrs on user config)
         self._use_windowed = _env_bool(
@@ -40,7 +131,6 @@ def prepare_background(self, background_choice: str, custom_background_path: Opt
         If a valid custom background path is given, loads and resizes it. Otherwise, uses a preset.
         Returns: np.ndarray RGB (H, W, 3) uint8
         """
-        import cv2
         from utils.cv_processing import create_professional_background
 
         if custom_background_path:
@@ -58,8 +148,6 @@ def prepare_background(self, background_choice: str, custom_background_path: Opt
         # fallback to preset
         return create_professional_background(background_choice, width, height)
 
-    # (rest of class unchanged...)
-
     # ---------- mask post-processing (stability + crispness) ----------
     def _iou(self, a: np.ndarray, b: np.ndarray, thr: float = 0.5) -> float:
         a_bin = (a >= thr).astype(np.uint8)
@@ -189,7 +277,7 @@ def _prepare_background_from_config(
                 img_bgr = cv2.resize(img_bgr, (width, height), interpolation=cv2.INTER_LANCZOS4)
                 return cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
 
-        if bg_config and isinstance(bg_config.get("gradient"), dict):
+        if bg_config and isinstance(bg_config.get("gradient"), dict) and _create_gradient_background_local:
             try:
                 return _create_gradient_background_local(bg_config["gradient"], width, height)
             except Exception as e:
@@ -295,13 +383,13 @@ def process_video(
 
         self._prev_mask = None
 
-        ffmpeg_pipe: _FFmpegPipe | None = None
+        ffmpeg_pipe: _FFmpegPipe | None = None  # type: ignore
         writer: cv2.VideoWriter | None = None
         ffmpeg_failed_reason = None
 
-        if getattr(self.config, "use_nvenc", True) and shutil.which("ffmpeg"):
+        if getattr(self.config, "use_nvenc", True) and shutil.which("ffmpeg") and _FFmpegPipe is not None:
             try:
-                ffmpeg_pipe = _FFmpegPipe(width, height, float(fps_out), output_path, self.config, log=self.log)
+                ffmpeg_pipe = _FFmpegPipe(width, height, float(fps_out), output_path, self.config, log=self.log)  # type: ignore
             except Exception as e:
                 ffmpeg_failed_reason = str(e)
                 self.log.warning("FFmpeg NVENC pipeline unavailable. Falling back to OpenCV. Reason: %s", e)
@@ -347,11 +435,11 @@ def process_video(
 
                     if ffmpeg_pipe is not None:
                         try:
-                            ffmpeg_pipe.write(out_bgr)
+                            ffmpeg_pipe.write(out_bgr)  # type: ignore[attr-defined]
                         except Exception as e:
                             self.log.warning("Switching to OpenCV writer after FFmpeg error at frame %d: %s", frame_count, e)
                             try:
-                                ffmpeg_pipe.close()
+                                ffmpeg_pipe.close()  # type: ignore[attr-defined]
                             except Exception:
                                 pass
                             ffmpeg_pipe = None
@@ -443,11 +531,11 @@ def process_video(
 
                             if ffmpeg_pipe is not None:
                                 try:
-                                    ffmpeg_pipe.write(out_bgr)
+                                    ffmpeg_pipe.write(out_bgr)  # type: ignore[attr-defined]
                                 except Exception as e:
                                     self.log.warning("Switching to OpenCV writer after FFmpeg error at frame %d: %s", frame_count, e)
                                     try:
-                                        ffmpeg_pipe.close()
+                                        ffmpeg_pipe.close()  # type: ignore[attr-defined]
                                     except Exception:
                                         pass
                                     ffmpeg_pipe = None
@@ -481,10 +569,10 @@ def process_video(
 
                             if ffmpeg_pipe is not None:
                                 try:
-                                    ffmpeg_pipe.write(np.ascontiguousarray(out_bgr_fb))
+                                    ffmpeg_pipe.write(np.ascontiguousarray(out_bgr_fb))  # type: ignore[attr-defined]
                                 except Exception:
                                     try:
-                                        ffmpeg_pipe.close()
+                                        ffmpeg_pipe.close()  # type: ignore[attr-defined]
                                     except Exception:
                                         pass
                                     ffmpeg_pipe = None
@@ -520,7 +608,7 @@ def process_video(
                 writer.release()
             if ffmpeg_pipe is not None:
                 try:
-                    ffmpeg_pipe.close()
+                    ffmpeg_pipe.close()  # type: ignore[attr-defined]
                 except Exception:
                     pass
 
@@ -535,4 +623,3 @@ def process_video(
             "fps_out": float(fps_out),
             "output_path": output_path,
         }
-