Create app.py

app.py

@@ -0,0 +1,268 @@
+
+
+import gradio as gr
+from deep_translator import GoogleTranslator
+import os
+import shutil
+import subprocess
+from PIL import Image, ImageDraw, ImageFont
+import re
+import uuid
+# Path to the ZIP file
+zip_file = "./fonts.zip"
+# Destination folder
+extract_to = "./fonts/"
+# Extract the ZIP file
+shutil.unpack_archive(zip_file, extract_to, 'zip')
+
+# Generate unique filename for the video
+def tts_file_name(text):
+    global temp_folder
+    # Remove all non-alphabetic characters and convert to lowercase
+    text = re.sub(r'[^a-zA-Z\s]', '', text)  # Retain only alphabets and spaces
+    text = text.lower().strip()             # Convert to lowercase and strip leading/trailing spaces
+    text = text.replace(" ", "_")           # Replace spaces with underscores
+    # Truncate or handle empty text
+    truncated_text = text[:20] if len(text) > 20 else text if len(text) > 0 else ""
+    
+    # Generate a random string for uniqueness
+    random_string = uuid.uuid4().hex[:8].upper()
+    
+    # Construct the file name
+    file_name = f"{temp_folder}/{truncated_text}_{random_string}.mp4"
+    return file_name
+
+temp_folder="./save_video"
+os.makedirs(temp_folder,exist_ok=True)
+# Translate text function
+def translate_text(text, target_language):
+    try:
+        translator = GoogleTranslator(source='auto', target=target_language)
+        return translator.translate(text)
+    except Exception as e:
+        print(f"Translation error: {e}")
+        return text
+
+
+ForeignLanguages = {
+    "en": "English", "zh-CN": "Mandarin Chinese", "hi": "Hindi", "es": "Spanish",
+    "fr": "French", "ar": "Standard Arabic", "bn": "Bengali", "pt": "Portuguese",
+    "ru": "Russian", "ur": "Urdu", "id": "Indonesian", "de": "German", "ja": "Japanese",
+    "pa": "Punjabi", "te": "Telugu", "tr": "Turkish", "ta": "Tamil", "vi": "Vietnamese", "ko": "Korean"
+}
+
+LocalIndianLanguages = {
+    "en": "English","hi": "Hindi", "bn": "Bengali", "mr": "Marathi", "te": "Telugu", "ta": "Tamil",
+    "gu": "Gujarati", "ur": "Urdu", "kn": "Kannada", "or": "Odia", "pa": "Punjabi", "ml": "Malayalam",
+    "mai": "Maithili","ne": "Nepali","sa": "Sanskrit","doi": "Dogri","sd": "Sindhi"
+
+}
+
+
+
+# Font Mapping
+font_mapping = {
+    "Arial-Bold.TTF": [ "it", "pt", "tr", "id"],
+    "OpenSans-Bold.ttf": ["ru", "vi"],
+    "Poppins-Bold.ttf": ["en","es","fr","hi","de"],
+    "NotoSansJP-Bold.ttf":["ja"],
+    "NotoSansBengali-Bold.ttf":["bn"],
+    "NotoSansKR-Bold.ttf":["ko"],
+    "NotoSansTamil-Bold.ttf":["ta"],
+    "AnekTelugu-Bold.ttf":["te"],
+    "BraahOne-Regular.ttf":["pa"],
+    "NotoNastaliqUrdu-Bold.ttf":["ur"],
+    "NotoSansSC-Bold.ttf":["zh-CN"],
+    "NotoSansArabic-Bold.ttf":["ar","sd"],
+    "NotoSansGujarati-Bold.ttf":["gu"],
+    "NotoSansKannada-Bold.ttf":["kn"],
+    "AnekOdia-Bold.ttf":["or"],
+    "NotoSansMalayalam-Bold.ttf":["ml"],
+    "NotoSans-Bold.ttf":["mr"]
+
+}
+
+
+# Get font for language
+def get_font_for_language(language):
+    for font, languages in font_mapping.items():
+        if language in languages:
+            return f"./fonts/{font}"
+    return "./fonts/NotoSans-Bold.ttf"
+
+# Create image function
+def create_image(text, language="en", font_size=100, text_color="#000000", bg_color="#FFFFFF", width=1024, height=1024, output_folder="./"):
+    img = Image.new('RGB', (width, height), color=bg_color)
+    draw = ImageDraw.Draw(img)
+    # font_path = "NotoSans-Regular.ttf"
+    font_path = get_font_for_language(language)
+    print(font_path)
+    font = ImageFont.truetype(font_path, font_size)
+    # try:
+    #     font = ImageFont.truetype(font_path, font_size)
+    # except IOError:
+    #     font = ImageFont.load_default()
+
+    bbox = draw.textbbox((0, 0), text, font=font)
+    text_width, text_height = bbox[2] - bbox[0], bbox[3] - bbox[1]
+    x, y = (width - text_width) // 2, (height - text_height) // 2
+    draw.text((x, y), text, fill=text_color, font=font)
+
+    filename = os.path.join(output_folder, f"frame_{language}.png")
+    img.save(filename)
+    return filename
+
+
+import subprocess
+
+def get_video_duration(video_file):
+    # Run FFmpeg to get video information in JSON format
+    result = subprocess.run(
+        ['ffmpeg', '-i', video_file],
+        stderr=subprocess.PIPE,
+        stdout=subprocess.PIPE
+    )
+    
+    # Decode the stderr output to get the duration information
+    output = result.stderr.decode()
+    
+    # Extract the duration from the output using regex
+    match = re.search(r'Duration: (\d+):(\d+):(\d+\.\d+)', output)
+    
+    if match:
+        hours = int(match.group(1))
+        minutes = int(match.group(2))
+        seconds = float(match.group(3))
+        
+        # Convert total duration to seconds
+        total_seconds = hours * 3600 + minutes * 60 + seconds
+        return total_seconds
+    else:
+        raise ValueError("Could not extract video duration.")
+
+
+
+
+# Generate video function
+def generate_video(input_text, language_set, font_size, theme, canvas_size):
+    width, height = map(int, canvas_size.split('x'))
+    theme_colors = {"Black Background": ("#FFFFFF", "#000000"), "White Background": ("#000000", "#FFFFFF")}
+    text_color, bg_color = theme_colors[theme]
+    output_folder = "temp_frames"
+    frames = "./frames"
+    # Cleanup previous frames
+    if os.path.exists(output_folder):
+        shutil.rmtree(output_folder)
+    os.makedirs(output_folder)
+    if os.path.exists(frames):
+        shutil.rmtree(frames)
+    os.makedirs(frames)
+
+    # Choose language set
+    language_list = list(ForeignLanguages.keys()) if language_set == "Foreign Languages" else list(LocalIndianLanguages.keys())
+    image_files = []
+
+    FPS = 30
+    DURATION_PER_IMAGE = 0.5  # 50ms duration per language
+    FRAMES_PER_IMAGE = round(FPS * DURATION_PER_IMAGE)  # Frames needed per image
+    extra_frames = FRAMES_PER_IMAGE+10  # Extra frames for the last image to allow fade-out effect
+    frame_index = 0  # Start numbering frames
+
+    for i, lang in enumerate(language_list):
+        translated_text = translate_text(input_text, lang) if lang != 'en' else input_text
+        img_path = create_image(translated_text, lang, font_size, text_color, bg_color, width, height, output_folder)
+
+        # Check if it's the last image
+        frame_count = FRAMES_PER_IMAGE + extra_frames if i == len(language_list) - 1 else FRAMES_PER_IMAGE
+
+        # Duplicate frames for smooth video
+        for _ in range(frame_count):
+            frame_filename = os.path.join(frames, f"{frame_index:05d}.png")
+            shutil.copy(img_path, frame_filename)
+            frame_index += 1
+
+    # Generate video using FFmpeg
+    output_video = "multi_language_video.mp4"
+    subprocess.run([
+        "ffmpeg", "-y", "-r", str(FPS), "-i", f"{frames}/%05d.png",
+        "-c:v", "libx264", "-pix_fmt", "yuv420p", output_video
+    ])
+
+    # Add music to the generated video with fade-out effect
+    music_file = "./music.WAV"  # Path to your music file
+    
+    final_video = tts_file_name(input_text)    
+    # subprocess.run([
+    #     "ffmpeg", "-y", "-i", output_video, "-i", music_file,
+    #     "-c:v", "libx264", "-c:a", "aac", "-strict", "experimental",
+    #     "-af", "afade=t=out:st=4:d=1",  # Fade out music at 4s, for 1 second
+    #     "-shortest", final_video
+    # ])
+    # # Example usage
+
+    video_duration = get_video_duration(output_video)
+    # Adjust the start time and duration for the fade-out effect
+    fade_out_start = max(0, video_duration - 1)  # Ensure the fade starts 1 second before the video ends
+    subprocess.run([
+        "ffmpeg", "-y", "-i", output_video, "-i", music_file,
+        "-c:v", "libx264", "-c:a", "aac", "-strict", "experimental",
+        "-af", f"afade=t=out:st={fade_out_start}:d=1",  # Fade out for the last 1 second
+        "-shortest", final_video
+    ])
+
+
+    shutil.rmtree(output_folder)  # Cleanup after generating video
+    shutil.rmtree(frames)  # Cleanup after generating frames
+    return final_video, final_video
+
+# Gradio UI Setup
+def ui():
+    dummy_examples = [
+        ["Hello", "Foreign Languages"],
+        ["No", "Local Indian Languages"]
+    ]
+    
+    with gr.Blocks() as demo:
+        gr.Markdown("<center><h1 style='font-size: 40px;'>See Your Name in Different Languages</h1></center>")  # Larger title with CSS
+        with gr.Row():
+            with gr.Column():
+                input_text = gr.Textbox(label='📝 Enter Your Name', lines=3)
+                language_set = gr.Radio(
+                    ["Foreign Languages", "Local Indian Languages"], 
+                    label="🌍Language Set", 
+                    value="Foreign Languages"
+                )
+                canvas_size = gr.Radio(
+                    ["1920x1080", "1080x1920", "1024x1024"], 
+                    value="1024x1024", 
+                    label="🖥️ Canvas Size"
+                )
+                generate_btn = gr.Button('🚀 Generate', variant='primary')
+
+                with gr.Accordion('🖌️ Text Style', open=False):
+                    font_size = gr.Slider(20, 200, value=100, step=1, label="🔠 Font Size")  # FIXED (Removed comma)
+                    theme = gr.Radio(["Black Background", "White Background"], label="🎨 Theme", value="Black Background")
+
+            with gr.Column():
+                download_video = gr.File(label="📥 Download Video")
+                play_video = gr.Video(label="🎬 Generated Video")
+
+        # Define Inputs and Outputs
+        input_list = [input_text, language_set, font_size, theme, canvas_size]
+        output_list = [download_video, play_video]
+
+        # Bind Functions to UI Elements
+        input_text.submit(generate_video, inputs=input_list, outputs=output_list)
+        generate_btn.click(generate_video, inputs=input_list, outputs=output_list)
+
+        # Add examples
+        gr.Examples(examples=dummy_examples, inputs=[input_text, language_set])
+
+    return demo
+
+# Launch the app
+def main(share=True, debug=True):
+    demo = ui()
+    demo.queue().launch(debug=debug, share=share)
+
+main()