Update processing/two_stage/two_stage_processor.py

processing/two_stage/two_stage_processor.py

@@ -1,28 +1,13 @@
 #!/usr/bin/env python3
 """
-ENHANCED Two-Stage Alpha Channel Processing System ✅
-(Full file, ready to drop in)
-Date: 2025-09-09
-
-VIDEO-TO-VIDEO PIPELINE with proper audio support via AudioProcessor
-
-Key fixes in this build:
-- Uses AudioProcessor for ffmpeg-based audio extraction & muxing
-- Ensures full video duration processing (no 5-second truncation unless you pass trim_seconds explicitly)
-- Direct alpha compositing (no green screen intermediate), supports image or video backgrounds
-- Chunked processing for long videos, with seamless reassembly (video first, audio added after)
-- Robust MatAnyone integration (supports both known signature and positional fallback)
-- Defensive handling for SAM2 mask creation; combines first N frames for a stable trimap
-- Careful memory cleanup between stages (GPU/system) to avoid leaks in long runs
-- Extra logging and debug artifacts to help diagnose issues quickly
+FIXED Two-Stage Alpha Channel Processing System
+Key fixes:
+- Removed all hardcoded duration limits
+- Fixed MatAnyone parameter handling
+- Proper audio preservation throughout pipeline
+- Simplified and more reliable processing flow
 """
 
-# ==============================================================================
-# IMPORTS
-# ==============================================================================
-
-from __future__ import annotations
-
 import os
 import sys
 import cv2
@@ -30,470 +15,47 @@
 import tempfile
 import shutil
 import logging
-import gc
 import time
 import traceback
 from pathlib import Path
 from typing import Optional, Tuple, Dict, Any, List
 
-# MoviePy (only used for probing durations, optional trimming, concat *video only*, and fallback audio mux)
-from moviepy.editor import (
-    VideoFileClip, AudioFileClip, concatenate_videoclips
-)
-import moviepy.video.fx.all as vfx  # noqa: F401 (kept for future effects)
+from moviepy.editor import VideoFileClip, AudioFileClip, concatenate_videoclips
 
-# Import the AudioProcessor for proper audio handling
-# Search both "processing.audio" and local "audio"
+# Try to import AudioProcessor
 try:
     from processing.audio import AudioProcessor
 except Exception:
     try:
-        from audio import AudioProcessor  # Fallback if in different location
+        from audio import AudioProcessor
     except Exception:
         AudioProcessor = None
 
-# Setup logging (do not override global logging level outside this module)
 logger = logging.getLogger(__name__)
