Update app.py

app.py

@@ -6,7 +6,7 @@ from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
 from PIL import Image, ImageDraw, ImageFont
 import tempfile
 import os
-from moviepy.editor import AudioFileClip, concatenate_videoclips, ImageClip
+from moviepy.editor import *
 import numpy as np
 from gtts import gTTS
 import textwrap
@@ -457,51 +457,17 @@ class ImageScraper:
             return False
 
     def generate_fallback_audio(self, script: str) -> AudioFileClip:
-        """Generate fallback audio using gTTS with improved error handling"""
+        """Generate fallback audio using gTTS"""
         try:
             audio_path = self.temp_dir / "voice.mp3"
-            
-            # Split long text into chunks to avoid gTTS limitations
-            max_chars = 5000
-            text_chunks = [script[i:i+max_chars] for i in range(0, len(script), max_chars)]
-            
-            # Create temporary files for each chunk
-            temp_files = []
-            for i, chunk in enumerate(text_chunks):
-                temp_path = self.temp_dir / f"voice_chunk_{i}.mp3"
-                tts = gTTS(text=chunk, lang='en', slow=False)
-                tts.save(str(temp_path))
-                temp_files.append(temp_path)
-            
-            # Concatenate audio files if there are multiple chunks
-            if len(temp_files) > 1:
-                clips = [AudioFileClip(str(f)) for f in temp_files]
-                final_clip = concatenate_audioclips(clips)
-                final_clip.write_audiofile(str(audio_path), codec='mp3')
-                final_clip.close()
-                for clip in clips:
-                    clip.close()
-            else:
-                # Just rename the single chunk file
-                os.rename(temp_files[0], audio_path)
-            
-            # Clean up temporary files
-            for temp_file in temp_files:
-                if temp_file.exists():
-                    temp_file.unlink()
-            
-            # Verify the audio file
-            if not audio_path.exists() or audio_path.stat().st_size == 0:
-                raise Exception("Audio file generation failed")
-                
+            tts = gTTS(text=script, lang='en', slow=False)
+            tts.save(str(audio_path))
             return AudioFileClip(str(audio_path))
-            
         except Exception as e:
-            logging.error(f"Audio generation failed: {str(e)}")
-            # Create a silent audio clip as last resort
-            silence_duration = len(script.split()) / 3  # Approximate duration based on words
-            return AudioFileClip(duration=silence_duration)
-    
+            print(f"Fallback audio generation failed: {e}")
+            # Create silent audio clip
+            return AudioFileClip(str(audio_path)) if os.path.exists(str(audio_path)) else None
+
     def scrape_pexels(self, query: str) -> List[str]:
         urls = []
         try:
@@ -552,50 +518,16 @@ class EnhancedVideoGenerator:
 
 
     def generate_fallback_audio(self, script: str) -> AudioFileClip:
-        """Generate fallback audio using gTTS with improved error handling"""
+        """Generate fallback audio using gTTS"""
         try:
             audio_path = self.temp_dir / "voice.mp3"
-            
-            # Split long text into chunks to avoid gTTS limitations
-            max_chars = 5000
-            text_chunks = [script[i:i+max_chars] for i in range(0, len(script), max_chars)]
-            
-            # Create temporary files for each chunk
-            temp_files = []
-            for i, chunk in enumerate(text_chunks):
-                temp_path = self.temp_dir / f"voice_chunk_{i}.mp3"
-                tts = gTTS(text=chunk, lang='en', slow=False)
-                tts.save(str(temp_path))
-                temp_files.append(temp_path)
-            
-            # Concatenate audio files if there are multiple chunks
-            if len(temp_files) > 1:
-                clips = [AudioFileClip(str(f)) for f in temp_files]
-                final_clip = concatenate_audioclips(clips)
-                final_clip.write_audiofile(str(audio_path), codec='mp3')
-                final_clip.close()
-                for clip in clips:
-                    clip.close()
-            else:
-                # Just rename the single chunk file
-                os.rename(temp_files[0], audio_path)
-            
-            # Clean up temporary files
-            for temp_file in temp_files:
-                if temp_file.exists():
-                    temp_file.unlink()
-            
-            # Verify the audio file
-            if not audio_path.exists() or audio_path.stat().st_size == 0:
-                raise Exception("Audio file generation failed")
-                
+            tts = gTTS(text=script, lang='en', slow=False)
+            tts.save(str(audio_path))
             return AudioFileClip(str(audio_path))
-            
         except Exception as e:
-            logging.error(f"Audio generation failed: {str(e)}")
-            # Create a silent audio clip as last resort
-            silence_duration = len(script.split()) / 3  # Approximate duration based on words
-            return AudioFileClip(duration=silence_duration)
+            print(f"Fallback audio generation failed: {e}")
+            # Create silent audio clip
+            return AudioFileClip(str(audio_path)) if os.path.exists(str(audio_path)) else None
     
     def apply_video_effects(self, frame: np.ndarray, effect_params: dict) -> np.ndarray:
         """Apply various video effects to a frame"""
@@ -955,60 +887,152 @@ class EnhancedVideoGenerator:
         msecs = int((seconds - int(seconds)) * 1000)
         return f"{hours:02d}:{minutes:02d}:{secs:02d},{msecs:03d}"
 
-    def create_video(self, images, audio_file, duration, output_path):
-        """Creates a video from images and audio."""
+    def create_video(self, script: str, style: str, duration: int, output_path: str, selected_images: List[str], 
+                    video_effects: dict = None, progress_callback: Callable[[float], None] = None) -> str:
+        """Create video with selected images and effects"""
         try:
-            if not images or not audio_file:
-                raise ValueError("Both images and audio are required.")
-
-            # Load and adjust the audio file
-            audio = AudioFileClip(audio_file)
-            audio = audio.subclip(0, min(duration, audio.duration))  # Adjust duration if needed
-
-            # Create video clips from images
-            video_clips = []
-            for img_path in images:
-                img = Image.open(img_path)
-                clip = ImageClip(img).set_duration(duration / len(images))
-                video_clips.append(clip)
-
-            # Combine all clips and set audio
-            final_clip = concatenate_videoclips(video_clips)
-            final_clip = final_clip.set_audio(audio)
-
-            # Write to output file
-            final_clip.write_videofile(output_path, fps=24, codec="libx264")
+            # Initialize default effects if none provided
+            if video_effects is None:
+                video_effects = {
+                    'zoom': 1.0,
+                    'brightness': 1.0,
+                    'contrast': 1.0,
+                    'blur': False
+                }
+            
+            # Process images with error handling
+            processed_images = []
+            total_images = len(selected_images)
+            
+            for idx, img_url in enumerate(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.LANCZOS)
+                    processed_images.append(img)
+                    
+                    # Update progress (20% of total progress is for image processing)
+                    if progress_callback:
+                        progress = (idx + 1) / total_images * 20
+                        progress_callback(progress)
+                        
+                except Exception as e:
+                    self.logger.error(f"Error processing image {img_url}: {e}")
+                    continue
+    
+            if not processed_images:
+                raise ValueError("No valid images to process")
+    
+            # Generate voice-over
+            audio = self.generate_fallback_audio(script)
+            if progress_callback:
+                progress_callback(30)  # 30% progress after audio generation
+    
+            # Calculate frames
+            fps = 30
+            total_frames = int(duration * fps)
+            frames_per_image = total_frames // len(processed_images)
+    
+            # Create frames with effects
+            frames = []
+            frame_count = 0
+            
+            # Apply zoom effect over time
+            zoom_range = np.linspace(1.0, video_effects['zoom'], frames_per_image)
+    
+            for idx, img in enumerate(processed_images):
+                img_array = np.array(img)
+                
+                # Calculate frames for this image
+                if idx == len(processed_images) - 1:
+                    n_frames = total_frames - frame_count
+                else:
+                    n_frames = min(frames_per_image, total_frames - frame_count)
+    
+                # Generate frames with effects
+                for frame_idx in range(n_frames):
+                    current_effects = video_effects.copy()
+                    
+                    # Update zoom factor
+                    if video_effects['zoom'] != 1.0:
+                        current_effects['zoom'] = zoom_range[min(frame_idx, len(zoom_range)-1)]
+                    
+                    # Apply effects to frame
+                    frame = self.apply_video_effects(img_array.copy(), current_effects)
+                    frames.append(frame)
+                    frame_count += 1
+                    
+                    # Update progress (30% to 70% is for frame generation)
+                    if progress_callback and frame_count % 30 == 0:
+                        progress = 30 + (frame_count / total_frames * 40)
+                        progress_callback(progress)
+    
+                # Add transition to next image if enabled
+                if idx < len(processed_images) - 1 and video_effects.get('transition_style') != 'None':
+                    next_img_array = np.array(processed_images[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
+    
+            # Create video clip
+            clip = ImageSequenceClip(frames, fps=fps)
+            if progress_callback:
+                progress_callback(80)  # 80% progress after creating clip
+    
+            # Adjust audio duration
+            if audio.duration > clip.duration:
+                audio = audio.subclip(0, clip.duration)
+            elif audio.duration < clip.duration:
+                clip = clip.subclip(0, audio.duration)
+    
+            # Combine video and audio
+            final_clip = clip.set_audio(audio)
+            if progress_callback:
+                progress_callback(90)  # 90% progress after combining audio
+    
+            # Ensure output directory exists
+            os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    
+            # Write video file
+            final_clip.write_videofile(
+                output_path,
+                fps=fps,
+                codec='libx264',
+                audio_codec='aac',
+                ffmpeg_params=['-pix_fmt', 'yuv420p'],
+                verbose=False,
+                logger=None
+            )
+            
+            if progress_callback:
+                progress_callback(100)  # 100% progress after writing file
+    
             return output_path
+    
         except Exception as e:
-            raise RuntimeError(f"Error generating video: {str(e)}")
-
-# Streamlit interface
-st.title("Enhanced Video Generator")
-
-# Upload files
-images = st.file_uploader("Upload Images", type=["jpg", "png"], accept_multiple_files=True)
-audio_file = st.file_uploader("Upload Audio", type=["mp3", "wav"])
-duration = st.number_input("Video Duration (seconds)", min_value=10, max_value=300, value=30)
-output_path = "output_video.mp4"
-
-# Generate video button
-if st.button("Generate Video"):
-    if not images or not audio_file:
-        st.error("Please upload both images and audio.")
-    else:
-        try:
-            generator = EnhancedVideoGenerator()
-            image_paths = [img.name for img in images]
-            for img in images:
-                with open(img.name, "wb") as f:
-                    f.write(img.getbuffer())
-
-            # Generate video
-            output = generator.create_video(image_paths, audio_file.name, duration, output_path)
-            st.success(f"Video generated: {output}")
-            st.video(output)
-        except Exception as e:
-            st.error(f"Error: {e}")
+            self.logger.error(f"Video creation failed: {str(e)}")
+            raise
+        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:
+                self.logger.error(f"Cleanup error: {e}")