Update app.py

app.py

@@ -25,6 +25,7 @@ import docx
 import PyPDF2
 import pptx
 import cv2
+from PIL import ImageEnhance
 
 class FileProcessor:
     @staticmethod
@@ -831,143 +832,178 @@ class EnhancedVideoGenerator:
         msecs = int((seconds - int(seconds)) * 1000)
         return f"{hours:02d}:{minutes:02d}:{secs:02d},{msecs:03d}"
 
-    def create_video(self, script: str, style: str, duration: int, output_path: str, selected_images: List[str]) -> str:
-        """Create video with selected images and improved error handling"""
-        try:
-            # Initialize progress tracking
-            progress_bar = st.progress(0)
-            status_text = st.empty()
-            
-            # Validate inputs
-            if not selected_images:
-                raise ValueError("No images selected. Please select at least one image.")
-            
-            if not script.strip():
-                raise ValueError("Script cannot be empty.")
-            
-            # Generate voice-over
-            status_text.text("Creating voice-over...")
-            audio = self.generate_fallback_audio(script)  # Using fallback audio for reliability
-            progress_bar.progress(20)
-            
-            # Process images
-            status_text.text("Processing images...")
-            processed_images = []
-            
-            for img_url in selected_images:
-                try:
-                    response = requests.get(img_url, timeout=10)
-                    response.raise_for_status()
-                    img = Image.open(BytesIO(response.content))
-                    img = img.convert('RGB')
-                    img = img.resize((1920, 1080), Image.Resampling.LANCZOS)
-                    processed_images.append(img)
-                except Exception as e:
-                    print(f"Error processing image {img_url}: {e}")
-                    continue
-            
-            if not processed_images:
-                raise ValueError("Failed to process any of the selected images.")
-            
-            progress_bar.progress(40)
-            
-            # Create frames
-            status_text.text("Generating frames...")
-            frames = []
-            fps = 30
-            total_frames = int(duration * fps)
-            frames_per_image = total_frames // len(processed_images)
-            
-            # Convert images to numpy arrays
-            image_arrays = [np.array(img) for img in processed_images]
-            
-            # Generate frames with transitions
-            frame_count = 0
-            for idx, img_array in enumerate(image_arrays):
-                # Calculate how many frames this image should appear
-                if idx == len(image_arrays) - 1:
-                    n_frames = total_frames - frame_count
-                else:
-                    n_frames = min(frames_per_image, total_frames - frame_count)
+   def create_video(self, script: str, style: str, duration: int, output_path: str, selected_images: List[str]) -> str:
+    """Create video with enhanced features and proper error handling"""
+    try:
+        # Initialize progress tracking
+        progress_bar = st.progress(0)
+        status_text = st.empty()
+        
+        # Create output directory if it doesn't exist
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+        
+        # Validate inputs and paths
+        if not output_path:
+            raise ValueError("Output path cannot be empty")
+        if not selected_images:
+            raise ValueError("No images selected")
+            
+        # Generate voice-over with progress tracking
+        status_text.text("Creating voice-over...")
+        audio = self.generate_voice_over(script)
+        progress_bar.progress(20)
+        
+        # Process images with effects
+        status_text.text("Processing images with effects...")
+        processed_images = []
+        
+        for img_url in selected_images:
+            try:
+                response = requests.get(img_url, timeout=10)
+                response.raise_for_status()
+                img = Image.open(BytesIO(response.content))
+                img = img.convert('RGB')
                 
-                # Add main frames
-                for _ in range(n_frames):
-                    frames.append(img_array)
-                    frame_count += 1
+                # Apply image effects based on style
+                if style == "Creative":
+                    # Add creative effects
+                    enhancer = ImageEnhance.Contrast(img)
+                    img = enhancer.enhance(1.2)
+                    enhancer = ImageEnhance.Brightness(img)
+                    img = enhancer.enhance(1.1)
+                elif style == "Professional":
+                    # Add professional effects
+                    enhancer = ImageEnhance.Sharpness(img)
+                    img = enhancer.enhance(1.3)
                 