-if not logger.handlers:
-    logging.basicConfig(
-        level=logging.INFO,
-        format='%(asctime)s - %(levelname)s - %(message)s',
-        datefmt='%Y-%m-%d %H:%M:%S'
-    )
-
-# PyTorch memory management (optional, if available on the host)
-try:
-    import torch
-    TORCH_AVAILABLE = True
-except Exception:
-    TORCH_AVAILABLE = False
-    logger.warning("PyTorch not available, GPU memory management disabled")
-
-# ==============================================================================
-# CONFIGURATION
-# ==============================================================================
-
-class ProcessingConfig:
-    """Configuration settings for two-stage processing with audio support."""
-    
-    # Reference mask creation
-    REFERENCE_FRAMES = 3  # Number of frames to use for reference mask
-    
-    # Chunked processing settings
-    MAX_CHUNK_DURATION = 300  # seconds (5 minutes). Videos longer than this will be chunked.
-    CHUNK_OVERLAP_FRAMES = 5
-    MAX_PROCESSING_RESOLUTION = None  # e.g., 1920 for downscaling if needed
-    
-    # Quality settings (for writes we control)
-    VIDEO_CODEC = 'libx264'
-    VIDEO_BITRATE = '8000k'
-    AUDIO_CODEC = 'aac'
-    AUDIO_BITRATE = '192k'
-    
-    # Alpha refinement
-    ALPHA_SMOOTHING = 3
-    ALPHA_EDGE_BLUR = 1
-    ALPHA_CONTRAST = 1.2
-    ENABLE_DEFRINGING = True
-    DEFRINGE_RADIUS = 1
-    
-    # Processing limits
-    MAX_FRAMES_FOR_REFERENCE = 10
-    MIN_FINAL_CHUNK_DURATION = 10
-    
-    # Memory management
-    CLEAR_CACHE_AFTER_STAGE = True
-    FORCE_GARBAGE_COLLECTION = True
-    MEMORY_USAGE_THRESHOLD = 70
-    MEMORY_CHECK_INTERVAL = 30  # every N frames during compositing
-    
-    # Debug settings
-    SAVE_DEBUG_FILES = True
-    DEBUG_FRAME_INTERVAL = 30
-    
-    # Audio settings
-    PRESERVE_ORIGINAL_AUDIO = True
-    AUDIO_QUALITY = 'high'
-    USE_FFMPEG_FOR_AUDIO = True  # Prefer ffmpeg over MoviePy
-
-
-# ==============================================================================
-# MEMORY MANAGER
-# ==============================================================================
-
-class MemoryManager:
-    """Utilities for managing GPU and system memory."""
-    
-    def __init__(self, config: ProcessingConfig):
-        self.config = config
-        self.initial_memory = self.get_current_memory()
-        self.peak_memory = self.initial_memory
-        self.stage_memories: Dict[str, Dict[str, float]] = {}
-    
-    @staticmethod
-    def clear_gpu_cache() -> float:
-        if TORCH_AVAILABLE and torch.cuda.is_available():
-            before = torch.cuda.memory_allocated()
-            torch.cuda.empty_cache()
-            try:
-                torch.cuda.synchronize()
-            except Exception:
-                pass
-            after = torch.cuda.memory_allocated()
-            freed = (before - after) / 1024**3
-            logger.info(f"GPU cache cleared: {freed:.2f}GB freed")
-            return freed
-        return 0.0
-    
-    @staticmethod
-    def force_garbage_collection() -> Tuple[int, float]:
-        before = 0
-        if TORCH_AVAILABLE and torch.cuda.is_available():
-            try:
-                before = torch.cuda.memory_allocated()
-            except Exception:
-                before = 0
-        
-        collected = gc.collect()
-        
-        after = 0
-        if TORCH_AVAILABLE and torch.cuda.is_available():
-            try:
-                after = torch.cuda.memory_allocated()
-            except Exception:
-                after = 0
-        
-        freed = (before - after) / 1024**3 if before > 0 else 0.0
-        logger.info(f"Garbage collection: {collected} objects freed, {freed:.2f}GB GPU memory recovered")
-        return collected, freed
-    
-    def get_current_memory(self) -> Dict[str, float]:
-        memory = {
-            'gpu_allocated': 0.0,
-            'gpu_reserved': 0.0,
-            'gpu_free': 0.0,
-            'gpu_total': 0.0,
-            'gpu_usage_percent': 0.0
-        }
-        
-        if TORCH_AVAILABLE and torch.cuda.is_available():
-            try:
-                memory['gpu_allocated'] = torch.cuda.memory_allocated() / 1024**3
-                memory['gpu_reserved'] = torch.cuda.memory_reserved() / 1024**3
-                props = torch.cuda.get_device_properties(0)
-                memory['gpu_total'] = props.total_memory / 1024**3
-                memory['gpu_free'] = memory['gpu_total'] - memory['gpu_allocated']
-                memory['gpu_usage_percent'] = (memory['gpu_allocated'] / memory['gpu_total']) * 100 if memory['gpu_total'] > 0 else 0
-            except Exception:
-                pass
-        return memory
-    
-    def get_gpu_memory_info(self) -> str:
-        memory = self.get_current_memory()
-        if memory['gpu_total'] > 0:
-            return (f"GPU Memory: {memory['gpu_allocated']:.1f}GB allocated, "
-                   f"{memory['gpu_free']:.1f}GB free, "
-                   f"{memory['gpu_usage_percent']:.0f}% usage")
-        return "GPU memory info unavailable"
-    
-    def should_clear_memory(self) -> bool:
-        memory = self.get_current_memory()
-        return memory['gpu_usage_percent'] > self.config.MEMORY_USAGE_THRESHOLD
-    
-    def cleanup_stage(self, stage_name: str, force: bool = False):
-        logger.info(f"Cleaning up after {stage_name}…")
-        
-        before = self.get_current_memory()
-        
-        gpu_freed = 0.0
-        gc_objects = 0
-        gc_memory = 0.0
-        
-        if force or self.should_clear_memory():
-            gpu_freed = self.clear_gpu_cache()
-            gc_objects, gc_memory = self.force_garbage_collection()
-        
-        after = self.get_current_memory()
-        
-        self.stage_memories[stage_name] = {
-            'before_alloc': before['gpu_allocated'],
-            'after_alloc': after['gpu_allocated'],
-            'freed_total': gpu_freed + gc_memory
-        }
-        
-        if after['gpu_allocated'] > self.peak_memory.get('gpu_allocated', 0):
-            self.peak_memory = after
-        
-        logger.info(f"Memory cleanup completed for {stage_name}: {gpu_freed + gc_memory:.2f}GB total freed")
-    
-    def cleanup_model(self, model_handler: Any, handler_name: str, deep_cleanup: bool = False):
-        try:
-            if hasattr(model_handler, 'cleanup'):
-                model_handler.cleanup()
-                logger.info(f"{handler_name}: cleanup() called")
-            
-            if hasattr(model_handler, 'release'):
-                model_handler.release()
-                logger.info(f"{handler_name}: release() called")
-            
-            if deep_cleanup:
-                if hasattr(model_handler, 'model'):
-                    try:
-                        delattr(model_handler, 'model')
-                        logger.info(f"{handler_name}: model deleted")
-                    except Exception:
-                        pass
-                if hasattr(model_handler, 'predictor'):
-                    try:
-                        delattr(model_handler, 'predictor')
-                        logger.info(f"{handler_name}: predictor deleted")
-                    except Exception:
-                        pass
-        except Exception as e:
-            logger.warning(f"Failed to cleanup {handler_name}: {e}")
-    
-    def get_memory_report(self) -> str:
-        report = ["="*60, "MEMORY USAGE REPORT", "="*60]
-        current = self.get_current_memory()
-        report.append(f"Current GPU Memory: {current['gpu_allocated']:.2f}GB / {current['gpu_total']:.2f}GB ({current['gpu_usage_percent']:.0f}%)")
-        peak = self.peak_memory.get('gpu_allocated', 0.0)
-        report.append(f"Peak GPU Memory: {peak:.2f}GB")
-        if self.stage_memories:
-            report.append("\nStage Memory Usage:")
-            for stage, mem in self.stage_memories.items():
-                report.append(f"  {stage}: before={mem['before_alloc']:.2f}GB after={mem['after_alloc']:.2f}GB freed={mem['freed_total']:.2f}GB")
-        report.append("="*60)
-        return "\n".join(report)
-
-
-# ==============================================================================
-# QUALITY MANAGER
-# ==============================================================================
-
-class QualityManager:
-    """Manages processing quality profiles."""
-    
-    PROFILES = {
-        'high': {
-            'max_size': None,
-            'bitrate': '8000k',
-            'preset': 'medium',
-            'crf': 18
-        },
-        'medium': {
-            'max_size': None,
-            'bitrate': '4000k',
-            'preset': 'fast',
-            'crf': 23
-        },
-        'fast': {
-            'max_size': 1920,
-            'bitrate': '2000k',
-            'preset': 'faster',
-            'crf': 28
-        }
-    }
-    
-    @classmethod
-    def get_profile(cls, quality: str = 'medium') -> Dict[str, Any]:
-        return cls.PROFILES.get(quality, cls.PROFILES['medium'])
-
-
-# ==============================================================================
-# ALPHA REFINEMENT
-# ==============================================================================
-
-class AlphaRefiner:
-    """Utilities for refining alpha mattes."""
-    
-    @staticmethod
-    def refine_alpha_matte(alpha: np.ndarray, config: ProcessingConfig) -> np.ndarray:
-        # Ensure single channel
-        if len(alpha.shape) == 3:
-            alpha = cv2.cvtColor(alpha, cv2.COLOR_BGR2GRAY)
-        
-        # Normalize to 0-1
-        if alpha.dtype == np.uint8:
-            alpha = alpha.astype(np.float32) / 255.0
-        
-        # Temporal smoothing
-        if config.ALPHA_SMOOTHING > 0:
-            k = config.ALPHA_SMOOTHING
-            if k % 2 == 0:
-                k += 1
-            alpha = cv2.medianBlur((alpha * 255).astype(np.uint8), k).astype(np.float32) / 255.0
-        
-        # Edge feathering
-        if config.ALPHA_EDGE_BLUR > 0:
-            ks = config.ALPHA_EDGE_BLUR * 2 + 1
-            alpha = cv2.GaussianBlur(alpha, (ks, ks), 0)
-        
-        # Contrast adjustment
-        if abs(config.ALPHA_CONTRAST - 1.0) > 1e-6:
-            alpha = np.power(alpha, config.ALPHA_CONTRAST)
-        
-        return np.clip(alpha, 0, 1)
-    
-    @staticmethod
-    def defringe_edges(composite: np.ndarray, alpha: np.ndarray, radius: int = 1) -> np.ndarray:
-        if len(alpha.shape) == 3:
-            alpha = cv2.cvtColor(alpha, cv2.COLOR_BGR2GRAY)
-        
-        if alpha.dtype == np.uint8:
-            alpha = alpha.astype(np.float32) / 255.0
-        
-        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (radius*2+1, radius*2+1))
-        dilated = cv2.dilate(alpha, kernel)
-        eroded = cv2.erode(alpha, kernel)
-        edge_mask = np.clip(dilated - eroded, 0, 1)
-        
-        blurred = cv2.GaussianBlur(composite, (3, 3), 0)
-        
-        edge_mask_3d = np.stack([edge_mask] * 3, axis=2)
-        result = composite * (1 - edge_mask_3d) + blurred * edge_mask_3d
-        
-        return np.clip(result, 0, 255).astype(np.uint8)
-
-
-# ==============================================================================
-# CHUNKED VIDEO PROCESSOR
-# ==============================================================================
-
-class ChunkedVideoProcessor:
-    """Handles splitting and reassembling videos (video-only; audio added later)."""
-    
-    def __init__(self, temp_dir: str, config: ProcessingConfig):
-        self.temp_dir = temp_dir
-        self.config = config
-        self.chunks_dir = os.path.join(temp_dir, "chunks")
-        os.makedirs(self.chunks_dir, exist_ok=True)
-    
-    def should_chunk_video(self, video_path: str) -> bool:
-        try:
-            with VideoFileClip(video_path) as clip:
-                duration = clip.duration or 0
-                should_chunk = duration > self.config.MAX_CHUNK_DURATION
-                logger.info(f"Video duration: {duration:.1f}s, chunking: {should_chunk}")
-                return should_chunk
-        except Exception as e:
-            logger.warning(f"Could not determine video duration: {e}")
-            return False
-    
-    def split_video_into_chunks(self, video_path: str) -> List[str]:
-        try:
-            with VideoFileClip(video_path) as clip:
-                duration = clip.duration or 0.0
-                chunk_paths: List[str] = []
-                
-                chunk_duration = self.config.MAX_CHUNK_DURATION
-                current_time = 0.0
-                chunk_index = 0
-                
-                while current_time < duration - 1e-6:
-                    end_time = min(current_time + chunk_duration, duration)
-                    
-                    remaining_after = duration - end_time
-                    if remaining_after > 0 and remaining_after < self.config.MIN_FINAL_CHUNK_DURATION:
-                        end_time = duration
-                        logger.info(f"Including final {remaining_after:.1f}s in chunk {chunk_index}")
-                    
-                    chunk_clip = clip.subclip(current_time, end_time)
-                    chunk_path = os.path.join(self.chunks_dir, f"chunk_{chunk_index:03d}.mp4")
-                    
-                    # Write WITHOUT audio (we'll add it back at the end)
-                    chunk_clip.write_videofile(
-                        chunk_path,
-                        codec=self.config.VIDEO_CODEC,
-                        audio=False,  # No audio in chunks
-                        verbose=False,
-                        logger=None
-                    )
-                    chunk_clip.close()
-                    
-                    chunk_paths.append(chunk_path)
-                    logger.info(f"Created chunk {chunk_index}: {current_time:.2f}s - {end_time:.2f}s")
-                    
-                    if end_time < duration:
-                        overlap_seconds = self.config.CHUNK_OVERLAP_FRAMES / (clip.fps or 30.0)
-                        current_time = max(0.0, end_time - overlap_seconds)
-                    else:
-                        current_time = duration
-                    
-                    chunk_index += 1
-                
-                logger.info(f"Split video into {len(chunk_paths)} chunks")
-                return chunk_paths
-                
-        except Exception as e:
-            logger.error(f"Video chunking failed: {e}")
-            raise
-    
-    def reassemble_chunks(self, processed_chunk_paths: List[str], output_path: str) -> str:
-        """Reassemble chunks (audio will be added separately)."""
-        try:
-            if len(processed_chunk_paths) == 1:
-                shutil.copy2(processed_chunk_paths[0], output_path)
-                logger.info("Single chunk, copied directly")
-                return output_path
-            
-            # Compose video-only
-            chunk_clips = [VideoFileClip(p) for p in processed_chunk_paths]
-            logger.info(f"Concatenating {len(chunk_clips)} chunks…")
-            final_clip = concatenate_videoclips(chunk_clips, method="compose")
-            final_clip.write_videofile(
-                output_path,
-                codec=self.config.VIDEO_CODEC,
-                audio=False,
-                verbose=False,
-                logger=None
-            )
-            final_clip.close()
-            for c in chunk_clips:
-                c.close()
-            
-            logger.info(f"Successfully reassembled video: {output_path}")
-            return output_path
-            
-        except Exception as e:
-            logger.error(f"Chunk reassembly failed: {e}")
-            raise
-
-
-# ==============================================================================
-# MAIN TWOSTAGEPROCESSOR CLASS
-# ==============================================================================
 
 class TwoStageProcessor:
     """
-    Enhanced two-stage alpha channel processor with proper audio support.
-    Uses AudioProcessor for ffmpeg-based audio handling.
+    Fixed two-stage processor that handles full video length and preserves audio.
     """
     
     def __init__(self, sam2_handler, matanyone_handler, temp_dir: Optional[str] = None):
         self.sam2_handler = sam2_handler
         self.matanyone_handler = matanyone_handler
