Update app.py

app.py

@@ -1,77 +1,92 @@
-# Import necessary libraries
-import os
-import re
-import random
-import math
-import shutil
-import tempfile
-import requests
-from urllib.parse import quote
-from bs4 import BeautifulSoup
-import numpy as np
-from PIL import Image
-import cv2
-from pydub import AudioSegment
-from gtts import gTTS
-import gradio as gr
+"""
+Full Code: Orbit Video Engine with Advanced Gradio UI
+
+This script combines the video-generation code (using Kokoro for TTS,
+MoviePy for video operations, Pexels/Google image/video search, etc.) with a
+Gradio Blocks UI that allows:
+  1. Content input and script generation.
+  2. Dynamic clip editing (change prompt, narration, or upload custom media).
+  3. Video settings (resolution, render speed, background music, subtitle settings).
+  4. Final video generation and preview/download.
+"""
+
+# --------- IMPORTS ---------
+from kokoro import KPipeline
+
 import soundfile as sf
-from moviepy.editor import (
-    VideoFileClip, concatenate_videoclips, AudioFileClip, ImageClip,
-    CompositeVideoClip, TextClip, CompositeAudioClip
-)
+import torch
+import os, time, random, math, json, tempfile, shutil, re, requests
+from moviepy.editor import VideoFileClip, AudioFileClip, ImageClip, concatenate_videoclips, CompositeVideoClip, TextClip, CompositeAudioClip
 import moviepy.video.fx.all as vfx
 import moviepy.config as mpy_config
+from pydub import AudioSegment
+from pydub.generators import Sine
+from PIL import Image, ImageDraw, ImageFont
+import numpy as np
+from bs4 import BeautifulSoup
+from urllib.parse import quote
+import pysrt
+from gtts import gTTS
+import cv2
+import gradio as gr
 
-# Initialize Kokoro TTS pipeline (assuming it's available; replace with dummy if not)
-try:
-    from kokoro import KPipeline
-    pipeline = KPipeline(lang_code='a')
-except ImportError:
-    pipeline = None  # Fallback to gTTS if Kokoro is unavailable
-
-# Ensure ImageMagick binary is set (adjust path as needed for your system)
+# --------- GLOBAL CONFIGURATION ---------
+pipeline = KPipeline(lang_code='a')  # Use American English voice. (Uses 'af_heart' for American English)
 mpy_config.change_settings({"IMAGEMAGICK_BINARY": "/usr/bin/convert"})
 
-# Global Configuration
 PEXELS_API_KEY = 'BhJqbcdm9Vi90KqzXKAhnEHGsuFNv4irXuOjWtT761U49lRzo03qBGna'
 OPENROUTER_API_KEY = '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'
 OPENROUTER_MODEL = "mistralai/mistral-small-3.1-24b-instruct:free"
 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  # Maximum number of editable clips
-
-# Temporary folder setup
-TEMP_FOLDER = tempfile.mkdtemp()
 
-# Helper Functions
+# These globals are later set per run
+TARGET_RESOLUTION = None
+CAPTION_COLOR = None
+TEMP_FOLDER = None
 
-## Script Generation
+# --------- HELPER FUNCTIONS ---------
 def generate_script(user_input):
+    """Generate documentary script using OpenRouter API."""
     headers = {
         'Authorization': f'Bearer {OPENROUTER_API_KEY}',
         'HTTP-Referer': 'https://your-domain.com',
         'X-Title': 'AI Documentary Maker'
     }
     prompt = f"""Short Documentary Script GeneratorInstructions:
+
 If I say "use this," just output the script exactly as I gave it.
 If I only give topics, generate a script based on them.
 If I provide a full script, rewrite it without any changes. Make everything short simple and humarous funny and act as serious but humarous. And don't say anything off topic. Also alway say a funny statement to subscribe based on the video topic at the end. Use normal conversational text like a normal person talking and avoid AI phase make the statements humanize and normal conversational
 And always talk negative views don't really wants any positive statement and the full script will be one video about one topic so keep in mind
 Formatting Rules:
+
 Title in Square Brackets:
+
 Each section starts with a one-word title inside [ ] (max two words if necessary).
 This title will be used as a search term for Pexels footage.
+
 Casual & Funny Narration:
+
 Each section has 5-10 words of narration.
 Keep it natural, funny, and unpredictable (not robotic, poetic, or rhythmic).
+
 No Special Formatting:
+
 No bold, italics, or special characters. You are a assistant AI your task is to create script. You aren't a chatbot. So, don't write extra text
+
 Generalized Search Terms:
+
 If a term is too specific, make it more general for Pexels search.
+
 Scene-Specific Writing:
+
 Each section describes only what should be shown in the video.
-Output Only the Script, and also make it funny and humarous and helirous and also add to subscribe with a funny statement like subscribe now or .....
+
+Output Only the Script, and also make it funny and humarous and helirous and also add to subscribe with a funny statement like subscribe now or ..... 
+
 No extra text, just the script.
+
 Example Output:
 [North Korea]
 Top 5 unknown facts about North Korea.
@@ -101,333 +116,704 @@ Now here is the Topic/scrip: {user_input}
             timeout=30
         )
         if response.status_code == 200:
-            return response.json()['choices'][0]['message']['content']
+            response_data = response.json()
+            if 'choices' in response_data and len(response_data['choices']) > 0:
+                return response_data['choices'][0]['message']['content']
+            else:
+                print("Unexpected response format:", response_data)
+                return None
         else:
             print(f"API Error {response.status_code}: {response.text}")
-            return "Failed to generate script due to API error."
+            return None
     except Exception as e:
         print(f"Request failed: {str(e)}")
-        return "Oops, script generation broke. Blame the internet!"
+        return None
 
 def parse_script(script_text):
+    """
+    Parse the generated script into a list of clip elements.
+    Each clip consists of a media element (with a 'prompt') and a TTS element with narration.
+    """
     sections = {}
     current_title = None
     current_text = ""
-    for line in script_text.splitlines():
-        line = line.strip()
-        if line.startswith("[") and "]" in line:
-            bracket_start = line.find("[")
-            bracket_end = line.find("]", bracket_start)
-            if bracket_start != -1 and bracket_end != -1:
-                if current_title:
-                    sections[current_title] = current_text.strip()
-                current_title = line[bracket_start+1:bracket_end]
-                current_text = line[bracket_end+1:].strip()
-        elif current_title:
-            current_text += line + " "
-    if current_title:
-        sections[current_title] = current_text.strip()
-    clips = [{"title": title, "narration": narration} for title, narration in sections.items()]
-    return clips
-
-## Media Fetching
-def search_pexels_videos(query, pexels_api_key):
-    headers = {'Authorization': pexels_api_key}
-    url = "https://api.pexels.com/videos/search"
-    params = {"query": query, "per_page": 15}
     try:
-        response = requests.get(url, headers=headers, params=params, timeout=10)
-        if response.status_code == 200:
-            videos = response.json().get("videos", [])
-            hd_videos = [v["video_files"][0]["link"] for v in videos if v["video_files"] and v["video_files"][0]["quality"] == "hd"]
-            return random.choice(hd_videos) if hd_videos else None
-        return None
+        for line in script_text.splitlines():
+            line = line.strip()
+            if line.startswith("[") and "]" in line:
+                bracket_start = line.find("[")
+                bracket_end = line.find("]", bracket_start)
+                if bracket_start != -1 and bracket_end != -1:
+                    if current_title is not None:
+                        sections[current_title] = current_text.strip()
+                    current_title = line[bracket_start+1:bracket_end]
+                    current_text = line[bracket_end+1:].strip()
+            elif current_title:
+                current_text += line + " "
+        if current_title:
+            sections[current_title] = current_text.strip()
+        elements = []
+        for title, narration in sections.items():
+            if not title or not narration:
+                continue
+            media_element = {"type": "media", "prompt": title, "effects": "fade-in"}
+            words = narration.split()
+            duration = max(3, len(words) * 0.5)
+            tts_element = {"type": "tts", "text": narration, "voice": "en", "duration": duration}
+            elements.append(media_element)
+            elements.append(tts_element)
+        return elements
     except Exception as e:
-        print(f"Video search error: {e}")
+        print(f"Error parsing script: {e}")
+        return []
+
+def search_pexels_videos(query, pexels_api_key):
+    """Search for a video on Pexels by query and return a random HD video link."""
+    headers = {'Authorization': pexels_api_key}
+    base_url = "https://api.pexels.com/videos/search"
+    num_pages = 3
+    videos_per_page = 15
+    max_retries = 3
+    retry_delay = 1
+    search_query = query
+    all_videos = []
+    for page in range(1, num_pages + 1):
+        for attempt in range(max_retries):
+            try:
+                params = {"query": search_query, "per_page": videos_per_page, "page": page}
+                response = requests.get(base_url, headers=headers, params=params, timeout=10)
+                if response.status_code == 200:
+                    data = response.json()
+                    videos = data.get("videos", [])
+                    if not videos:
+                        print(f"No videos found on page {page}.")
+                        break
+                    for video in videos:
+                        video_files = video.get("video_files", [])
+                        for file in video_files:
+                            if file.get("quality") == "hd":
+                                all_videos.append(file.get("link"))
+                                break
+                    break
+                elif response.status_code == 429:
+                    print(f"Rate limit hit (attempt {attempt+1}/{max_retries}). Retrying...")
+                    time.sleep(retry_delay)
+                    retry_delay *= 2
+                else:
+                    print(f"Error fetching videos: {response.status_code} {response.text}")
+                    if attempt < max_retries - 1:
+                        time.sleep(retry_delay)
+                        retry_delay *= 2
+                    else:
+                        break
+            except requests.exceptions.RequestException as e:
+                print(f"Request exception: {e}")
+                if attempt < max_retries - 1:
+                    time.sleep(retry_delay)
+                    retry_delay *= 2
+                else:
+                    break
+    if all_videos:
+        random_video = random.choice(all_videos)
+        print(f"Selected random video from {len(all_videos)} HD videos")
+        return random_video
+    else:
+        print("No suitable videos found.")
         return None
 
 def search_pexels_images(query, pexels_api_key):
+    """Search for an image on Pexels by query."""
     headers = {'Authorization': pexels_api_key}
     url = "https://api.pexels.com/v1/search"
     params = {"query": query, "per_page": 5, "orientation": "landscape"}
-    try:
-        response = requests.get(url, headers=headers, params=params, timeout=10)
-        if response.status_code == 200:
-            photos = response.json().get("photos", [])
-            return random.choice(photos)["src"]["original"] if photos else None
-        return None
-    except Exception as e:
-        print(f"Image search error: {e}")
-        return None
+    max_retries = 3
+    retry_delay = 1
+    for attempt in range(max_retries):
+        try:
+            response = requests.get(url, headers=headers, params=params, timeout=10)
+            if response.status_code == 200:
+                data = response.json()
+                photos = data.get("photos", [])
+                if photos:
+                    photo = random.choice(photos[:min(5, len(photos))])
+                    img_url = photo.get("src", {}).get("original")
+                    return img_url
+                else:
+                    print(f"No images found for query: {query}")
+                    return None
+            elif response.status_code == 429:
+                print(f"Rate limit hit (attempt {attempt+1}/{max_retries}). Retrying...")
+                time.sleep(retry_delay)
+                retry_delay *= 2
+            else:
+                print(f"Error fetching images: {response.status_code} {response.text}")
+                if attempt < max_retries - 1:
+                    time.sleep(retry_delay)
+                    retry_delay *= 2
+        except requests.exceptions.RequestException as e:
+            print(f"Request exception: {e}")
+            if attempt < max_retries - 1:
+                time.sleep(retry_delay)
+                retry_delay *= 2
+    print(f"No Pexels images found for query: {query}")
+    return None
 
 def search_google_images(query):
-    search_url = f"https://www.google.com/search?q={quote(query)}&tbm=isch"
-    headers = {"User-Agent": USER_AGENT}
+    """Search for images on Google Images."""
     try:
+        search_url = f"https://www.google.com/search?q={quote(query)}&tbm=isch"
+        headers = {"User-Agent": USER_AGENT}
         response = requests.get(search_url, headers=headers, timeout=10)
         soup = BeautifulSoup(response.text, "html.parser")
-        img_urls = [img["src"] for img in soup.find_all("img") if img.get("src", "").startswith("http") and "gstatic" not in img["src"]]
-        return random.choice(img_urls[:5]) if img_urls else None
+        img_tags = soup.find_all("img")
+        image_urls = []
+        for img in img_tags:
+            src = img.get("src", "")
+            if src.startswith("http") and "gstatic" not in src:
+                image_urls.append(src)
+        if image_urls:
+            return random.choice(image_urls[:5]) if len(image_urls) >= 5 else image_urls[0]
+        else:
+            print(f"No Google Images found for query: {query}")
+            return None
     except Exception as e:
-        print(f"Google Images error: {e}")
+        print(f"Error in Google Images search: {e}")
         return None
 
 def download_image(image_url, filename):
+    """Download an image from a URL to a local file with verification."""
     try:
-        response = requests.get(image_url, headers={"User-Agent": USER_AGENT}, stream=True, timeout=15)
+        headers = {"User-Agent": USER_AGENT}
+        print(f"Downloading image from: {image_url} to {filename}")
+        response = requests.get(image_url, headers=headers, stream=True, timeout=15)
         response.raise_for_status()
         with open(filename, 'wb') as f:
             for chunk in response.iter_content(chunk_size=8192):
                 f.write(chunk)
-        img = Image.open(filename)
-        if img.mode != 'RGB':
-            img = img.convert('RGB')
-            img.save(filename)
-        return filename
+        print(f"Image downloaded to: {filename}")
+        try:
+            img = Image.open(filename)
+            img.verify()
+            img = Image.open(filename)
+            if img.mode != 'RGB':
+                img = img.convert('RGB')
+                img.save(filename)
+            print(f"Image validated and processed: {filename}")
+            return filename
+        except Exception as e_validate:
+            print(f"Downloaded file is not a valid image: {e_validate}")
+            if os.path.exists(filename):
+                os.remove(filename)
+            return None
     except Exception as e:
         print(f"Image download error: {e}")
+        if os.path.exists(filename):
+            os.remove(filename)
         return None
 
 def download_video(video_url, filename):
+    """Download a video from a URL to a local file."""
     try:
         response = requests.get(video_url, stream=True, timeout=30)
         response.raise_for_status()
         with open(filename, 'wb') as f:
             for chunk in response.iter_content(chunk_size=8192):
                 f.write(chunk)
+        print(f"Video downloaded to: {filename}")
         return filename
     except Exception as e:
         print(f"Video download error: {e}")
+        if os.path.exists(filename):
+            os.remove(filename)
         return None
 
-## Media and TTS Generation
-def generate_media(prompt, custom_media=None, video_prob=0.25):
-    if isinstance(custom_media, str) and os.path.exists(custom_media):
-        asset_type = "video" if custom_media.lower().endswith(('.mp4', '.avi', '.mov')) else "image"
-        return {"path": custom_media, "asset_type": asset_type}
+def generate_media(prompt, user_image=None, current_index=0, total_segments=1):
+    """
+    Generate a visual asset for the clip.
+    If user_image is provided (from custom media upload) use it; otherwise,
+    use Pexels (and Google Images for news related queries) with fallbacks.
+    """
     safe_prompt = re.sub(r'[^\w\s-]', '', prompt).strip().replace(' ', '_')
+    if user_image is not None:
+        # Assume user_image is a local path or file-like object.
+        print(f"Using custom media provided for prompt: {prompt}")
+        return {"path": user_image, "asset_type": "image"}
+    
     if "news" in prompt.lower():
+        print(f"News query detected: {prompt}. Using Google Images...")
         image_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}_news.jpg")
         image_url = search_google_images(prompt)
-        if image_url and download_image(image_url, image_file):
-            return {"path": image_file, "asset_type": "image"}
-    if random.random() < video_prob:
+        if image_url:
+            downloaded_image = download_image(image_url, image_file)
+            if downloaded_image:
+                return {"path": downloaded_image, "asset_type": "image"}
+    if random.random() < 0.25:
         video_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}_video.mp4")
         video_url = search_pexels_videos(prompt, PEXELS_API_KEY)
-        if video_url and download_video(video_url, video_file):
-            return {"path": video_file, "asset_type": "video"}
+        if video_url:
+            downloaded_video = download_video(video_url, video_file)
+            if downloaded_video:
+                return {"path": downloaded_video, "asset_type": "video"}
     image_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}.jpg")
     image_url = search_pexels_images(prompt, PEXELS_API_KEY)
-    if image_url and download_image(image_url, image_file):
-        return {"path": image_file, "asset_type": "image"}
-    print(f"No media generated for prompt: {prompt}")
+    if image_url:
+        downloaded_image = download_image(image_url, image_file)
+        if downloaded_image:
+            return {"path": downloaded_image, "asset_type": "image"}
+    fallback_terms = ["nature", "people", "landscape", "technology", "business"]
+    for term in fallback_terms:
+        fallback_file = os.path.join(TEMP_FOLDER, f"fallback_{term}.jpg")
+        fallback_url = search_pexels_images(term, PEXELS_API_KEY)
+        if fallback_url:
+            downloaded_fallback = download_image(fallback_url, fallback_file)
+            if downloaded_fallback:
+                return {"path": downloaded_fallback, "asset_type": "image"}
+    print(f"Failed to generate asset for: {prompt}")
     return None
 
-def generate_tts(text, voice='en'):
-    if not text.strip():
-        return None
+def generate_silent_audio(duration, sample_rate=24000):
+    """Generate a silent WAV file for TTS fallback."""
+    num_samples = int(duration * sample_rate)
+    silence = np.zeros(num_samples, dtype=np.float32)
+    silent_path = os.path.join(TEMP_FOLDER, f"silent_{int(time.time())}.wav")
+    sf.write(silent_path, silence, sample_rate)
+    return silent_path
+
+def generate_tts(text, voice):
+    """Generate TTS audio using Kokoro, falling back to gTTS if needed."""
     safe_text = re.sub(r'[^\w\s-]', '', text[:10]).strip().replace(' ', '_')
     file_path = os.path.join(TEMP_FOLDER, f"tts_{safe_text}.wav")
     if os.path.exists(file_path):
         return file_path
     try:
-        if pipeline:
-            audio_segments = [audio for _, _, audio in pipeline(text, voice='af_heart', speed=0.9, split_pattern=r'\n+')]
-            full_audio = np.concatenate(audio_segments) if len(audio_segments) > 1 else audio_segments[0]
-            sf.write(file_path, full_audio, 24000)
-        else:
-            tts = gTTS(text=text, lang=voice)
+        kokoro_voice = 'af_heart' if voice == 'en' else voice
+        generator = pipeline(text, voice=kokoro_voice, speed=0.9, split_pattern=r'\n+')
+        audio_segments = []
+        for i, (gs, ps, audio) in enumerate(generator):
+            audio_segments.append(audio)
+        full_audio = np.concatenate(audio_segments) if len(audio_segments) > 1 else audio_segments[0]
+        sf.write(file_path, full_audio, 24000)
+        return file_path
+    except Exception as e:
+        try:
+            tts = gTTS(text=text, lang='en')
             mp3_path = os.path.join(TEMP_FOLDER, f"tts_{safe_text}.mp3")
             tts.save(mp3_path)
-            AudioSegment.from_mp3(mp3_path).export(file_path, format="wav")
+            audio = AudioSegment.from_mp3(mp3_path)
+            audio.export(file_path, format="wav")
             os.remove(mp3_path)
-        return file_path
-    except Exception as e:
-        print(f"TTS generation failed: {e}")
-        return None
+            return file_path
+        except Exception as fallback_error:
+            return generate_silent_audio(duration=max(3, len(text.split()) * 0.5))
 
-## Video Processing
-def apply_kenburns_effect(clip, target_resolution):
+def apply_kenburns_effect(clip, target_resolution, effect_type=None):
+    """Apply a smooth Ken Burns effect to images."""
     target_w, target_h = target_resolution
     clip_aspect = clip.w / clip.h
     target_aspect = target_w / target_h
     if clip_aspect > target_aspect:
-        new_width = int(target_h * clip_aspect)
-        clip = clip.resize(width=new_width)
+        new_height = target_h
+        new_width = int(new_height * clip_aspect)
+    else:
+        new_width = target_w
+        new_height = int(new_width / clip_aspect)
+    clip = clip.resize(newsize=(new_width, new_height))
+    base_scale = 1.15
+    new_width = int(new_width * base_scale)
+    new_height = int(new_height * base_scale)
+    clip = clip.resize(newsize=(new_width, new_height))
+    max_offset_x = new_width - target_w
+    max_offset_y = new_height - target_h
+    available_effects = ["zoom-in", "zoom-out", "pan-left", "pan-right", "up-left"]
+    if effect_type is None or effect_type == "random":
+        effect_type = random.choice(available_effects)
+    if effect_type == "zoom-in":
+        start_zoom = 0.9
+        end_zoom = 1.1
+        start_center = (new_width / 2, new_height / 2)
+        end_center = start_center
+    elif effect_type == "zoom-out":
+        start_zoom = 1.1
+        end_zoom = 0.9
+        start_center = (new_width / 2, new_height / 2)
+        end_center = start_center
+    elif effect_type == "pan-left":
+        start_zoom = 1.0
+        end_zoom = 1.0
+        start_center = (max_offset_x + target_w / 2, (max_offset_y // 2) + target_h / 2)
+        end_center = (target_w / 2, (max_offset_y // 2) + target_h / 2)
+    elif effect_type == "pan-right":
+        start_zoom = 1.0
+        end_zoom = 1.0
+        start_center = (target_w / 2, (max_offset_y // 2) + target_h / 2)
+        end_center = (max_offset_x + target_w / 2, (max_offset_y // 2) + target_h / 2)
+    elif effect_type == "up-left":
+        start_zoom = 1.0
+        end_zoom = 1.0
+        start_center = (max_offset_x + target_w / 2, max_offset_y + target_h / 2)
+        end_center = (target_w / 2, target_h / 2)
     else:
-        new_height = int(target_w / clip_aspect)
-        clip = clip.resize(height=new_height)
-    clip = clip.resize(zoom=1.15)
-    return vfx.crop(clip.fx(vfx.resize, width=target_w * 1.1), width=target_w, height=target_h, x_center=clip.w / 2, y_center=clip.h / 2)
+        raise ValueError(f"Unsupported effect_type: {effect_type}")
+    def transform_frame(get_frame, t):
+        frame = get_frame(t)
+        ratio = t / clip.duration if clip.duration > 0 else 0
+        ratio = 0.5 - 0.5 * math.cos(math.pi * ratio)
+        current_zoom = start_zoom + (end_zoom - start_zoom) * ratio
+        crop_w = int(target_w / current_zoom)
+        crop_h = int(target_h / current_zoom)
+        current_center_x = start_center[0] + (end_center[0] - start_center[0]) * ratio
+        current_center_y = start_center[1] + (end_center[1] - start_center[1]) * ratio
+        min_center_x = crop_w / 2
+        max_center_x = new_width - crop_w / 2
+        min_center_y = crop_h / 2
+        max_center_y = new_height - crop_h / 2
+        current_center_x = max(min_center_x, min(current_center_x, max_center_x))
+        current_center_y = max(min_center_y, min(current_center_y, max_center_y))
+        cropped_frame = cv2.getRectSubPix(frame, (crop_w, crop_h), (current_center_x, current_center_y))
+        resized_frame = cv2.resize(cropped_frame, (target_w, target_h), interpolation=cv2.INTER_LANCZOS4)
+        return resized_frame
+    return clip.fl(transform_frame)
 
 def resize_to_fill(clip, target_resolution):
+    """Resize and crop a clip to fill the target resolution."""
     target_w, target_h = target_resolution
     clip_aspect = clip.w / clip.h
     target_aspect = target_w / target_h
     if clip_aspect > target_aspect:
         clip = clip.resize(height=target_h)
         crop_amount = (clip.w - target_w) / 2
-        clip = clip.crop(x1=crop_amount, x2=clip.w - crop_amount)
+        clip = clip.crop(x1=crop_amount, x2=clip.w - crop_amount, y1=0, y2=clip.h)
     else:
         clip = clip.resize(width=target_w)
         crop_amount = (clip.h - target_h) / 2
-        clip = clip.crop(y1=crop_amount, y2=clip.h - crop_amount)
+        clip = clip.crop(x1=0, x2=clip.w, y1=crop_amount, y2=clip.h - crop_amount)
     return clip
 
-def add_background_music(final_video, bgm_path=None, bgm_volume=0.15):
-    if bgm_path and os.path.exists(bgm_path):
-        bg_music = AudioFileClip(bgm_path)
-        if bg_music.duration < final_video.duration:
-            loops_needed = math.ceil(final_video.duration / bg_music.duration)
-            bg_music = concatenate_audioclips([bg_music] * loops_needed)
-        bg_music = bg_music.subclip(0, final_video.duration).volumex(bgm_volume)
-        mixed_audio = CompositeAudioClip([final_video.audio, bg_music])
-        return final_video.set_audio(mixed_audio)
-    return final_video
-
-def create_clip(media_path, asset_type, tts_path, narration_text, target_resolution, subtitles_enabled, font, font_size, outline_width, font_color, outline_color, position, zoom_pan_effect):
-    if not media_path or not os.path.exists(media_path) or (tts_path and not os.path.exists(tts_path)):
-        print("Missing media or TTS file")
-        return None
-    audio_clip = AudioFileClip(tts_path).audio_fadeout(0.2) if tts_path else None
-    target_duration = audio_clip.duration + 0.2 if audio_clip else 5.0
-    if asset_type == "video":
-        clip = VideoFileClip(media_path)
-        clip = resize_to_fill(clip, target_resolution)
-        clip = clip.loop(duration=target_duration) if clip.duration < target_duration else clip.subclip(0, target_duration)
-    else:
-        clip = ImageClip(media_path).set_duration(target_duration).fadein(0.3).fadeout(0.3)
-        if zoom_pan_effect:
-            clip = apply_kenburns_effect(clip, target_resolution)
-        clip = resize_to_fill(clip, target_resolution)
-    if subtitles_enabled and narration_text and audio_clip:
-        words = narration_text.split()
-        chunks = [' '.join(words[i:i+5]) for i in range(0, len(words), 5)]
-        chunk_duration = audio_clip.duration / max(len(chunks), 1)
-        subtitle_clips = []
-        y_position = target_resolution[1] * (0.1 if position == "top" else 0.8 if position == "bottom" else 0.5)
-        for i, chunk in enumerate(chunks):
-            txt_clip = TextClip(
-                chunk,
-                fontsize=font_size,
-                font=font,
-                color=font_color,
-                stroke_color=outline_color,
-                stroke_width=outline_width,
-                method='caption',
-                align='center',
-                size=(target_resolution[0] * 0.8, None)
-            ).set_start(i * chunk_duration).set_end((i + 1) * chunk_duration).set_position(('center', y_position))
-            subtitle_clips.append(txt_clip)
-        clip = CompositeVideoClip([clip] + subtitle_clips)
-    if audio_clip:
+def find_mp3_files():
+    """Find an MP3 file for background music."""
+    mp3_files = []
+    for root, dirs, files in os.walk('.'):
+        for file in files:
+            if file.endswith('.mp3'):
+                mp3_path = os.path.join(root, file)
+                mp3_files.append(mp3_path)
+    return mp3_files[0] if mp3_files else None
+
+def add_background_music(final_video, bg_music_volume=0.08):
+    """Add background music to the final video."""
+    try:
+        bg_music_path = find_mp3_files()
+        if bg_music_path and os.path.exists(bg_music_path):
+            bg_music = AudioFileClip(bg_music_path)
+            if bg_music.duration < final_video.duration:
+                loops_needed = math.ceil(final_video.duration / bg_music.duration)
+                bg_segments = [bg_music] * loops_needed
+                bg_music = concatenate_videoclips(bg_segments)
+            bg_music = bg_music.subclip(0, final_video.duration)
+            bg_music = bg_music.volumex(bg_music_volume)
+            video_audio = final_video.audio
+            mixed_audio = CompositeAudioClip([video_audio, bg_music])
+            final_video = final_video.set_audio(mixed_audio)
+        return final_video
+    except Exception as e:
+        print(f"Error adding background music: {e}")
+        return final_video
+
+def create_clip(media_path, asset_type, tts_path, duration=None, effects=None, narration_text=None, segment_index=0):
+    """Create a video clip from a media asset and its corresponding TTS audio, optionally with subtitles."""
+    try:
+        if not os.path.exists(media_path) or not os.path.exists(tts_path):
+            return None
+        audio_clip = AudioFileClip(tts_path).audio_fadeout(0.2)
+        audio_duration = audio_clip.duration
+        target_duration = audio_duration + 0.2
+        if asset_type == "video":
+            clip = VideoFileClip(media_path)
+            clip = resize_to_fill(clip, TARGET_RESOLUTION)
+            if clip.duration < target_duration:
+                clip = clip.loop(duration=target_duration)
+            else:
+                clip = clip.subclip(0, target_duration)
+        elif asset_type == "image":
+            img = Image.open(media_path)
+            if img.mode != 'RGB':
+                with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as temp:
+                    img.convert('RGB').save(temp.name)
+                    media_path = temp.name
+                img.close()
+            clip = ImageClip(media_path).set_duration(target_duration)
+            clip = apply_kenburns_effect(clip, TARGET_RESOLUTION)
+            clip = clip.fadein(0.3).fadeout(0.3)
+        else:
+            return None
+        if narration_text and CAPTION_COLOR != "transparent":
+            try:
+                words = narration_text.split()
+                chunks = []
+                current_chunk = []
+                for word in words:
+                    current_chunk.append(word)
+                    if len(current_chunk) >= 5:
+                        chunks.append(' '.join(current_chunk))
+                        current_chunk = []
+                if current_chunk:
+                    chunks.append(' '.join(current_chunk))
+                chunk_duration = audio_duration / len(chunks)
+                subtitle_clips = []
+                subtitle_y_position = int(TARGET_RESOLUTION[1] * 0.70)
+                for i, chunk_text in enumerate(chunks):
+                    start_time = i * chunk_duration
+                    end_time = (i + 1) * chunk_duration
+                    txt_clip = TextClip(
+                        chunk_text,
+                        fontsize=45,
+                        font='Arial-Bold',
+                        color=CAPTION_COLOR,
+                        bg_color='rgba(0, 0, 0, 0.25)',
+                        method='caption',
+                        align='center',
+                        stroke_width=2,
+                        stroke_color=CAPTION_COLOR,
+                        size=(TARGET_RESOLUTION[0] * 0.8, None)
+                    ).set_start(start_time).set_end(end_time)
+                    txt_clip = txt_clip.set_position(('center', subtitle_y_position))
+                    subtitle_clips.append(txt_clip)
+                clip = CompositeVideoClip([clip] + subtitle_clips)
+            except Exception as sub_error:
+                txt_clip = TextClip(
+                    narration_text,
+                    fontsize=28,
+                    color=CAPTION_COLOR,
+                    align='center',
+                    size=(TARGET_RESOLUTION[0] * 0.7, None)
+                ).set_position(('center', int(TARGET_RESOLUTION[1] / 3))).set_duration(clip.duration)
+                clip = CompositeVideoClip([clip, txt_clip])
         clip = clip.set_audio(audio_clip)
-    return clip
+        return clip
+    except Exception as e:
+        print(f"Error in create_clip: {str(e)}")
+        return None
 
-## Main Video Generation Function
-def generate_video(resolution, render_speed, video_clip_percent, zoom_pan_effect, bgm_upload, bgm_volume, subtitles_enabled, font, font_size, outline_width, font_color, outline_color, position, *clip_data):
-    target_resolution = (1080, 1920) if resolution == "Short (1080x1920)" else (1920, 1080)
+def fix_imagemagick_policy():
+    """Attempt to fix ImageMagick security policies."""
+    try:
+        policy_paths = [
+            "/etc/ImageMagick-6/policy.xml",
+            "/etc/ImageMagick-7/policy.xml",
+            "/etc/ImageMagick/policy.xml",
+            "/usr/local/etc/ImageMagick-7/policy.xml"
+        ]
+        found_policy = next((path for path in policy_paths if os.path.exists(path)), None)
+        if not found_policy:
+            return False
+        os.system(f"sudo cp {found_policy} {found_policy}.bak")
+        os.system(f"sudo sed -i 's/rights=\"none\"/rights=\"read|write\"/g' {found_policy}")
+        os.system(f"sudo sed -i 's/<policy domain=\"path\" pattern=\"@\\*\"[^>]*>/<policy domain=\"path\" pattern=\"@*\" rights=\"read|write\"/g' {found_policy}")
+        os.system(f"sudo sed -i 's/<policy domain=\"coder\" rights=\"none\" pattern=\"PDF\"[^>]*>/<!-- <policy domain=\"coder\" rights=\"none\" pattern=\"PDF\"> -->/g' {found_policy}")
+        return True
+    except Exception as e:
+        return False
+
+def generate_video(user_input, resolution, caption_option):
+    """
+    Original video generation function.
+    This version takes only the basic inputs and uses the global clip data generated by the script.
+    You may need to extend this to use updated clip data from the dynamic clip editor.
+    """
+    global TARGET_RESOLUTION, CAPTION_COLOR, TEMP_FOLDER
+    if resolution == "Full HD (1920x1080)":
+        TARGET_RESOLUTION = (1920, 1080)
+    elif resolution == "Short (1080x1920)":
+        TARGET_RESOLUTION = (1080, 1920)
+    else:
+        TARGET_RESOLUTION = (1920, 1080)
+    CAPTION_COLOR = "white" if caption_option == "Yes" else "transparent"
+    TEMP_FOLDER = tempfile.mkdtemp()
+    fix_success = fix_imagemagick_policy()
+    if not fix_success:
+        print("Unable to fix ImageMagick policies; proceeding with alternative methods.")
+    print("Generating script from API...")
+    script = generate_script(user_input)
+    if not script:
+        shutil.rmtree(TEMP_FOLDER)
+        return None
+    print("Generated Script:\n", script)
+    elements = parse_script(script)
+    if not elements:
+        shutil.rmtree(TEMP_FOLDER)
+        return None
+    paired_elements = []
+    for i in range(0, len(elements), 2):
+        if i + 1 < len(elements):
+            paired_elements.append((elements[i], elements[i + 1]))
+    if not paired_elements:
+        shutil.rmtree(TEMP_FOLDER)
+        return None
     clips = []
-    for i in range(0, len(clip_data), 3):
-        prompt, narration, custom_media = clip_data[i], clip_data[i+1], clip_data[i+2]
-        if prompt.strip() or narration.strip():
-            media_asset = generate_media(prompt, custom_media, video_clip_percent / 100.0)
-            if not media_asset:
-                continue
-            tts_path = generate_tts(narration) if narration.strip() else None
-            clip = create_clip(
-                media_asset['path'], media_asset['asset_type'], tts_path, narration, target_resolution,
-                subtitles_enabled, font, font_size, outline_width, font_color, outline_color, position, zoom_pan_effect
-            )
-            if clip:
-                clips.append(clip)
+    for idx, (media_elem, tts_elem) in enumerate(paired_elements):
+        print(f"Processing segment {idx+1} with prompt: '{media_elem['prompt']}'")
+        media_asset = generate_media(media_elem['prompt'])
+        if not media_asset:
+            continue
+        tts_path = generate_tts(tts_elem['text'], tts_elem['voice'])
+        if not tts_path:
+            continue
+        clip = create_clip(
+            media_path=media_asset['path'],
+            asset_type=media_asset['asset_type'],
+            tts_path=tts_path,
+            duration=tts_elem['duration'],
+            effects=media_elem.get('effects', 'fade-in'),
+            narration_text=tts_elem['text'],
+            segment_index=idx
+        )
+        if clip:
+            clips.append(clip)
     if not clips:
-        print("No clips generated.")
+        shutil.rmtree(TEMP_FOLDER)
         return None
     final_video = concatenate_videoclips(clips, method="compose")
-    final_video = add_background_music(final_video, bgm_upload, bgm_volume)
-    final_video.write_videofile(OUTPUT_VIDEO_FILENAME, codec='libx264', fps=24, preset=render_speed, logger=None)
+    final_video = add_background_music(final_video, bg_music_volume=0.08)
+    final_video.write_videofile(OUTPUT_VIDEO_FILENAME, codec='libx264', fps=24, preset='veryfast')
     shutil.rmtree(TEMP_FOLDER)
     return OUTPUT_VIDEO_FILENAME
 
-## Load Clips Function
-def load_clips(topic, script):
-    raw_script = script.strip() if script.strip() else generate_script(topic)
-    clips = parse_script(raw_script)[:MAX_CLIPS]
-    updates = [gr.update(value=raw_script)]
-    for i in range(MAX_CLIPS):
-        if i < len(clips):
-            updates.extend([
-                gr.update(value=clips[i]["title"]),
-                gr.update(value=clips[i]["narration"]),
-                gr.update(value=None)  # Clear custom media
-            ])
-        else:
-            updates.extend([
-                gr.update(value=""),
-                gr.update(value=""),
-                gr.update(value=None)
-            ])
-    return updates
-
-# Gradio Interface
-with gr.Blocks(title="🚀 Orbit Video Engine") as app:
+# --------- NEW CALLBACK FUNCTIONS FOR THE NEW UI ---------
+# Global variable to store clip data from script-generation.
+generated_clip_data = []
+
+def generate_script_clips(topic_input, full_script):
+    """
+    Callback when the user clicks "📝 Generate Script & Load Clips".
+    Uses full_script if provided, else generates a script based on topic_input.
+    Returns generated raw script and a JSON string representing clip data.
+    """
+    input_text = full_script if full_script.strip() != "" else topic_input
+    script = generate_script(input_text)
+    if not script:
+        return "Error: failed to generate script", "{}"
+    elements = parse_script(script)
+    clip_list = []
+    for i in range(0, len(elements), 2):
+        if i + 1 < len(elements):
+            media_elem = elements[i]
+            tts_elem = elements[i+1]
+            clip_info = {
+                "prompt": media_elem.get("prompt", ""),
+                "narration": tts_elem.get("text", ""),
+                "custom_media": None
+            }
+            clip_list.append(clip_info)
+    global generated_clip_data
+    generated_clip_data = clip_list
+    return script, json.dumps(clip_list)
+
+def update_clip_editor(clip_json):
+    """
+    Generate a dynamic interface (using Gradio Blocks) for editing clip details.
+    Returns a list of Accordion components.
+    """
+    clip_list = json.loads(clip_json)
+    editors = []
+    for idx, clip in enumerate(clip_list, start=1):
+        accordion_title = f"Clip {idx}: {clip['prompt']}"
+        # Create an accordion for each clip.
+        with gr.Accordion(label=accordion_title, open=(idx<=2)) as accordion:
+            prompt_box = gr.Textbox(label="Visual Prompt", value=clip["prompt"])
+            narration_box = gr.Textbox(label="Narration Text", value=clip["narration"], lines=3)
+            custom_media_box = gr.File(label="Custom Media Upload (overrides prompt)", file_types=[".jpg", ".png", ".mp4"])
+            # Pack into a dictionary structure.
+            editors.append({
+                "prompt": prompt_box,
+                "narration": narration_box,
+                "custom_media": custom_media_box
+            })
+        editors.append(accordion)
+    return editors
+
+def generate_final_video(topic_input, full_script, clip_data_json, resolution, render_speed,
+                         video_clip_percent, zoom_pan, bg_music_file, bg_music_volume,
+                         subtitle_enabled, font_dropdown, font_size, outline_width,
+                         font_color, outline_color, subtitle_position):
+    """
+    Callback for "🎬 Generate Video" button.
+    Here we would combine the user-edited clip data with settings and call video generation.
+    Note: For demonstration, we will use the original generate_video function.
+    """
+    # In a real integration you would process clip_data_json to update each clip with custom overrides.
+    print("Final settings:")
+    print(f"Resolution: {resolution}, Render Speed: {render_speed}, Video Clip %: {video_clip_percent}, Zoom/Pan: {zoom_pan}")
+    if bg_music_file is not None:
+        print("Custom background music provided.")
+    # For now, we simply call generate_video using topic_input and full_script.
+    video_file = generate_video(topic_input, resolution, "Yes")
+    return video_file
+
+# --------- GRADIO BLOCKS UI ---------
+with gr.Blocks(title="🚀 Orbit Video Engine") as demo:
     with gr.Row():
         # Column 1: Content Input & Script Generation
-        with gr.Column():
-            gr.Markdown("### 1. Content Input")
-            topic_input = gr.Textbox(label="Video Topic", placeholder="e.g., Funny Cat Facts")
-            script_input = gr.Textbox(label="Or Paste Full Script", lines=10, placeholder="[Title]\nNarration...")
+        with gr.Column(scale=1):
+            gr.Markdown("## 1. Content Input")
+            topic_input = gr.Textbox(label="Topic Input", placeholder="Enter your video topic here...")
+            full_script = gr.Textbox(label="Or Paste Full Script", placeholder="Paste full script here...", lines=5)
             generate_script_btn = gr.Button("📝 Generate Script & Load Clips")
-            generated_script_display = gr.Textbox(label="Generated Script", interactive=False, lines=10)
-
-        # Column 2: Clip Editor
-        with gr.Column():
-            gr.Markdown("### 2. Edit Clips")
-            gr.Markdown("Modify prompts, narration, and upload custom media for each clip.")
-            prompts, narrations, custom_medias = [], [], []
-            for i in range(MAX_CLIPS):
-                with gr.Row():  # Always visible
-                    prompt = gr.Textbox(label=f"Clip {i+1} Visual Prompt")
-                    narration = gr.Textbox(label=f"Clip {i+1} Narration", lines=3)
-                    custom_media = gr.File(label=f"Clip {i+1} Upload Custom Media (Image/Video)", file_types=["image", "video"], value=None)
-                prompts.append(prompt)
-                narrations.append(narration)
-                custom_medias.append(custom_media)
-
+            generated_script_disp = gr.Textbox(label="Generated Script", interactive=False, visible=False)
+            clip_data_storage = gr.Textbox(visible=False)
+        # Column 2: Clip Editor (Dynamic)
+        with gr.Column(scale=1):
+            gr.Markdown("## 2. Edit Clips")
+            gr.Markdown("Modify each clip's visual prompt, narration or upload custom media.")
+            clip_editor_container = gr.Column(visible=False)
         # Column 3: Settings & Output
-        with gr.Column():
-            gr.Markdown("### 3. Video Settings")
-            resolution = gr.Radio(["Short (1080x1920)", "Full HD (1920x1080)"], label="Resolution", value="Full HD (1920x1080)")
-            render_speed = gr.Dropdown(["ultrafast", "veryfast", "fast", "medium", "slow", "veryslow"], 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 (Images)", value=True)
+        with gr.Column(scale=1):
+            gr.Markdown("## 3. Video Settings")
+            resolution = gr.Radio(choices=["Short (1080x1920)", "Full HD (1920x1080)"],
+                                  label="Resolution", value="Full HD (1920x1080)")
+            render_speed = gr.Dropdown(choices=["ultrafast", "veryfast", "fast", "medium", "slow", "veryslow"],
+                                       label="Render Speed", value="fast")
+            video_clip_percent = gr.Slider(0, 100, step=5, label="Video Clip Percentage", value=25)
+            zoom_pan = gr.Checkbox(label="Add Zoom/Pan Effect (Images)", value=True)
             with gr.Accordion("Background Music", open=False):
-                bgm_upload = gr.Audio(label="Upload Background Music", type="filepath")
-                bgm_volume = gr.Slider(0.0, 1.0, value=0.15, label="BGM Volume")
+                bg_music_file = gr.File(label="Upload Background Music (MP3)", file_types=[".mp3"])
+                bg_music_volume = gr.Slider(0.0, 1.0, step=0.05, label="BGM Volume", value=0.15)
             with gr.Accordion("Subtitle Settings", open=True):
-                subtitles_enabled = gr.Checkbox(label="Enable Subtitles", value=True)
-                font = gr.Dropdown(["Impact", "Arial", "Times New Roman"], label="Font", value="Arial")
+                subtitle_enabled = gr.Checkbox(label="Enable Subtitles", value=True)
+                font_dropdown = gr.Dropdown(choices=["Impact", "Arial", "Helvetica", "Times New Roman"],
+                                            label="Font", value="Arial")
                 font_size = gr.Number(label="Font Size", value=45)
                 outline_width = gr.Number(label="Outline Width", value=2)
                 font_color = gr.ColorPicker(label="Font Color", value="#FFFFFF")
                 outline_color = gr.ColorPicker(label="Outline Color", value="#000000")
-                position = gr.Radio(["top", "center", "bottom"], label="Position", value="bottom")
+                subtitle_position = gr.Radio(choices=["center", "bottom", "top"], label="Subtitle Position", value="center")
+            gr.Markdown("## 4. Output")
             generate_video_btn = gr.Button("🎬 Generate Video")
-            gr.Markdown("### 4. Output")
-            video_output = gr.Video(label="Generated Video")
-
-    # Event Handlers
+            video_preview = gr.Video(label="Generated Video")
+            download_video_file = gr.File(label="Download Video", interactive=False)
+    # Interactions
     generate_script_btn.click(
-        fn=load_clips,
-        inputs=[topic_input, script_input],
-        outputs=[generated_script_display] + prompts + narrations + custom_medias
+        fn=generate_script_clips,
+        inputs=[topic_input, full_script],
+        outputs=[generated_script_disp, clip_data_storage]
+    ).then(
+        fn=lambda script: gr.update(visible=True),
+        inputs=[generated_script_disp],
+        outputs=[generated_script_disp]
+    ).then(
+        fn=update_clip_editor,
+        inputs=[clip_data_storage],
+        outputs=[clip_editor_container]
+    ).then(
+        fn=lambda _: gr.update(visible=True),
+        inputs=[clip_editor_container],
+        outputs=[clip_editor_container]
     )
     generate_video_btn.click(
-        fn=generate_video,
-        inputs=[resolution, render_speed, video_clip_percent, zoom_pan_effect, bgm_upload, bgm_volume, subtitles_enabled, font, font_size, outline_width, font_color, outline_color, position] + prompts + narrations + custom_medias,
-        outputs=video_output
+        fn=generate_final_video,
+        inputs=[topic_input, full_script, clip_data_storage, resolution, render_speed,
+                video_clip_percent, zoom_pan, bg_music_file, bg_music_volume,
+                subtitle_enabled, font_dropdown, font_size, outline_width, font_color, outline_color, subtitle_position],
+        outputs=[video_preview]
     )
-
-# Launch the app
-app.launch(share=True)
+    
+demo.launch(share=True)