-                # Add transition frames to next image
-                if idx < len(image_arrays) - 1:
-                    next_img_array = image_arrays[idx + 1]
-                    transition_frames = 15  # Number of transition frames
-                    for t in range(transition_frames):
-                        if frame_count < total_frames:
-                            alpha = t / transition_frames
-                            transition_frame = cv2.addWeighted(
-                                img_array, 1 - alpha,
-                                next_img_array, alpha, 0
-                            )
-                            frames.append(transition_frame)
-                            frame_count += 1
-            
-            progress_bar.progress(70)
-            
-            # Create video with frames
-            status_text.text("Compiling video...")
-            clip = ImageSequenceClip(frames, fps=fps)
-            
-            # Add audio
-            audio_duration = audio.duration
-            video_duration = len(frames) / fps
-            
-            if audio_duration > video_duration:
-                audio = audio.subclip(0, video_duration)
-            elif audio_duration < video_duration:
-                clip = clip.subclip(0, audio_duration)
-            
-            final_clip = clip.set_audio(audio)
-            
-            # Ensure output directory exists
-            output_dir = os.path.dirname(output_path)
-            if output_dir and not os.path.exists(output_dir):
-                os.makedirs(output_dir)
-            
-            progress_bar.progress(90)
-            
-            # Write video file
-            status_text.text("Saving video...")
+                img = img.resize((1920, 1080), Image.Resampling.LANCZOS)
+                processed_images.append(img)
+                
+            except Exception as e:
+                print(f"Error processing image {img_url}: {e}")
+                continue
+        
+        progress_bar.progress(40)
+        
+        # Generate frames with transitions
+        status_text.text("Creating frames with transitions...")
+        frames = []
+        fps = 30
+        total_frames = int(duration * fps)
+        frames_per_image = total_frames // len(processed_images)
+        
+        # Convert images to numpy arrays
+        image_arrays = [np.array(img) for img in processed_images]
+        
+        # Add transition effects
+        frame_count = 0
+        for idx, img_array in enumerate(image_arrays):
+            # Calculate frames for this image
+            if idx == len(image_arrays) - 1:
+                n_frames = total_frames - frame_count
+            else:
+                n_frames = min(frames_per_image, total_frames - frame_count)
+            
+            # Add effects and transitions
+            for frame_idx in range(n_frames):
+                # Apply fade in/out effect
+                alpha = 1.0
+                if frame_idx < 15:  # Fade in
+                    alpha = frame_idx / 15
+                elif frame_idx > n_frames - 15:  # Fade out
+                    alpha = (n_frames - frame_idx) / 15
+                
+                frame = img_array * alpha
+                frames.append(frame.astype(np.uint8))
+                frame_count += 1
+                
+                # Update progress
+                progress = int(40 + (frame_count / total_frames * 30))
+                progress_bar.progress(progress)
+            
+            # Add transition to next image
+            if idx < len(image_arrays) - 1:
+                next_img_array = image_arrays[idx + 1]
+                transition_frames = 15
+                for t in range(transition_frames):
+                    if frame_count < total_frames:
+                        alpha = t / transition_frames
+                        transition_frame = cv2.addWeighted(
+                            img_array, 1 - alpha,
+                            next_img_array, alpha, 0
+                        )
+                        frames.append(transition_frame)
+                        frame_count += 1
+        
+        progress_bar.progress(70)
+        
+        # Create video with frames
+        status_text.text("Compiling video...")
+        clip = ImageSequenceClip(frames, fps=fps)
+        
+        # Add audio with proper synchronization
+        audio_duration = audio.duration
+        video_duration = len(frames) / fps
+        
+        if audio_duration > video_duration:
+            audio = audio.subclip(0, video_duration)
+        elif audio_duration < video_duration:
+            clip = clip.subclip(0, audio_duration)
+        
+        final_clip = clip.set_audio(audio)
+        
+        # Write video with progress caching
+        status_text.text("Saving video...")
+        cache_dir = os.path.join(os.path.dirname(output_path), ".cache")
+        os.makedirs(cache_dir, exist_ok=True)
+        
+        try:
+            final_clip.write_videofile(
+                output_path,
+                fps=fps,
+                codec='libx264',
+                audio_codec='aac',
+                ffmpeg_params=['-pix_fmt', 'yuv420p'],
+                temp_audiofile=os.path.join(cache_dir, "temp-audio.m4a"),
+                verbose=False,
+                logger=None
+            )
+        except Exception as e:
+            # Attempt error recovery
+            status_text.text("Attempting error recovery...")
             try:
+                # Try alternative codec settings
                 final_clip.write_videofile(
                     output_path,
                     fps=fps,
                     codec='libx264',
-                    audio_codec='aac',
-                    ffmpeg_params=['-pix_fmt', 'yuv420p'],  # Ensure compatibility
+                    audio_codec='mp3',
                     verbose=False,
                     logger=None
                 )
-            except Exception as e:
-                raise RuntimeError(f"Failed to write video file: {str(e)}")
-            
-            progress_bar.progress(100)
-            status_text.text("Video generation complete!")
-            
-            return output_path
-            
+            except Exception as recovery_e:
+                raise RuntimeError(f"Video creation failed even with recovery attempt: {str(recovery_e)}")
+        
+        progress_bar.progress(100)
+        status_text.text("Video generation complete!")
+        
+        return output_path
+        
+    except Exception as e:
+        error_msg = f"Video creation failed: {str(e)}"
+        print(error_msg)
+        raise RuntimeError(error_msg)
+    finally:
+        # Cleanup
+        try:
+            if 'clip' in locals():
+                clip.close()
+            if 'final_clip' in locals():
+                final_clip.close()
+            if 'audio' in locals():
+                audio.close()
         except Exception as e:
-            error_msg = f"Video creation failed: {str(e)}"
-            print(error_msg)  # For debugging
-            raise RuntimeError(error_msg)
-        finally:
-            # Cleanup
-            try:
-                if 'clip' in locals():
-                    clip.close()
-                if 'final_clip' in locals():
-                    final_clip.close()
-                if 'audio' in locals():
-                    audio.close()
-            except Exception as e:
-                print(f"Cleanup error: {e}")
+            print(f"Cleanup error: {e}")