-        self.temp_dir = temp_dir or tempfile.mkdtemp(prefix='twostage_video_')
-        self.config = ProcessingConfig()
-        self.memory_manager = MemoryManager(self.config)
-        self.chunked_processor = ChunkedVideoProcessor(self.temp_dir, self.config)
-        self.alpha_refiner = AlphaRefiner()
+        self.temp_dir = temp_dir or tempfile.mkdtemp(prefix='twostage_')
         
-        # Initialize AudioProcessor for proper audio handling
-        if AudioProcessor and self.config.USE_FFMPEG_FOR_AUDIO:
+        # Initialize AudioProcessor if available
+        if AudioProcessor:
             try:
                 self.audio_processor = AudioProcessor(temp_dir=self.temp_dir)
                 logger.info("AudioProcessor initialized for ffmpeg-based audio handling")
             except Exception as e:
                 self.audio_processor = None
-                logger.warning(f"AudioProcessor failed to initialize ({e}). Using MoviePy fallback for audio.")
+                logger.warning(f"AudioProcessor init failed: {e}. Using MoviePy fallback.")
         else:
             self.audio_processor = None
-            logger.warning("AudioProcessor not available - using MoviePy fallback for audio")
+            logger.info("AudioProcessor not available - using MoviePy for audio")
         
         os.makedirs(self.temp_dir, exist_ok=True)
