Update app.py

app.py

@@ -889,123 +889,86 @@ 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, 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 enhanced error handling and progress tracking"""
         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
-                }
+            if not selected_images:
+                raise ValueError("No images provided for video generation")
+
+            # Initialize moviepy
+            import moviepy.editor as mpy
+            from moviepy.editor import ImageSequenceClip, AudioFileClip
             
-            # Process images with error handling
+            # Process images
             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)
+                    img = img.convert('RGB').resize((1920, 1080), Image.LANCZOS)
+                    processed_images.append(np.array(img))
                     
-                    # Update progress (20% of total progress is for image processing)
                     if progress_callback:
-                        progress = (idx + 1) / total_images * 20
-                        progress_callback(progress)
-                        
+                        progress_callback((idx + 1) / len(selected_images) * 20)
                 except Exception as e:
-                    self.logger.error(f"Error processing image {img_url}: {e}")
+                    logging.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)
+                raise ValueError("Failed to process any images")
+
+            # Generate audio
             if progress_callback:
-                progress_callback(30)  # 30% progress after audio generation
-    
-            # Calculate frames
+                progress_callback(25)
+            audio = self.generate_voice_over(script)
+            
+            # Calculate video parameters
             fps = 30
-            total_frames = int(duration * fps)
-            frames_per_image = total_frames // len(processed_images)
-    
-            # Create frames with effects
-            frames = []
-            frame_count = 0
+            total_duration = duration
+            frames_per_image = int(fps * total_duration / len(processed_images))
             
-            # 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)
+            # Generate frames with effects
+            frames = []
+            for img_array in processed_images:
+                for _ in range(frames_per_image):
+                    if video_effects and video_effects.get('zoom'):
+                        # Apply zoom effect
+                        zoom = video_effects['zoom']
+                        h, w = img_array.shape[:2]
+                        scaled_h, scaled_w = int(h * zoom), int(w * zoom)
+                        img = Image.fromarray(img_array).resize((scaled_w, scaled_h), Image.LANCZOS)
+                        # Crop to original size from center
+                        left = (scaled_w - w) // 2
+                        top = (scaled_h - h) // 2
+                        img = img.crop((left, top, left + w, top + h))
+                        frames.append(np.array(img))
+                    else:
+                        frames.append(img_array)
+
             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)
-    
+                progress_callback(60)
+
+            # Create video clip
+            video_clip = ImageSequenceClip(frames, fps=fps)
+            
+            # Adjust audio duration if needed
+            if audio.duration > video_clip.duration:
+                audio = audio.subclip(0, video_clip.duration)
+            elif audio.duration < video_clip.duration:
+                video_clip = video_clip.subclip(0, audio.duration)
+
             # Combine video and audio
-            final_clip = clip.set_audio(audio)
+            final_clip = video_clip.set_audio(audio)
+            
             if progress_callback:
-                progress_callback(90)  # 90% progress after combining audio
-    
+                progress_callback(80)
+
             # Ensure output directory exists
             os.makedirs(os.path.dirname(output_path), exist_ok=True)
-    
-            # Write video file
+
+            # Write final video
             final_clip.write_videofile(
                 output_path,
                 fps=fps,
@@ -1015,26 +978,26 @@ class EnhancedVideoGenerator:
                 verbose=False,
                 logger=None
             )
-            
+
             if progress_callback:
-                progress_callback(100)  # 100% progress after writing file
-    
+                progress_callback(100)
+
             return output_path
-    
+
         except Exception as e:
-            self.logger.error(f"Video creation failed: {str(e)}")
+            logging.error(f"Video creation failed: {str(e)}")
             raise
         finally:
             # Cleanup
             try:
-                if 'clip' in locals():
-                    clip.close()
+                if 'video_clip' in locals():
+                    video_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}")
+                logging.error(f"Cleanup error: {e}")