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 *
+from moviepy.editor import AudioFileClip, concatenate_videoclips, ImageClip
 import numpy as np
 from gtts import gTTS
 import textwrap
@@ -955,152 +955,60 @@ 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], 
-                    video_effects: dict = None, progress_callback: Callable[[float], None] = None) -> str:
-        """Create video with selected images and effects"""
+    def create_video(self, images, audio_file, duration, output_path):
+        """Creates a video from images and audio."""
         try:
-            # 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
-    
+            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")
             return output_path
-    
         except Exception as 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}")
+            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}")