Update app.py

app.py

@@ -9,7 +9,7 @@
 
 import os
 from pathlib import Path
-from typing import Optional, Tuple, Dict, Any, Callable
+from typing import Optional, Dict, Any, Callable
 
 # 1️⃣ Set CSP-safe environment variables BEFORE any imports (Gradio will see these)
 os.environ['GRADIO_ALLOW_FLAGGING'] = 'never'
@@ -50,8 +50,7 @@ def patched_get_type(schema):
 from processing.video.video_processor import CoreVideoProcessor, ProcessorConfig
 from processing.audio.audio_processor import AudioProcessor
 
-# NOTE: You previously imported from utils.cv_processing; adjust if needed.
-# Here we import from your unified utils (the file you showed me earlier).
+# NOTE: We import background presets (for the UI) and validator from utils
 from utils import PROFESSIONAL_BACKGROUNDS, validate_video_file
 
 # 5️⃣ CSP-safe fallback model stubs
@@ -67,7 +66,7 @@ def predict(self, point_coords=None, point_labels=None, box=None, multimask_outp
 class CSPSafeMatAnyone:
     def step(self, image_tensor, mask_tensor=None, objects=None, first_frame_pred=False, **kwargs):
         import torch
-        # image_tensor is CHW or NCHW (guard in ModelLoader handles it)
+        # image_tensor can be CHW or NCHW; our model guard normalizes it upstream
         if hasattr(image_tensor, "shape"):
             if len(image_tensor.shape) == 3:
                 _, H, W = image_tensor.shape
@@ -92,7 +91,7 @@ def __init__(self):
         self.model_loader = ModelLoader(self.device_mgr, self.memory_mgr)
         self.audio_proc = AudioProcessor()
         self.models_loaded = False
-        self.core_processor = None
+        self.core_processor: Optional[CoreVideoProcessor] = None
         logger.info("VideoBackgroundApp initialized (device=%s)", self.device_mgr.get_optimal_device())
 
     def load_models(self, progress_callback: Optional[Callable]=None) -> str:
@@ -106,8 +105,21 @@ def load_models(self, progress_callback: Optional[Callable]=None) -> str:
         sam2_model = getattr(sam2, "model", sam2) if sam2 else CSPSafeSAM2()
         matanyone_model = getattr(matanyone, "model", matanyone) if matanyone else CSPSafeMatAnyone()
 
-        # CoreVideoProcessor expects a models manager; provide minimal adapter
-        self.core_processor = CoreVideoProcessor(config=ProcessorConfig(), models=None)
+        # ⬇️ NEW: fast-but-safe defaults (NVENC + model-only downscale)
+        cfg = ProcessorConfig(
+            background_preset="office",   # valid preset key
+            write_fps=None,               # keep source FPS
+            max_model_size=1280,          # model-only downscale; output remains full-res
+            use_nvenc=True,               # try GPU encoder if available
+            nvenc_codec="h264",           # browser-safe preview
+            nvenc_preset="p5",            # HQ preset
+            nvenc_cq=18,                  # lower = higher quality
+            nvenc_tune_hq=True,           # high-quality tuning
+            nvenc_pix_fmt="yuv420p",      # web-compatible pixel format
+        )
+        self.core_processor = CoreVideoProcessor(config=cfg, models=None)
+
+        # Minimal adapter the processor expects
         self.core_processor.models = type('FakeModelManager', (), {
             'get_sam2': lambda self_: sam2_model,
             'get_matanyone': lambda self_: matanyone_model
@@ -123,20 +135,21 @@ def process_video(self, video, bg_style, custom_bg_file):
             return None, "Models not loaded yet"
 
         logger.info("process_video called (video=%s, bg_style=%s, custom_bg=%s)",
-                    video, bg_style, getattr(custom_bg_file, "name", None))
+                    video, bg_style, getattr(custom_bg_file, "name", None) if custom_bg_file else None)
 
         import time
         output_path = f"/tmp/output_{int(time.time())}.mp4"
 
-        # Background config
+        # Background config passed to the processor:
+        # - custom image via {"custom_path": "..."}
+        # - preset via {"background_choice": "<key>"}
         if custom_bg_file:
-            cfg = {"custom_path": custom_bg_file.name}
+            bg_cfg = {"custom_path": custom_bg_file.name}
         else:
-            # Safe default: ensure value exists in dict
-            style = bg_style if bg_style in PROFESSIONAL_BACKGROUNDS else "office"
-            cfg = PROFESSIONAL_BACKGROUNDS.get(style, PROFESSIONAL_BACKGROUNDS["office"])
+            style = bg_style if (bg_style in PROFESSIONAL_BACKGROUNDS) else "office"
+            bg_cfg = {"background_choice": style}
 
-        # Validate input video (your `validate_video_file` returns bool)
+        # Validate input video (utils.validate_video_file returns bool)
         ok = validate_video_file(video)
         if not ok:
             logger.warning("Invalid/unreadable video: %s", video)
@@ -146,7 +159,7 @@ def process_video(self, video, bg_style, custom_bg_file):
             result = self.core_processor.process_video(
                 input_path=video,
                 output_path=output_path,
-                bg_config=cfg
+                bg_config=bg_cfg
             )
             logger.info("Core processing done → %s", output_path)
 
@@ -180,9 +193,10 @@ def create_csp_safe_gradio():
                 video = gr.Video(label="Upload Video")
                 # Ensure default choice exists in PROFESSIONAL_BACKGROUNDS (use 'office')
                 choices = list(PROFESSIONAL_BACKGROUNDS.keys())
+                default_choice = "office" if "office" in choices else (choices[0] if choices else "office")
                 bg_style = gr.Dropdown(
                     choices=choices,
-                    value="office",
+                    value=default_choice,
                     label="Background Style"
                 )
                 custom_bg = gr.File(label="Custom Background (Optional)", file_types=["image"])