Update pipeline/video_pipeline.py

pipeline/video_pipeline.py

@@ -174,27 +174,38 @@ def smooth_alpha_video(alpha_path, output_path, window_size=5):
 def create_transparent_mov(foreground_path, alpha_path, output_dir):
     """Create transparent MOV using FFmpeg (reliable alpha handling)"""
     output_path = str(output_dir / "transparent.mov")
+    logger.info(f"[create_transparent_mov] Foreground: {foreground_path}, Alpha: {alpha_path}, Output: {output_path}")
     try:
         cmd = [
-            "ffmpeg", "-y", "-hide_banner", "-loglevel", "error",
+            "ffmpeg", "-y", "-hide_banner", "-loglevel", "info",
             "-i", foreground_path,
             "-i", alpha_path,
             "-filter_complex", "[0:v][1:v]alphamerge[out]",
             "-map", "[out]",
-            "-c:v", "png", # Lossless codec for alpha
+            "-c:v", "png",
             "-pix_fmt", "rgba",
             output_path
         ]
-        subprocess.run(cmd, check=True, capture_output=True)
+        logger.info(f"[create_transparent_mov] Running FFmpeg command: {' '.join(cmd)}")
+        result = subprocess.run(cmd, check=True, capture_output=True, text=True)
+        logger.info(f"[create_transparent_mov] FFmpeg stdout: {result.stdout}")
+        logger.info(f"[create_transparent_mov] FFmpeg stderr: {result.stderr}")
         # Verify alpha channel
         cap = cv2.VideoCapture(output_path)
         ret, frame = cap.read()
         if ret:
-            logger.info(f"FFmpeg MOV: Shape={frame.shape} | Alpha={np.unique(frame[:, :, 3])}")
+            logger.info(f"[create_transparent_mov] FFmpeg MOV: Shape={frame.shape} | Alpha={np.unique(frame[:, :, 3])}")
+        else:
+            logger.error("[create_transparent_mov] Failed to read output video")
         cap.release()
+        if not os.path.exists(output_path):
+            logger.error("[create_transparent_mov] Output file not created")
+            return None
         return output_path
     except Exception as e:
-        logger.error(f"FFmpeg MOV creation failed: {e}")
+        logger.error(f"[create_transparent_mov] FFmpeg MOV creation failed: {e}")
+        logger.error(f"[create_transparent_mov] FFmpeg stdout: {result.stdout if 'result' in locals() else 'N/A'}")
+        logger.error(f"[create_transparent_mov] FFmpeg stderr: {result.stderr if 'result' in locals() else 'N/A'}")
         return None
 # --- Stage 1: Transparent Video Creation ---
 def stage1_create_transparent_video(input_file):
@@ -212,13 +223,16 @@ def stage1_create_transparent_video(input_file):
         with tempfile.TemporaryDirectory() as temp_dir:
             temp_dir = Path(temp_dir)
             input_path = _normalize_input(input_file, temp_dir)
+            logger.info(f"[stage1] Input video: {input_path}")
             # Extract audio from input video
             audio_path = str(temp_dir / "audio.aac")
-            extract_audio(input_path, audio_path)
+            if not extract_audio(input_path, audio_path):
+                logger.warning("[stage1] Audio extraction failed, continuing without audio")
             # Generate first-frame mask
             mask = generate_first_frame_mask(input_path, sam2_predictor)
             mask_path = str(temp_dir / "mask.png")
             cv2.imwrite(mask_path, mask)
+            logger.info(f"[stage1] First-frame mask saved: {mask_path}")
             # MatAnyone processing
             foreground_path, alpha_path = matanyone_processor.process_video(
                 input_path=input_path,
@@ -226,8 +240,12 @@ def stage1_create_transparent_video(input_file):
                 output_path=str(temp_dir),
                 max_size=720
             )
+            logger.info(f"[stage1] MatAnyone output: foreground={foreground_path}, alpha={alpha_path}")
+            if not foreground_path or not alpha_path or not os.path.exists(foreground_path) or not os.path.exists(alpha_path):
+                raise RuntimeError("MatAnyone failed to produce valid foreground or alpha paths")
             # Temporal smoothing
             smoothed_alpha = smooth_alpha_video(alpha_path, str(temp_dir / "alpha_smoothed.mp4"))
+            logger.info(f"[stage1] Smoothed alpha: {smoothed_alpha}")
             # Create transparent MOV
             transparent_path = create_transparent_mov(foreground_path, smoothed_alpha, temp_dir)
             if not transparent_path:
@@ -235,10 +253,11 @@ def stage1_create_transparent_video(input_file):
             # Save to persistent storage
             persist_path = Path("tmp") / "transparent_video.mov"
             shutil.copyfile(transparent_path, persist_path)
+            logger.info(f"[stage1] Transparent video saved: {persist_path}")
             # Return both transparent video and audio paths for Stage 2
             return str(persist_path), audio_path
     except Exception as e:
-        logger.error(f"Stage 1 failed: {e}", exc_info=True)
+        logger.error(f"[stage1] Stage 1 failed: {e}", exc_info=True)
         st.error(f"Stage 1 Error: {str(e)}")
         return None, None
     finally: