fix

models/__init__.py

@@ -592,33 +592,74 @@ def matany_worker():
             try:
                 logger.info("MatAnyone worker thread started")
                 
-                # Mock frame-by-frame progress for now (MatAnyone doesn't expose frame progress)
-                def mock_progress():
-                    import time
-                    for frame in range(1, total_frames + 1):
-                        if progress_callback:
-                            progress_msg = f" MatAnyone processing frame {frame}/{total_frames} ({frame/total_frames*100:.1f}%)"
-                            try:
-                                progress_callback(progress_msg)
-                            except:
-                                logger.info(progress_msg)
-                        progress_container[0] = frame
-                        time.sleep(0.1)  # Simulate processing time
+                # Read video frames and mask
+                import cv2
+                import numpy as np
+                cap = cv2.VideoCapture(str(video_path))
+                mask_img = cv2.imread(str(mask_path), cv2.IMREAD_GRAYSCALE)
                 
-                # Start progress tracking in background
-                import threading
-                progress_thread = threading.Thread(target=mock_progress)
-                progress_thread.daemon = True
-                progress_thread.start()
+                if mask_img is None:
+                    raise ValueError(f"Could not read mask image: {mask_path}")
                 
-                result = session.process_video(
-                    video_path=str(video_path),
-                    trimap_path=str(mask_path),
-                    fg_path=str(fg_path),
-                    alpha_path=str(alpha_path)
-                )
-                result_container[0] = result
-                logger.info("MatAnyone worker thread completed successfully")
+                # Get video properties
+                fps = cap.get(cv2.CAP_PROP_FPS)
+                width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+                height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+                
+                # Resize mask to match video dimensions
+                mask_resized = cv2.resize(mask_img, (width, height))
+                seed_mask_hw = mask_resized.astype('float32') / 255.0
+                
+                # Prepare output video writers
+                fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+                fg_writer = cv2.VideoWriter(str(fg_path), fourcc, fps, (width, height))
+                alpha_writer = cv2.VideoWriter(str(alpha_path), fourcc, fps, (width, height))
+                
+                # Process frames using MatAnyone frame-by-frame API
+                frame_count = 0
+                frames = []
+                
+                # Read all frames first
+                while True:
+                    ret, frame = cap.read()
+                    if not ret:
+                        break
+                    frames.append(frame)
+                
+                cap.release()
+                
+                # Process frames through MatAnyone
+                for i, alpha_result in enumerate(session.process_video(frames, seed_mask_hw, every=10)):
+                    frame_count += 1
+                    
+                    # Update progress
+                    if progress_callback:
+                        progress_msg = f"MatAnyone processing frame {frame_count}/{total_frames} ({frame_count/total_frames*100:.1f}%)"
+                        try:
+                            progress_callback(progress_msg)
+                        except:
+                            logger.info(progress_msg)
+                    
+                    # Get current frame
+                    current_frame = frames[i]
+                    
+                    # Convert alpha to 3-channel for video writing
+                    alpha_3ch = cv2.cvtColor((alpha_result * 255).astype('uint8'), cv2.COLOR_GRAY2BGR)
+                    
+                    # Create foreground by applying alpha mask
+                    alpha_norm = alpha_result[:, :, np.newaxis]
+                    fg_frame = (current_frame.astype('float32') * alpha_norm).astype('uint8')
+                    
+                    # Write frames
+                    fg_writer.write(fg_frame)
+                    alpha_writer.write(alpha_3ch)
+                
+                # Clean up
+                fg_writer.release()
+                alpha_writer.release()
+                
+                result_container[0] = True
+                logger.info(f"MatAnyone worker thread completed successfully - processed {frame_count} frames")
             except Exception as e:
                 logger.error(f"MatAnyone worker thread failed: {e}")
                 exception_container[0] = e