Update app.py

app.py

@@ -1273,6 +1273,302 @@ class VideoGeneratorUI:
                 st.error(f"Error generating video: {str(e)}")
                 print(f"Video generation error: {str(e)}")  # For debugging
     
+class VideoGenerator:
+    def __init__(self):
+        self.temp_dir = Path(tempfile.mkdtemp())
+        self.setup_resources()
+
+    def setup_resources(self):
+        # Initialize font
+        try:
+            font_options = [
+                "arial.ttf",
+                "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+                "/System/Library/Fonts/Helvetica.ttc"
+            ]
+            for font_path in font_options:
+                try:
+                    self.font = ImageFont.truetype(font_path, 40)
+                    break
+                except OSError:
+                    continue
+            else:
+                self.font = ImageFont.load_default()
+        except Exception as e:
+            print(f"Font loading error: {e}")
+            self.font = ImageFont.load_default()
+
+    def create_video_frame(self, image, text, frame_number, total_frames, size=(1920, 1080)):
+        try:
+            # Resize and pad image to maintain aspect ratio
+            img_aspect = image.size[0] / image.size[1]
+            target_aspect = size[0] / size[1]
+            
+            if img_aspect > target_aspect:
+                new_height = size[1]
+                new_width = int(new_height * img_aspect)
+            else:
+                new_width = size[0]
+                new_height = int(new_width / img_aspect)
+                
+            image = image.resize((new_width, new_height), Image.LANCZOS)
+            
+            # Create new background
+            frame = Image.new('RGB', size, (0, 0, 0))
+            
+            # Paste resized image in center
+            paste_x = (size[0] - new_width) // 2
+            paste_y = (size[1] - new_height) // 2
+            frame.paste(image, (paste_x, paste_y))
+            
+            # Add text overlay
+            draw = ImageDraw.Draw(frame)
+            
+            # Text background
+            text = textwrap.fill(text, width=50)
+            text_bbox = draw.textbbox((0, 0), text, font=self.font)
+            text_width = text_bbox[2] - text_bbox[0]
+            text_height = text_bbox[3] - text_bbox[1]
+            
+            text_x = (size[0] - text_width) // 2
+            text_y = size[1] - text_height - 100
+            
+            # Semi-transparent background
+            padding = 20
+            draw.rectangle(
+                [
+                    text_x - padding,
+                    text_y - padding,
+                    text_x + text_width + padding,
+                    text_y + text_height + padding
+                ],
+                fill=(0, 0, 0, 180)
+            )
+            
+            # Draw text
+            draw.text((text_x, text_y), text, fill=(255, 255, 255), font=self.font)
+            
+            # Add progress bar
+            self.draw_progress_bar(draw, frame_number, total_frames, size)
+            
+            return np.array(frame)
+            
+        except Exception as e:
+            print(f"Frame creation error: {e}")
+            return np.zeros((*size, 3), dtype=np.uint8)
+
+    def draw_progress_bar(self, draw, frame_number, total_frames, size):
+        progress = frame_number / total_frames
+        bar_width = int(size[0] * 0.8)
+        bar_height = 6
+        x_offset = (size[0] - bar_width) // 2
+        y_position = size[1] - 40
+        
+        # Background bar
+        draw.rectangle(
+            [x_offset, y_position, x_offset + bar_width, y_position + bar_height],
+            fill=(100, 100, 100, 160)
+        )
+        
+        # Progress bar
+        progress_width = int(bar_width * progress)
+        draw.rectangle(
+            [x_offset, y_position, x_offset + progress_width, y_position + bar_height],
+            fill=(255, 255, 255, 200)
+        )
+
+    def generate_video(self, script: str, images: List[str], duration: int, output_path: str) -> str:
+        try:
+            # Create temporary directory for processing
+            os.makedirs(os.path.dirname(output_path), exist_ok=True)
+            
+            # Process images
+            processed_images = []
+            for img_url in images:
+                try:
+                    response = requests.get(img_url)
+                    img = Image.open(BytesIO(response.content)).convert('RGB')
+                    processed_images.append(img)
+                except Exception as e:
+                    print(f"Image processing error: {e}")
+                    continue
+            
+            if not processed_images:
+                raise ValueError("No valid images to process")
+            
+            # Generate frames
+            fps = 30
+            total_frames = duration * fps
+            frames_per_image = total_frames // len(processed_images)
+            
+            # Split script into sections
+            words = script.split()
+            words_per_image = len(words) // len(processed_images)
+            
+            frames = []
+            frame_count = 0
+            
+            # Generate video frames
+            for idx, img in enumerate(processed_images):
+                # Get text section for this image
+                start_idx = idx * words_per_image
+                end_idx = start_idx + words_per_image if idx < len(processed_images) - 1 else len(words)
+                section_text = ' '.join(words[start_idx:end_idx])
+                
+                # Generate frames for this section
+                for frame in range(frames_per_image):
+                    if frame_count < total_frames:
+                        frame_img = self.create_video_frame(
+                            img, 
+                            section_text,
+                            frame_count,
+                            total_frames
+                        )
+                        frames.append(frame_img)
+                        frame_count += 1
+                        
+                # Add transition frames
+                if idx < len(processed_images) - 1:
+                    next_img = processed_images[idx + 1]
+                    for t in range(15):  # 15 frame transition
+                        if frame_count < total_frames:
+                            alpha = t / 15
+                            transition_frame = Image.blend(
+                                img,
+                                next_img,
+                                alpha
+                            )
+                            frame_img = self.create_video_frame(
+                                transition_frame,
+                                section_text,
+                                frame_count,
+                                total_frames
+                            )
+                            frames.append(frame_img)
+                            frame_count += 1
+            
+            # Generate audio
+            audio_path = self.temp_dir / "audio.mp3"
+            tts = gTTS(text=script, lang='en')
+            tts.save(str(audio_path))
+            
+            # Create video
+            clip = ImageSequenceClip(frames, fps=fps)
+            audio_clip = AudioFileClip(str(audio_path))
+            
+            # Adjust video length to match audio
+            if audio_clip.duration < clip.duration:
+                clip = clip.subclip(0, audio_clip.duration)
+            else:
+                audio_clip = audio_clip.subclip(0, clip.duration)
+            
+            final_clip = clip.set_audio(audio_clip)
+            
+            # Write video
+            final_clip.write_videofile(
+                output_path,
+                fps=fps,
+                codec='libx264',
+                audio_codec='aac',
+                ffmpeg_params=['-pix_fmt', 'yuv420p']
+            )
+            
+            return output_path
+            
+        except Exception as e:
+            print(f"Video generation error: {e}")
+            raise
+        finally:
+            # Cleanup
+            try:
+                if 'clip' in locals():
+                    clip.close()
+                if 'final_clip' in locals():
+                    final_clip.close()
+                if 'audio_clip' in locals():
+                    audio_clip.close()
+            except Exception as e:
+                print(f"Cleanup error: {e}")
+
+    def cleanup(self):
+        try:
+            import shutil
+            shutil.rmtree(self.temp_dir)
+        except Exception as e:
+            print(f"Cleanup error: {e}")
+
+def create_ui():
+    st.title("VaultGenix Video Generator")
+    st.markdown("Create professional videos for your digital legacy management platform")
+    
+    # File upload section
+    st.subheader("Upload Content")
+    uploaded_file = st.file_uploader(
+        "Upload your content (PDF, DOCX, PPTX, or TXT)",
+        type=['pdf', 'docx', 'pptx', 'txt']
+    )
+    
+    # Text input section
+    script = ""
+    if uploaded_file:
+        try:
+            file_processor = FileProcessor()
+            if uploaded_file.type == "text/plain":
+                script = file_processor.read_txt(uploaded_file)
+            elif uploaded_file.type == "application/pdf":
+                script = file_processor.read_pdf(uploaded_file)
+            elif uploaded_file.type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+                script = file_processor.read_docx(uploaded_file)
+            elif uploaded_file.type == "application/vnd.openxmlformats-officedocument.presentationml.presentation":
+                script = file_processor.read_pptx(uploaded_file)
+        except Exception as e:
+            st.error(f"Error processing file: {str(e)}")
+    
+    script = st.text_area("Enter or edit your video script", value=script, height=200)
+    
+    if st.button("Generate Video") and script:
+        try:
+            # Initialize video generator
+            generator = VideoGenerator()
+            
+            # Get stock images (replace with your image selection logic)
+            images = [
+                "https://images.pexels.com/photos/60504/security-protection-anti-virus-software-60504.jpeg",
+                "https://images.pexels.com/photos/5380642/pexels-photo-5380642.jpeg",
+                "https://images.pexels.com/photos/2582937/pexels-photo-2582937.jpeg"
+            ]
+            
+            # Generate video
+            output_path = "output_video.mp4"
+            with st.spinner("Generating video..."):
+                video_path = generator.generate_video(script, images, 30, output_path)
+            
+            # Display video
+            if os.path.exists(video_path):
+                st.success("Video generated successfully!")
+                with open(video_path, 'rb') as video_file:
+                    video_bytes = video_file.read()
+                    st.video(video_bytes)
+                    
+                    # Download button
+                    st.download_button(
+                        label="Download Video",
+                        data=video_bytes,
+                        file_name="vaultgenix_video.mp4",
+                        mime="video/mp4"
+                    )
+            
+        except Exception as e:
+            st.error(f"Error generating video: {str(e)}")
+            print(f"Error details: {str(e)}")
+
+if __name__ == "__main__":
+    create_ui()
+    
+    
+    
+    
+    
     def generate_video(self, prompt: str, style: str, duration: int, selected_images: List[str]):
         """Handle video generation with improved error handling"""
         if not selected_images: