app.py

import gradio as gr
import os
import tempfile
import shutil
import random
import requests
from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, ImageClip, TextClip
import numpy as np
from gtts import gTTS
import cv2

# Global configurations
PEXELS_API_KEY = 'BhJqbcdm9Vi90KqzXKAhnEHGsuFNv4irXuOjWtT761U49lRzo03qBGna'  # Replace with your Pexels API key
OUTPUT_VIDEO_FILENAME = "final_video.mp4"
USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
MAX_CLIPS = 10
TARGET_RESOLUTION = (1920, 1080)  # Default resolution
TEMP_FOLDER = None
CAPTION_COLOR = "#FFFFFF"

# Helper Functions
def generate_script(topic):
    """Generate a simple script based on the topic."""
    return f"[Title]\n{topic}\n[Narration]\nThis is a sample narration about {topic}."

def parse_script(script):
    """Parse the script into elements."""
    elements = []
    lines = script.strip().split('\n')
    for line in lines:
        if line.startswith('[Title]'):
            elements.append({'type': 'media', 'prompt': line[7:].strip()})
        elif line.startswith('[Narration]'):
            elements.append({'type': 'tts', 'text': line[11:].strip()})
    return elements

def search_pexels_videos(query, api_key):
    """Search for videos on Pexels."""
    url = f"https://api.pexels.com/videos/search?query={quote(query)}&per_page=1"
    headers = {"Authorization": api_key}
    response = requests.get(url, headers=headers)
    if response.status_code == 200:
        data = response.json()
        if data['videos']:
            return data['videos'][0]['video_files'][0]['link']
    return None

def download_video(url, output_path):
    """Download a video from a URL."""
    response = requests.get(url, headers={"User-Agent": USER_AGENT}, stream=True)
    if response.status_code == 200:
        with open(output_path, 'wb') as f:
            shutil.copyfileobj(response.raw, f)
        return output_path
    return None

def generate_tts(text, lang='en'):
    """Generate TTS audio using gTTS."""
    tts = gTTS(text=text, lang=lang, slow=False)
    tts_path = os.path.join(TEMP_FOLDER, f"tts_{random.randint(0, 10000)}.mp3")
    tts.save(tts_path)
    return tts_path

def resize_media(media_path, target_resolution):
    """Resize media to match target resolution."""
    clip = VideoFileClip(media_path) if media_path.endswith(('.mp4', '.avi', '.mov')) else ImageClip(media_path)
    return clip.resize(target_resolution)

def apply_kenburns_effect(clip, target_resolution):
    """Apply a zoom/pan (Ken Burns) effect to an image clip."""
    w, h = target_resolution
    clip = clip.resize(height=h * 1.2).crop(x_center=w/2, y_center=h/2, width=w, height=h)
    return clip.fx(vfx.zoom_in, 0.1)

def create_clip(media_path, asset_type, tts_path, duration, effects, narration_text, segment_index):
    """Create a video clip with media and narration."""
    if asset_type == 'video':
        clip = VideoFileClip(media_path).subclip(0, min(duration, VideoFileClip(media_path).duration))
    else:
        clip = ImageClip(media_path, duration=duration)
    
    clip = resize_media(media_path, TARGET_RESOLUTION)
    if effects == 'fade-in':
        clip = clip.crossfadein(1.0)
    
    audio = AudioFileClip(tts_path)
    clip = clip.set_audio(audio.set_duration(duration))
    
    if CAPTION_COLOR != "transparent":
        txt_clip = TextClip(narration_text, fontsize=45, color=CAPTION_COLOR, font="Arial", stroke_color="#000000", stroke_width=2)
        txt_clip = txt_clip.set_position('bottom').set_duration(duration)
        clip = CompositeVideoClip([clip, txt_clip])
    
    return clip

def generate_media(prompt, current_index, total_segments):
    """Generate media (placeholder for actual generation)."""
    media_path = os.path.join(TEMP_FOLDER, f"media_{current_index}.jpg")
    with open(media_path, 'wb') as f:
        f.write(requests.get("https://via.placeholder.com/1920x1080").content)  # Placeholder image
    return {'path': media_path, 'asset_type': 'image'}

def process_script(topic, script_input):
    """Process the topic or script and return updates for the UI."""
    if script_input.strip():
        raw_script = script_input
    else:
        raw_script = generate_script(topic)
        if not raw_script:
            return "Failed to generate script", 0, [], [], [], []

    elements = parse_script(raw_script)
    paired_elements = [(elements[i], elements[i + 1]) for i in range(0, len(elements) - 1, 2)]
    num_clips = min(len(paired_elements), MAX_CLIPS)

    accordion_updates = []
    prompt_updates = []
    narration_updates = []
    media_updates = []
    for i in range(MAX_CLIPS):
        if i < num_clips:
            media_elem, tts_elem = paired_elements[i]
            accordion_updates.append(gr.update(visible=True, label=f"Clip {i+1}: {media_elem['prompt'][:20]}..."))
            prompt_updates.append(gr.update(value=media_elem['prompt']))
            narration_updates.append(gr.update(value=tts_elem['text']))
            media_updates.append(gr.update(value=None))
        else:
            accordion_updates.append(gr.update(visible=False))
            prompt_updates.append(gr.update(value=""))
            narration_updates.append(gr.update(value=""))
            media_updates.append(gr.update(value=None))

    return raw_script, num_clips, accordion_updates, prompt_updates, narration_updates, media_updates