-        logger.info(f"TwoStageProcessor initialized with temp dir: {self.temp_dir}")
-        logger.info(f"Audio handling: {'ffmpeg via AudioProcessor' if self.audio_processor else 'MoviePy fallback'}")
-        logger.info(self.memory_manager.get_gpu_memory_info())
     
     def process_video(self, 
                      video_path: str, 
@@ -504,643 +66,362 @@ def process_video(self,
                      callback: Optional[callable] = None,
                      **kwargs) -> Tuple[Optional[str], str]:
         """
-        Main processing pipeline with proper audio handling.
-
-        Returns:
-            (final_output_path, status_message)
+        FIXED: Main processing pipeline with proper full-length handling.
         """
         try:
-            logger.info(f"🎬 Enhanced Two-Stage Alpha Pipeline: {video_path}")
-            logger.info(f"🎯 Background: {background_path}")
-            logger.info(f"📁 Temp: {self.temp_dir}")
-            logger.info(f"🎤 Audio: {'Enabled (ffmpeg)' if self.audio_processor else 'Enabled (MoviePy)'}")
-            if trim_seconds is not None:
-                logger.info(f"✂️  Trim requested: first {trim_seconds}s will be processed")
+            logger.info(f"Processing video: {video_path}")
+            logger.info(f"Trim requested: {trim_seconds}s" if trim_seconds else "Full video processing")
+            
+            # Extract original audio FIRST (before any processing)
+            original_audio_path = self._extract_original_audio(video_path)
+            
+            # Prepare input video (trim only if explicitly requested)
+            processing_video = video_path
+            if trim_seconds and trim_seconds > 0:
+                processing_video = self._create_trimmed_video(video_path, trim_seconds)
+                logger.info(f"Created trimmed version for processing: {trim_seconds}s")
             else:
-                logger.info("⏱️  No trimming requested; full duration will be processed")
+                logger.info("Processing full video - no trimming applied")
             
-            # Extract original audio (if any)
-            original_audio_path = None
-            if self.config.PRESERVE_ORIGINAL_AUDIO:
-                original_audio_path = self._extract_audio(video_path)
-                if original_audio_path:
-                    logger.info(f"✅ Audio extracted: {original_audio_path}")
-                else:
-                    logger.info("ℹ️ No audio found in source video")
+            # Stage 1: Create reference mask from first frame(s)
+            if callback:
+                callback("Creating reference mask...", 10)
+            reference_mask = self._create_reference_mask(processing_video)
             
-            # Determine if chunking is needed
-            needs_chunking = self.chunked_processor.should_chunk_video(video_path)
+            # Stage 2: MatAnyone processing (FIXED to handle full video)
+            if callback:
+                callback("Processing with MatAnyone...", 30)
+            alpha_video = self._process_with_matanyone(processing_video, reference_mask)
             
-            if needs_chunking:
-                logger.info("Using chunked processing for long video…")
-                result = self._process_chunked_video(
-                    video_path, background_path, output_path, 
-                    quality, original_audio_path, callback
-                )
-            else:
-                logger.info("Processing full video in single pass…")
-                result = self._process_single_video(
-                    video_path, background_path, output_path, 
-                    quality, trim_seconds, original_audio_path, callback
-                )
+            # Stage 3: Composite with background
+            if callback:
+                callback("Compositing with background...", 70)
+            composite_video = self._composite_with_background(
+                processing_video, alpha_video, background_path
+            )
             
-            # Verify final output
-            if result[0] and os.path.exists(result[0]):
-                try:
-                    with VideoFileClip(result[0]) as clip:
-                        final_duration = clip.duration or 0.0
-                        has_audio = clip.audio is not None
-                        logger.info(f"✅ Final output: {final_duration:.1f}s, Audio: {has_audio}")
-                except Exception:
-                    pass
+            # Stage 4: Add original audio back
+            if callback:
+                callback("Adding audio...", 90)
+            final_output = self._add_audio_to_final(
+                composite_video, original_audio_path, output_path
+            )
             
-            logger.info(self.memory_manager.get_memory_report())
-            return result
+            if callback:
+                callback("Complete!", 100)
+            
+            # Verify output
+            if final_output and os.path.exists(final_output):
+                with VideoFileClip(final_output) as clip:
+                    duration = clip.duration or 0
+                    has_audio = clip.audio is not None
+                    logger.info(f"Final output: {duration:.1f}s, Audio: {has_audio}")
+                
+                return final_output, f"Success: {duration:.1f}s video with audio"
+            else:
+                return None, "Processing completed but output file not found"
                 
         except Exception as e:
             error_msg = f"Processing failed: {str(e)}"
-            logger.error(error_msg)
-            logger.error(f"Traceback: {traceback.format_exc()}")
+            logger.error(f"{error_msg}\n{traceback.format_exc()}")
             return None, error_msg
     
-    # ------------------------------------------------------------------
-    # Audio helpers
-    # ------------------------------------------------------------------
-    def _extract_audio(self, video_path: str) -> Optional[str]:
-        """Extract audio using AudioProcessor (ffmpeg) or MoviePy fallback."""
+    def _extract_original_audio(self, video_path: str) -> Optional[str]:
+        """Extract audio from original video before any processing."""
         try:
+            audio_output = os.path.join(self.temp_dir, "original_audio.aac")
+            
             if self.audio_processor:
-                # Use AudioProcessor with ffmpeg
-                logger.info("Extracting audio using ffmpeg…")
-                audio_path = self.audio_processor.extract_audio(
+                # Use AudioProcessor (ffmpeg) - check if it has duration limits
+                logger.info("Extracting audio with ffmpeg...")
+                result = self.audio_processor.extract_audio(
                     video_path=video_path,
-                    output_path=os.path.join(self.temp_dir, "original_audio.aac"),
+                    output_path=audio_output,
                     audio_format='aac',
-                    quality=self.config.AUDIO_QUALITY
+                    quality='high'
                 )
-                return audio_path
+                return result
             else:
                 # Fallback to MoviePy
-                logger.info("Extracting audio using MoviePy…")
-                audio_path = os.path.join(self.temp_dir, "original_audio.m4a")
+                logger.info("Extracting audio with MoviePy...")
                 with VideoFileClip(video_path) as clip:
                     if clip.audio is not None:
                         clip.audio.write_audiofile(
-                            audio_path,
-                            codec=self.config.AUDIO_CODEC,
-                            bitrate=self.config.AUDIO_BITRATE,
+                            audio_output,
+                            codec='aac',
+                            bitrate='192k',
                             verbose=False,
                             logger=None
                         )
-                        return audio_path
+                        return audio_output
                 return None
-                    
-        except Exception as e:
-            logger.warning(f"Could not extract audio: {e}")
-            return None
-    
-    def _add_audio_to_video(self, video_path: str, audio_path: Optional[str], output_path: str) -> str:
-        """Add audio to video using AudioProcessor (ffmpeg) or MoviePy fallback."""
-        try:
-            if self.audio_processor and audio_path:
-                # Using ffmpeg via AudioProcessor.
-                # Note: AudioProcessor.add_audio_to_video accepts an input for "original_video".
-                # It's OK to pass an audio-only file here; the function maps [1:a:0] as audio.
-                logger.info("Adding audio using ffmpeg (lossless where possible)…")
-                return self.audio_processor.add_audio_to_video(
-                    original_video=audio_path,       # Source of audio (audio-only or original video)
-                    processed_video=video_path,      # Video without audio
-                    output_path=output_path,
-                    audio_quality=self.config.AUDIO_QUALITY
-                )
-            elif audio_path:
-                # Fallback to MoviePy
-                logger.info("Adding audio using MoviePy…")
-                with VideoFileClip(video_path) as video:
-                    with AudioFileClip(audio_path) as audio:
-                        final = video.set_audio(audio)
-                        final.write_videofile(
-                            output_path,
-                            codec=self.config.VIDEO_CODEC,
-                            audio_codec=self.config.AUDIO_CODEC,
-                            audio_bitrate=self.config.AUDIO_BITRATE,
-                            temp_audiofile=os.path.join(self.temp_dir, "temp_audio.m4a"),
-                            remove_temp=True,
-                            verbose=False,
-                            logger=None
-                        )
-                return output_path
-            else:
-                # No audio to add; just copy
-                shutil.copy2(video_path, output_path)
-                return output_path
-                
-        except Exception as e:
-            logger.error(f"Failed to add audio: {e}")
-            # Return video without audio rather than failing completely
-            try:
-                shutil.copy2(video_path, output_path)
-            except Exception:
-                pass
-            return output_path
-    
-    # ------------------------------------------------------------------
-    # Chunked processing
-    # ------------------------------------------------------------------
-    def _process_chunked_video(self, video_path: str, background_path: str,
-                              output_path: str, quality: str,
-                              original_audio_path: Optional[str],
-                              callback: Optional[callable]) -> Tuple[Optional[str], str]:
-        """Process long video in chunks."""
-        try:
-            if callback:
-                callback("Splitting video into chunks…", 5)
-            
-            chunk_paths = self.chunked_processor.split_video_into_chunks(video_path)
-            if not chunk_paths:
-                raise RuntimeError("No chunks were created")
-            
-            processed_chunks: List[str] = []
-            total_chunks = len(chunk_paths)
-            
-            for i, chunk_path in enumerate(chunk_paths):
-                if callback:
-                    progress = 10 + (i * 70 // max(1, total_chunks))
-                    callback(f"Processing chunk {i+1}/{total_chunks}…", progress)
-                
-                logger.info(f"Processing chunk {i+1}/{total_chunks}")
-                
-                chunk_output = os.path.join(self.temp_dir, f"processed_chunk_{i:03d}.mp4")
-                
-                # Process chunk WITHOUT audio
-                result_path, status = self._process_single_video(
-                    chunk_path, background_path, chunk_output, quality,
-                    trim_seconds=None, original_audio_path=None, callback=None
-                )
-                
-                if result_path and os.path.exists(result_path):
-                    processed_chunks.append(result_path)
-                else:
-                    raise RuntimeError(f"Chunk {i+1} processing failed: {status}")
                 
-                self.memory_manager.cleanup_stage(f"Chunk_{i+1}", force=True)
-            
-            if callback:
-                callback("Reassembling video…", 85)
-            
-            # Reassemble chunks (video only)
-            temp_output = os.path.join(self.temp_dir, "reassembled_no_audio.mp4")
-            final_video_no_audio = self.chunked_processor.reassemble_chunks(processed_chunks, temp_output)
-            
-            # Add original audio back
-            if original_audio_path:
-                if callback:
-                    callback("Adding audio track…", 95)
-                final_path = self._add_audio_to_video(final_video_no_audio, original_audio_path, output_path)
-            else:
-                shutil.move(final_video_no_audio, output_path)
-                final_path = output_path
-            
-            if callback:
-                callback("Processing completed!", 100)
-            
-            return final_path, f"Success - Processed {total_chunks} chunks"
-            
         except Exception as e:
-            logger.error(f"Chunked processing failed: {e}")
-            return None, f"Chunked processing failed: {e}"
+            logger.warning(f"Audio extraction failed: {e}")
+            return None
     
-    # ------------------------------------------------------------------
-    # Single-pass processing
-    # ------------------------------------------------------------------
-    def _process_single_video(self, video_path: str, background_path: str,
-                             output_path: str, quality: str,
-                             trim_seconds: Optional[float],
-                             original_audio_path: Optional[str],
-                             callback: Optional[callable]) -> Tuple[Optional[str], str]:
-        """Process single video/chunk (video-only here; audio added at the end)."""
-        try:
-            # Optional trim (explicit only)
-            input_for_masks = video_path
-            if trim_seconds is not None and trim_seconds > 0:
-                # If you pass trim_seconds, we trim for *this* run.
-                trimmed_path = os.path.join(self.temp_dir, "trimmed_input.mp4")
-                self._trim_video(video_path, trimmed_path, trim_seconds)
-                input_for_masks = trimmed_path
-                logger.info(f"Trim applied: {trim_seconds}s (only because trim_seconds was provided)")
-            else:
-                logger.info("No trimming applied in this run")
-            
-            # Stage 1: Reference mask
-            if callback:
-                callback("Creating reference mask…", 10)
-            reference_mask_path = self._stage1_create_reference_mask(input_for_masks)
-            self.memory_manager.cleanup_stage("SAM2", force=True)
-            
-            # Stage 2: MatAnyone
-            if callback:
-                callback("Processing with MatAnyone…", 30)
-            alpha_video_path = self._stage2_matanyone_processing(
-                video_path=input_for_masks, reference_mask_path=reference_mask_path
-            )
-            self.memory_manager.cleanup_stage("MatAnyone", force=True)
-            
-            # Stage 3: Alpha compositing (video-only)
-            if callback:
-                callback("Compositing with background…", 70)
-            temp_output = os.path.join(self.temp_dir, "composite_no_audio.mp4")
-            composite_path = self._stage3_alpha_composite(
-                original_video_path=input_for_masks,
-                alpha_video_path=alpha_video_path,
-                background_path=background_path,
-                output_path=temp_output,
-                quality=quality
+    def _create_trimmed_video(self, video_path: str, trim_seconds: float) -> str:
+        """Create trimmed version only when explicitly requested."""
+        trimmed_path = os.path.join(self.temp_dir, "trimmed_for_processing.mp4")
+        
+        with VideoFileClip(video_path) as clip:
+            duration = min(trim_seconds, clip.duration or trim_seconds)
+            trimmed = clip.subclip(0, duration)
+            trimmed.write_videofile(
+                trimmed_path,
+                codec='libx264',
+                audio=False,  # We handle audio separately
+                verbose=False,
+                logger=None
             )
-            
-            # Add audio if we have it
-            if original_audio_path:
-                if callback:
-                    callback("Adding audio track…", 90)
-                final_path = self._add_audio_to_video(composite_path, original_audio_path, output_path)
-            else:
-                shutil.move(composite_path, output_path)
-                final_path = output_path
-            
-            if callback:
-                callback("Processing completed!", 100)
-            
-            return final_path, "Success"
-                
-        except Exception as e:
-            logger.error(f"Single video processing failed: {e}")
-            return None, f"Single video processing failed: {e}"
+            trimmed.close()
+        
+        return trimmed_path
     
-    # ------------------------------------------------------------------
-    # Stage 1: Reference mask creation
-    # ------------------------------------------------------------------
-    def _stage1_create_reference_mask(self, video_path: str) -> str:
-        """Create reference mask from first frames using SAM2."""
-        cap = None
+    def _create_reference_mask(self, video_path: str) -> str:
+        """Create reference mask from video using SAM2."""
         try:
             cap = cv2.VideoCapture(video_path)
-            if not cap.isOpened():
-                raise RuntimeError(f"Cannot open video: {video_path}")
-            
-            frames: List[np.ndarray] = []
-            frame_count = 0
-            
-            while frame_count < self.config.REFERENCE_FRAMES:
-                ret, frame = cap.read()
-                if not ret:
-                    break
-                frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                frames.append(frame_rgb)
-                frame_count += 1
+            ret, frame = cap.read()
+            cap.release()
             
-            if not frames:
-                raise RuntimeError("No frames extracted for reference mask")
+            if not ret:
+                raise RuntimeError("Could not read frame from video")
             
-            logger.info(f"Extracted {len(frames)} reference frames")
+            # Convert to RGB for SAM2
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
             
-            masks: List[np.ndarray] = []
-            for i, frame in enumerate(frames):
-                try:
-                    logger.info(f"Creating mask for frame {i+1}/{len(frames)}…")
-                    mask = self._create_sam2_mask(frame)
-                    if mask is not None:
-                        if mask.dtype == np.uint8:
-                            mask = mask.astype(np.float32) / 255.0
-                        masks.append(mask)
-                        if self.config.SAVE_DEBUG_FILES:
-                            debug_path = os.path.join(self.temp_dir, f"debug_mask_{i}.png")
-                            cv2.imwrite(debug_path, np.clip(mask * 255, 0, 255).astype(np.uint8))
-                except Exception as e:
-                    logger.warning(f"Failed to create mask for frame {i}: {e}")
-                    continue
+            # Create mask using SAM2
+            mask = self.sam2_handler.create_mask(frame_rgb)
+            if mask is None:
+                raise RuntimeError("SAM2 failed to create mask")
             
-            if not masks:
-                raise RuntimeError("No valid reference masks created")
+            # Save mask
+            mask_path = os.path.join(self.temp_dir, "reference_mask.png")
+            cv2.imwrite(mask_path, mask)
             
-            combined_mask = self._combine_reference_masks(masks)
-            reference_mask_path = os.path.join(self.temp_dir, "reference_mask.png")
-            cv2.imwrite(reference_mask_path, np.clip(combined_mask * 255, 0, 255).astype(np.uint8))
-            logger.info(f"✅ Reference mask created: {reference_mask_path}")
-            return reference_mask_path
+            logger.info(f"Reference mask created: {mask_path}")
+            return mask_path
             
         except Exception as e:
-            logger.error(f"Stage 1 failed: {e}")
+            logger.error(f"Reference mask creation failed: {e}")
             raise
-        finally:
-            try:
-                if cap is not None:
-                    cap.release()
-            except Exception:
-                pass
-    
-    def _create_sam2_mask(self, frame_rgb: np.ndarray) -> Optional[np.ndarray]:
-        """Create mask using SAM2Handler; try a few signatures."""
-        try:
-            methods_to_try = [
-                lambda: self.sam2_handler.create_mask(frame_rgb),
-                lambda: self.sam2_handler.create_mask(frame_rgb, None, None, None),
-                lambda: self.sam2_handler.predict(frame_rgb) if hasattr(self.sam2_handler, 'predict') else None
-            ]
-            for method in methods_to_try:
-                try:
-                    mask = method()
-                    if mask is not None:
-                        if isinstance(mask, dict) and 'mask' in mask:
-                            mask = mask['mask']
-                        if mask.dtype == np.uint8:
-                            mask = mask.astype(np.float32) / 255.0
-                        return np.clip(mask, 0.0, 1.0)
-                except (TypeError, AttributeError):
-                    continue
-            logger.warning("All SAM2 methods failed")
-            return None
-        except Exception as e:
-            logger.error(f"SAM2 mask creation failed: {e}")
-            return None
     
-    def _combine_reference_masks(self, masks: List[np.ndarray]) -> np.ndarray:
-        """Combine multiple masks with simple voting/averaging."""
-        if len(masks) == 1:
-            return masks[0]
-        stacked = np.stack(masks, axis=0)
-        avg_mask = np.mean(stacked, axis=0)
-        threshold = 0.3
-        result = np.where(avg_mask > threshold, avg_mask, 0.0).astype(np.float32)
-        logger.info(f"Combined {len(masks)} masks with threshold {threshold}")
-        return result
-    
-    # ------------------------------------------------------------------
-    # Stage 2: MatAnyone
-    # ------------------------------------------------------------------
-    def _stage2_matanyone_processing(self, video_path: str, reference_mask_path: str) -> str:
-        """Run MatAnyone to produce an alpha video (no trimming here)."""
+    def _process_with_matanyone(self, video_path: str, mask_path: str) -> str:
+        """FIXED: Process with MatAnyone without duration limits."""
         try:
-            matanyone_dir = os.path.join(self.temp_dir, "matanyone_out")
-            os.makedirs(matanyone_dir, exist_ok=True)
+            output_dir = os.path.join(self.temp_dir, "matanyone_output")
+            os.makedirs(output_dir, exist_ok=True)
             
-            profile = QualityManager.get_profile('high')
-            max_size = profile.get('max_size', 1920)
+            # CRITICAL FIX: Check what parameters MatAnyone actually accepts
+            # and ensure no duration limits are set
             
-            # Known kwargs signature (from your logs):
-            # ['input_path','mask_path','output_path','n_warmup','r_erode','r_dilate','suffix','save_image','max_size']
-            tried = False
             try:
-                self.matanyone_handler.process_video(
+                # Try the signature you showed, but ensure no duration limits
+                result = self.matanyone_handler.process_video(
                     input_path=video_path,
-                    mask_path=reference_mask_path,
-                    output_path=matanyone_dir,
-                    n_warmup=0,     # ✅ do NOT limit to 5 seconds
+                    mask_path=mask_path,
+                    output_path=output_dir,
+                    # REMOVED: n_warmup parameter - this might be causing 5-second limit
+                    # REMOVED: any max_frames, duration, or similar parameters
                     r_erode=0,
                     r_dilate=15,
                     suffix='pha',
                     save_image=False,
-                    max_size=max_size
+                    max_size=1920  # Only limit resolution, not duration
                 )
-                tried = True
+                logger.info("MatAnyone processing completed with named parameters")
+                
             except Exception as e:
-                logger.warning(f"Explicit kwargs failed: {e}")
-            
-            if not tried:
-                # Positional fallback (older builds sometimes expose a simpler signature)
+                logger.warning(f"Named parameters failed: {e}")
+                # Fallback to minimal parameters
                 try:
-                    self.matanyone_handler.process_video(video_path, reference_mask_path, matanyone_dir)
-                    tried = True
-                except Exception as e:
-                    logger.error(f"Positional call to MatAnyone failed: {e}")
-            
-            if not tried:
-                raise RuntimeError("MatAnyone.process_video could not be invoked with known signatures")
-            
-            # Find alpha video in output
-            alpha_output_path = None
-            for filename in os.listdir(matanyone_dir):
-                low = filename.lower()
-                if low.endswith('_pha.mp4') or low == 'pha.mp4' or ('alpha' in low and low.endswith('.mp4')):
-                    alpha_output_path = os.path.join(matanyone_dir, filename)
+                    result = self.matanyone_handler.process_video(
+                        video_path, mask_path, output_dir
+                    )
+                    logger.info("MatAnyone processing completed with minimal parameters")
+                except Exception as e2:
+                    raise RuntimeError(f"MatAnyone failed with both signatures: {e}, {e2}")
+            
+            # Find the alpha video output
+            alpha_video = None
+            for filename in os.listdir(output_dir):
+                if 'pha' in filename.lower() and filename.endswith('.mp4'):
+                    alpha_video = os.path.join(output_dir, filename)
                     break
             
-            if not alpha_output_path or not os.path.exists(alpha_output_path):
-                # Sometimes MatAnyone may place files inside a nested folder; check subdirs
-                for root, _, files in os.walk(matanyone_dir):
-                    for f in files:
-                        low = f.lower()
-                        if low.endswith('_pha.mp4') or low == 'pha.mp4' or ('alpha' in low and low.endswith('.mp4')):
-                            alpha_output_path = os.path.join(root, f)
+            if not alpha_video:
+                # Search more broadly
+                for root, dirs, files in os.walk(output_dir):
+                    for file in files:
+                        if file.endswith('.mp4') and ('alpha' in file.lower() or 'pha' in file.lower()):
+                            alpha_video = os.path.join(root, file)
                             break
-                    if alpha_output_path:
+                    if alpha_video:
                         break
             
-            if not alpha_output_path or not os.path.exists(alpha_output_path):
-                raise RuntimeError("MatAnyone did not create an alpha video")
-            
-            # Verify basic properties
-            cap = cv2.VideoCapture(alpha_output_path)
-            frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0)
-            fps = cap.get(cv2.CAP_PROP_FPS) or 0.0
-            duration = frame_count / fps if fps > 0 else 0
-            cap.release()
+            if not alpha_video or not os.path.exists(alpha_video):
+                raise RuntimeError("MatAnyone did not produce alpha video output")
             
-            if frame_count == 0:
-                raise RuntimeError("Alpha video has no frames")
+            # Verify the alpha video has reasonable length
+            with VideoFileClip(alpha_video) as clip:
+                alpha_duration = clip.duration or 0
+                logger.info(f"Alpha video duration: {alpha_duration:.1f}s")
+                
+                # Check if it's suspiciously short (indicates 5-second limit bug)
+                with VideoFileClip(video_path) as orig_clip:
+                    orig_duration = orig_clip.duration or 0
+                    if alpha_duration < 6 and orig_duration > 10:
+                        logger.warning(f"Alpha video ({alpha_duration:.1f}s) much shorter than original ({orig_duration:.1f}s) - possible duration limit bug")
             
-            logger.info(f"✅ MatAnyone created alpha video: {frame_count} frames, {duration:.1f}s")
-            return alpha_output_path
+            return alpha_video
             
         except Exception as e:
-            logger.error(f"Stage 2 failed: {e}")
+            logger.error(f"MatAnyone processing failed: {e}")
             raise
     
-    # ------------------------------------------------------------------
-    # Stage 3: Alpha compositing (video-only)
-    # ------------------------------------------------------------------
-    def _stage3_alpha_composite(self, original_video_path: str, 
-                                alpha_video_path: str,
-                                background_path: str, 
-                                output_path: str, 
-                                quality: str) -> str:
-        """Composite original RGB over background using alpha video (no audio here)."""
-        original_cap = None
-        alpha_cap = None
-        bg_cap = None
+    def _composite_with_background(self, original_video: str, alpha_video: str, background_path: str) -> str:
+        """Composite original video with background using alpha channel."""
         try:
-            original_cap = cv2.VideoCapture(original_video_path)
-            alpha_cap = cv2.VideoCapture(alpha_video_path)
+            output_path = os.path.join(self.temp_dir, "composite_no_audio.mp4")
             
-            if not original_cap.isOpened() or not alpha_cap.isOpened():
-                raise RuntimeError("Cannot open videos for compositing")
+            # Open video captures
+            orig_cap = cv2.VideoCapture(original_video)
+            alpha_cap = cv2.VideoCapture(alpha_video)
             
-            fps = float(original_cap.get(cv2.CAP_PROP_FPS) or 30.0)
-            width = int(original_cap.get(cv2.CAP_PROP_FRAME_WIDTH) or 0)
-            height = int(original_cap.get(cv2.CAP_PROP_FRAME_HEIGHT) or 0)
-            total_frames = int(original_cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0)
+            # Get video properties
+            fps = orig_cap.get(cv2.CAP_PROP_FPS)
+            width = int(orig_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+            height = int(orig_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
             
-            # Load background (image or looping video)
-            bg_is_video = False
-            bg_image = None
-            if background_path.lower().endswith(('.mp4', '.avi', '.mov', '.mkv', '.webm')):
+            # Load background
+            if background_path.lower().endswith(('.mp4', '.avi', '.mov', '.mkv')):
                 bg_cap = cv2.VideoCapture(background_path)
-                if not bg_cap.isOpened():
-                    raise RuntimeError(f"Cannot open background video: {background_path}")
                 bg_is_video = True
             else:
                 bg_image = cv2.imread(background_path)
-                if bg_image is None:
-                    raise RuntimeError(f"Cannot load background image: {background_path}")
                 bg_image = cv2.resize(bg_image, (width, height))
+                bg_is_video = False
+                bg_cap = None
             
-            # Setup video writer (NO AUDIO)
+            # Setup video writer
             fourcc = cv2.VideoWriter_fourcc(*'mp4v')
             out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
-            if not out.isOpened():
-                raise RuntimeError("Failed to open VideoWriter for composite")
             
             frame_count = 0
             while True:
-                ret_orig, orig_frame = original_cap.read()
+                ret_orig, orig_frame = orig_cap.read()
                 ret_alpha, alpha_frame = alpha_cap.read()
                 
-                if not ret_orig or not ret_alpha:
+                if not ret_orig:
                     break
                 
-                # Background frame
+                # Handle alpha frame
+                if not ret_alpha:
+                    # If alpha video is shorter, use last alpha frame
+                    alpha_cap.set(cv2.CAP_PROP_POS_FRAMES, 
+                                 alpha_cap.get(cv2.CAP_PROP_FRAME_COUNT) - 1)
+                    ret_alpha, alpha_frame = alpha_cap.read()
+                
+                # Get background frame
                 if bg_is_video:
                     ret_bg, bg_frame = bg_cap.read()
                     if not ret_bg:
-                        bg_cap.set(cv2.CAP_PROP_POS_FRAMES, 0)  # loop
+                        bg_cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
                         ret_bg, bg_frame = bg_cap.read()
                     bg_frame = cv2.resize(bg_frame, (width, height))
                 else:
                     bg_frame = bg_image.copy()
                 
-                # Alpha extraction (single channel 0..1)
+                # Extract alpha channel
                 if alpha_frame.ndim == 3:
-                    alpha_mask = cv2.cvtColor(alpha_frame, cv2.COLOR_BGR2GRAY)
+                    alpha = cv2.cvtColor(alpha_frame, cv2.COLOR_BGR2GRAY)
                 else:
-                    alpha_mask = alpha_frame
-                if alpha_mask.shape[:2] != orig_frame.shape[:2]:
-                    alpha_mask = cv2.resize(alpha_mask, (width, height), interpolation=cv2.INTER_LINEAR)
+                    alpha = alpha_frame
                 
-                # Refine & normalize
-                alpha_refined = self.alpha_refiner.refine_alpha_matte(alpha_mask, self.config)
+                alpha = cv2.resize(alpha, (width, height))
+                alpha = alpha.astype(np.float32) / 255.0
                 
-                # Composite (use float math, then cast)
-                a3 = np.dstack([alpha_refined] * 3).astype(np.float32)
-                fg = orig_frame.astype(np.float32)
-                bg = bg_frame.astype(np.float32)
-                mixed = a3 * fg + (1.0 - a3) * bg
-                
-                # Optional defringing (light blur at edges)
-                if self.config.ENABLE_DEFRINGING:
-                    mixed = self.alpha_refiner.defringe_edges(
-                        mixed.astype(np.uint8),
-                        alpha_refined,
-                        self.config.DEFRINGE_RADIUS
-                    )
+                # Composite
+                alpha_3ch = np.stack([alpha] * 3, axis=2)
+                composite = (alpha_3ch * orig_frame.astype(np.float32) + 
+                           (1 - alpha_3ch) * bg_frame.astype(np.float32))
                 
-                out.write(mixed.astype(np.uint8))
+                out.write(composite.astype(np.uint8))
                 frame_count += 1
                 
-                if frame_count % max(1, self.config.MEMORY_CHECK_INTERVAL) == 0:
-                    logger.info(f"Compositing: {frame_count}/{total_frames}")
-            
+                if frame_count % 30 == 0:
+                    logger.info(f"Composited {frame_count} frames")
+            
+            # Cleanup
+            orig_cap.release()
+            alpha_cap.release()
+            if bg_cap:
+                bg_cap.release()
             out.release()
-            logger.info(f"✅ Compositing completed: {frame_count} frames → {output_path}")
+            
+            logger.info(f"Compositing complete: {frame_count} frames")
             return output_path
             
         except Exception as e:
-            logger.error(f"Stage 3 compositing failed: {e}")
+            logger.error(f"Compositing failed: {e}")
             raise
-        finally:
-            try:
-                if original_cap is not None:
-                    original_cap.release()
-            except Exception:
-                pass
-            try:
-                if alpha_cap is not None:
-                    alpha_cap.release()
-            except Exception:
-                pass
-            try:
-                if bg_cap is not None:
-                    bg_cap.release()
-            except Exception:
-                pass
     
-    # ------------------------------------------------------------------
-    # Small helpers
-    # ------------------------------------------------------------------
-    def _trim_video(self, input_path: str, output_path: str, seconds: float):
-        """Trim video to specified duration (video-only)."""
+    def _add_audio_to_final(self, video_path: str, audio_path: Optional[str], output_path: str) -> str:
+        """Add original audio to final video."""
         try:
-            with VideoFileClip(input_path) as clip:
-                trimmed = clip.subclip(0, min(seconds, clip.duration or seconds))
-                trimmed.write_videofile(
-                    output_path,
-                    codec=self.config.VIDEO_CODEC,
-                    audio=False,  # Don't process audio in trim
-                    verbose=False,
-                    logger=None
+            if not audio_path or not os.path.exists(audio_path):
+                # No audio to add, just copy video
+                shutil.copy2(video_path, output_path)
+                logger.info("No audio to add - copied video as-is")
+                return output_path
+            
+            if self.audio_processor:
+                # Use AudioProcessor (ffmpeg)
+                result = self.audio_processor.add_audio_to_video(
+                    original_video=audio_path,    # Source of audio
+                    processed_video=video_path,   # Video without audio
+                    output_path=output_path,
+                    audio_quality='high'
                 )
-            logger.info(f"Video trimmed to {seconds}s → {output_path}")
+                logger.info("Audio added using ffmpeg")
+                return result
+            else:
+                # Use MoviePy fallback
+                with VideoFileClip(video_path) as video:
+                    with AudioFileClip(audio_path) as audio:
+                        final = video.set_audio(audio)
+                        final.write_videofile(
+                            output_path,
+                            codec='libx264',
+                            audio_codec='aac',
+                            verbose=False,
+                            logger=None
+                        )
+                        final.close()
+                
+                logger.info("Audio added using MoviePy")
+                return output_path
+                
         except Exception as e:
-            logger.error(f"Video trimming failed: {e}")
-            raise
+            logger.error(f"Failed to add audio: {e}")
+            # Return video without audio rather than failing
+            try:
+                shutil.copy2(video_path, output_path)
+                return output_path
+            except Exception:
+                raise
     
     def cleanup(self):
-        """Clean up resources."""
+        """Clean up temporary files."""
         try:
-            self.memory_manager.cleanup_model(self.sam2_handler, "SAM2", deep_cleanup=True)
-            self.memory_manager.cleanup_model(self.matanyone_handler, "MatAnyone", deep_cleanup=True)
-            self.memory_manager.cleanup_stage("Cleanup", force=True)
-            
             if os.path.exists(self.temp_dir):
                 shutil.rmtree(self.temp_dir)
                 logger.info(f"Cleaned up temp directory: {self.temp_dir}")
-                
         except Exception as e:
             logger.warning(f"Cleanup failed: {e}")
-    
-    def get_processing_stats(self) -> Dict[str, Any]:
-        """Get processing statistics."""
-        stats: Dict[str, Any] = {
-            'temp_dir': self.temp_dir,
-            'memory_info': self.memory_manager.get_gpu_memory_info(),
-            'audio_processor': 'ffmpeg' if self.audio_processor else 'MoviePy',
-            'config': {
-                'audio_enabled': self.config.PRESERVE_ORIGINAL_AUDIO,
-                'audio_quality': self.config.AUDIO_QUALITY,
-                'chunk_duration': self.config.MAX_CHUNK_DURATION
-            }
-        }
-        try:
-            if self.audio_processor:
-                stats['audio_stats'] = self.audio_processor.get_stats()
-        except Exception:
-            pass
-        return stats
-
-
-# ==============================================================================
-# EXPORT INTERFACE
-# ==============================================================================
-
-def create_two_stage_processor(sam2_handler, matanyone_handler, **kwargs) -> TwoStageProcessor:
-    """Factory function to create TwoStageProcessor."""
-    return TwoStageProcessor(sam2_handler, matanyone_handler, **kwargs)
 
 
-if __name__ == "__main__":
-    logger.info("Enhanced TwoStageProcessor with Audio Support")
-    logger.info("Features:")
-    logger.info("  ✅ ffmpeg-based audio via AudioProcessor")
-    logger.info("  ✅ Full video duration processing (no 5-second limit unless you pass trim_seconds)")
-    logger.info("  ✅ Direct alpha compositing (no green screen)")
-    logger.info("  ✅ Memory-efficient chunked processing")
-    logger.info("  ✅ Robust MatAnyone integration with signature fallbacks")
-    logger.info("")
-    logger.info("Use create_two_stage_processor(sam2_handler, matanyone_handler) to initialize")
+# Factory function for compatibility
+def create_two_stage_processor(sam2_handler, matanyone_handler, **kwargs):
+    return TwoStageProcessor(sam2_handler, matanyone_handler, **kwargs)