def generate_video_full(resolution, render_speed, video_clip_percent, zoom_pan_effect, 
                        bgm_upload, bgm_volume, subtitles_enabled, num_clips, *clip_inputs):
    """Generate the video using all settings and edited clip data."""
    global TARGET_RESOLUTION, CAPTION_COLOR, TEMP_FOLDER
    
    TARGET_RESOLUTION = (1080, 1920) if resolution == "Short (1080x1920)" else (1920, 1080)
    CAPTION_COLOR = "#FFFFFF" if subtitles_enabled else "transparent"
    TEMP_FOLDER = tempfile.mkdtemp()
    
    clips_data = []
    for i in range(num_clips):
        idx = i * 3
        clips_data.append({
            'visual_prompt': clip_inputs[idx],
            'narration': clip_inputs[idx + 1],
            'custom_media': clip_inputs[idx + 2]
        })

    clips = []
    for idx, clip_data in enumerate(clips_data):
        if clip_data['custom_media']:
            media_path = clip_data['custom_media']
            asset_type = 'video' if media_path.endswith(('.mp4', '.avi', '.mov')) else 'image'
        else:
            media_asset = generate_media(clip_data['visual_prompt'], idx, num_clips)
            media_path = media_asset['path']
            asset_type = media_asset['asset_type']
            if random.random() < (video_clip_percent / 100):
                video_url = search_pexels_videos(clip_data['visual_prompt'], PEXELS_API_KEY)
                if video_url:
                    media_path = download_video(video_url, os.path.join(TEMP_FOLDER, f"video_{idx}.mp4"))
                    asset_type = 'video'

        tts_path = generate_tts(clip_data['narration'])
        duration = max(3, len(clip_data['narration'].split()) * 0.5)
        clip = create_clip(media_path, asset_type, tts_path, duration, 'fade-in', clip_data['narration'], idx)
        if clip and zoom_pan_effect and asset_type == 'image':
            clip = apply_kenburns_effect(clip, TARGET_RESOLUTION)
        if clip:
            clips.append(clip)

    if not clips:
        shutil.rmtree(TEMP_FOLDER)
        return None, None

    final_video = concatenate_videoclips(clips, method="compose")
    
    if bgm_upload:
        bg_music = AudioFileClip(bgm_upload).volumex(bgm_volume)
        if bg_music.duration < final_video.duration:
            bg_music = bg_music.loop(duration=final_video.duration)
        else:
            bg_music = bg_music.subclip(0, final_video.duration)
        final_video = final_video.set_audio(CompositeVideoClip([final_video.audio, bg_music]))

    output_path = OUTPUT_VIDEO_FILENAME
    final_video.write_videofile(output_path, codec='libx264', fps=24, preset=render_speed)
    shutil.rmtree(TEMP_FOLDER)

    return output_path, output_path

# Gradio Interface
with gr.Blocks(title="Video Generator") as demo:
    gr.Markdown("# Video Generator")
    gr.Markdown("Create custom videos with script, clips, and settings!")
    
    with gr.Row():
        # Column 1: Content Input & Script Generation
        with gr.Column(scale=1):
            gr.Markdown("### 1. Content Input")
            topic_input = gr.Textbox(label="Topic", placeholder="e.g., Funny Cat Facts")
            script_input = gr.Textbox(label="Or Paste Full Script", lines=10, placeholder="[Title]\nNarration...")
            generate_button = gr.Button("Generate Script & Load Clips")
            script_display = gr.Textbox(label="Generated Script", interactive=False, visible=False)
        
        # Column 2: Clip Editor
        with gr.Column(scale=2):
            gr.Markdown("### 2. Edit Clips")
            with gr.Column():
                clip_accordions = []
                for i in range(MAX_CLIPS):
                    with gr.Accordion(f"Clip {i+1}", visible=False) as acc:
                        visual_prompt = gr.Textbox(label="Visual Prompt")
                        narration = gr.Textbox(label="Narration", lines=3)
                        custom_media = gr.File(label="Upload Custom Media")
                        clip_accordions.append((acc, visual_prompt, narration, custom_media))
        
        # Column 3: Settings & Output
        with gr.Column(scale=1):
            gr.Markdown("### 3. Video Settings")
            resolution = gr.Radio(["Short (1080x1920)", "Full HD (1920x1080)"], label="Resolution", value="Full HD (1920x1080)")
            render_speed = gr.Dropdown(["ultrafast", "fast", "medium", "slow"], label="Render Speed", value="fast")
            video_clip_percent = gr.Slider(0, 100, value=25, label="Video Clip Percentage")
            zoom_pan_effect = gr.Checkbox(label="Add Zoom/Pan Effect", value=True)
            bgm_upload = gr.Audio(label="Upload Background Music", type="filepath")
            bgm_volume = gr.Slider(0.0, 1.0, value=0.15, label="BGM Volume")
            subtitles_enabled = gr.Checkbox(label="Enable Subtitles", value=True)
            generate_video_button = gr.Button("Generate Video")
            gr.Markdown("### 4. Output")
            output_video = gr.Video(label="Generated Video")
            download_button = gr.File(label="Download Video")

    num_clips_state = gr.State(value=0)

    generate_button.click(
        fn=process_script,
        inputs=[topic_input, script_input],
        outputs=[script_display, num_clips_state] + 
                [comp for acc in clip_accordions for comp in [acc[0], acc[1], acc[2], acc[3]]]
    ).then(
        fn=lambda x: gr.update(visible=True),
        inputs=[script_display],
        outputs=[script_display]
    )

    generate_video_button.click(
        fn=generate_video_full,
        inputs=[resolution, render_speed, video_clip_percent, zoom_pan_effect, 
                bgm_upload, bgm_volume, subtitles_enabled, num_clips_state] + 
               [comp for acc in clip_accordions for comp in acc[1:]],
        outputs=[output_video, download_button]
    )

demo.launch()