Corrected initial push of light AI Video Generator

README copy.md

@@ -0,0 +1,112 @@
+# 🎥 Light AI Video Generator
+
+**Light AI Video Generator** is an all-in-one Hugging Face Space that lets you create short, compelling AI-powered videos using **just a few inputs**. It handles everything — from script writing and voice generation to background video montage and subtitles.
+
+> ✅ No editing skills required.  
+> 🔥 Perfect for YouTube Shorts, TikTok, Reels, and more.
+
+---
+
+## 🚀 Features
+
+### 1. 🧠 AI Script Generation
+Use the built-in Qwen2.5 language model to automatically write a **concise, engaging script** based on your context and instructions.  
+Prefer to write your own? Just switch to "Use my script" mode.
+
+### 2. 🗣️ Voice Generation with Kokoro
+Your script is turned into a **natural-sounding AI voice** using Kokoro TTS (English voices). The voice is saved and synchronized with the final video.
+
+### 3. 🎞️ Background Video Compilation
+Upload one or more `.mp4` clips to serve as the **background footage**. The app automatically stitches and syncs them to match your script duration.
+
+### 4. 🎨 Video Style Settings
+Customize:
+- **Brightness**
+- **Contrast**
+- **Gamma**
+
+Perfect to match your aesthetic or highlight visuals better.
+
+### 5. 🎵 Optional Background Music
+Optionally upload a `.mp3` music track to mix with the voiceover.
+
+### 6. 📝 Subtitles (Optional)
+Enable dynamic subtitles that match the voiceover and are perfectly synced for better accessibility and viewer retention.
+
+### 7. 🏷️ Title + Description + Tags
+Get a **YouTube-ready title, description, and hashtags** automatically generated to improve discoverability.
+
+---
+
+## 🧪 How to Use
+
+1. Go to the **🛠️ Settings tab**:
+   - Enter your **context** and **instruction**
+   - Choose whether to auto-generate the script or input your own
+   - Set your desired video **duration**, **style**, and upload your background video(s)
+   - Optional: upload a music file and enable subtitles
+
+2. Click **🚀 Generate the video**
+
+3. Head to the **📤 Results tab** to:
+   - Watch the generated video
+   - Copy the script, title, and description with one click
+
+---
+
+## 🛠 Technologies Used
+
+| Component        | Technology                       |
+|------------------|----------------------------------|
+| UI               | Gradio                           |
+| LLM              | Qwen2.5 via Hugging Face         |
+| Voice (TTS)      | Kokoro 82M (open-weight TTS)     |
+| Audio Processing | Pydub, Soundfile                 |
+| Video Editing    | MoviePy                          |
+| Subtitles        | Whisper (OpenAI)                 |
+
+---
+
+## 📁 Project Structure
+
+```
+.
+├── app.py                  # Gradio app logic & interface
+├── requirements.txt        # All needed dependencies
+├── README.md               # This file
+├── scripts/
+│   ├── generate_scripts.py        # Script, title, description generation
+│   ├── generate_voice.py          # Kokoro voice synthesis
+│   ├── get_footage.py             # Background montage builder
+│   ├── edit_video.py              # Final audio/video editor
+│   └── generate_subtitles.py     # Whisper subtitle generation
+└── assets/                # Stores audio, video and outputs
+```
+
+---
+
+## ✅ Requirements
+
+This app requires the following dependencies (automatically installed in Spaces):
+
+```txt
+gradio
+torch
+transformers
+kokoro>=0.9.4
+soundfile
+pydub
+openai-whisper
+moviepy
+python-dotenv
+```
+
+---
+
+## 🤖 Credits
+
+Built by [Your Name or Team]  
+Powered by Hugging Face 🤗, Qwen, and Kokoro TTS  
+MIT License
+
+---

app.py

@@ -0,0 +1,218 @@
+import gradio as gr
+import os
+import shutil
+from typing import List, Optional
+
+from scripts.generate_scripts import generate_script, generate_title, generate_description
+from scripts.generate_voice import generate_voice
+from scripts.get_footage import get_video_montage_from_folder
+from scripts.edit_video import edit_video
+from scripts.generate_subtitles import (
+    transcribe_audio_to_subs,
+    chunk_text_by_words,
+    add_subtitles_to_video,
+)
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Constants & helper utils
+# ──────────────────────────────────────────────────────────────────────────────
+
+WORDS_PER_SECOND = 2.3  # ≃ 140 wpm
+
+
+def safe_copy(src: str, dst: str) -> str:
+    if os.path.abspath(src) == os.path.abspath(dst):
+        return src
+    shutil.copy(src, dst)
+    return dst
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Core processing pipeline
+# ──────────────────────────────────────────────────────────────────────────────
+
+def process_video(
+    context: str,
+    instruction: str,
+    target_duration: int,
+    script_mode: str,
+    custom_script: Optional[str],
+    lum: float,
+    contrast: float,
+    gamma: float,
+    add_subs: bool,
+    accumulated_videos: List[str] | None = None,
+    user_music: Optional[str] = None,
+    show_progress_bar: bool = True,
+):
+    """Build the final video using user‑defined visual parameters (brightness, contrast, gamma)."""
+
+    if not accumulated_videos:
+        raise ValueError("❌ Please upload at least one background video (.mp4) before generating.")
+
+    approx_words = int(target_duration * WORDS_PER_SECOND)
+
+    # --- 1. Script (AI or custom) ---
+    if script_mode == "Use my script":
+        if not custom_script or not custom_script.strip():
+            raise ValueError("❌ You selected 'Use my script' but the script field is empty!")
+        script = custom_script.strip()
+        title = generate_title(script)
+        description = generate_description(script)
+    else:
+        prompt = (
+            f"You are a video creation expert. Here is the context: {context.strip()}\n"
+            f"Instruction: {instruction.strip()}\n"
+            f"🔴 Strict target duration: {target_duration}s — ≈ {approx_words} words (must be respected)."
+        )
+        script = generate_script(prompt)
+        title = generate_title(script)
+        description = generate_description(script)
+
+    # --- 2. Prepare folders ---
+    for folder in ("./assets/audio", "./assets/backgrounds", "./assets/output"):
+        os.makedirs(folder, exist_ok=True)
+
+    voice_path = "./assets/audio/voice.mp3"
+    final_no_subs = "./assets/output/final_video.mp4"
+    final_with_subs = "./assets/output/final_video_subtitles.mp4"
+
+    # --- 3. Copy videos ---
+    for f in os.listdir("./assets/backgrounds"):
+        if f.lower().endswith(".mp4"):
+            os.remove(os.path.join("./assets/backgrounds", f))
+    for idx, v in enumerate(accumulated_videos):
+        if not os.path.isfile(v) or not v.lower().endswith(".mp4"):
+            raise ValueError(f"❌ Invalid file: {v}")
+        safe_copy(v, os.path.join("./assets/backgrounds", f"video_{idx:03d}.mp4"))
+
+    # --- 4. AI voice ---
+    generate_voice(script, voice_path)
+
+    # --- 5. Video montage ---
+    music_path = user_music if user_music and os.path.isfile(user_music) else None
+    _, out_no_audio = get_video_montage_from_folder(
+        folder_path="./assets/backgrounds",
+        audio_path=voice_path,
+        output_dir="./assets/video_music",
+        lum=lum,
+        contrast=contrast,
+        gamma=gamma,
+        show_progress_bar=show_progress_bar,
+    )
+
+    # --- 6. Mixing & subtitles ---
+    edit_video(out_no_audio, voice_path, music_path, final_no_subs)
+
+    if add_subs:
+        segments = transcribe_audio_to_subs(voice_path)
+        subs = chunk_text_by_words(segments, max_words=3)
+        add_subtitles_to_video(final_no_subs, subs, final_with_subs)
+        return script, title, description, final_with_subs
+    else:
+        return script, title, description, final_no_subs
+
+# ─────────────────────────────────────────────��────────────────────────────────
+# Upload helper
+# ──────────────────────────────────────────────────────────────────────────────
+
+def accumulate_files(new: List[str], state: List[str] | None):
+    state = state or []
+    for f in new or []:
+        if isinstance(f, str) and os.path.isfile(f) and f.lower().endswith(".mp4") and f not in state:
+            state.append(f)
+    return state
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Gradio UI
+# ──────────────────────────────────────────────────────────────────────────────
+
+with gr.Blocks(theme="gradio/soft") as demo:
+    gr.Markdown("# 🎬 AI Video Generator — Advanced Controls")
+
+    # ------------------- Parameters -------------------
+    with gr.Tab("🛠️ Settings"):
+        with gr.Row():
+            context_input = gr.Textbox(label="🧠 Context", lines=4)
+            instruction_input = gr.Textbox(label="🎯 Instruction", lines=4)
+
+        duration_slider = gr.Slider(5, 120, 1, 60, label="⏱️ Target duration (s)")
+
+        script_mode = gr.Radio([
+            "Generate script with AI",
+            "Use my script",
+        ], value="Generate script with AI", label="Script mode")
+
+        custom_script_input = gr.Textbox(label="✍️ My script", lines=8, interactive=False)
+
+        def toggle_script_input(mode):
+            return gr.update(interactive=(mode == "Use my script"))
+
+        script_mode.change(toggle_script_input, inputs=script_mode, outputs=custom_script_input)
+
+        with gr.Accordion("🎨 Video Settings (brightness/contrast/gamma)", open=False):
+            lum_slider = gr.Slider(0, 20, 6, step=0.5, label="Brightness (0–20)")
+            contrast_slider = gr.Slider(0.5, 2.0, 1.0, step=0.05, label="Contrast (0.5–2.0)")
+            gamma_slider = gr.Slider(0.5, 2.0, 1.0, step=0.05, label="Gamma (0.5–2.0)")
+
+        with gr.Row():
+            add_subs_checkbox = gr.Checkbox(label="Add dynamic subtitles", value=True)
+
+        with gr.Row():
+            show_bar = gr.Checkbox(label="Show progress bar", value=True)
+
+        # Upload videos
+        videos_dropzone = gr.Files(label="🎞️ Background videos (MP4)", file_types=[".mp4"], type="filepath")
+        videos_state = gr.State([])
+        video_list_display = gr.Textbox(label="✅ Selected videos", interactive=False, lines=4)
+        videos_dropzone.upload(accumulate_files, [videos_dropzone, videos_state], videos_state, queue=False)
+        videos_state.change(lambda s: "\n".join(os.path.basename(f) for f in s), videos_state, video_list_display, queue=False)
+
+
+        user_music = gr.File(label="🎵 Background music (MP3, optional)", file_types=[".mp3"], type="filepath")
+
+        generate_btn = gr.Button("🚀 Generate the video", variant="primary")
+
+    with gr.Tab("📤 Results"):
+        video_output = gr.Video(label="🎬 Generated Video")
+
+        # Script + copy button
+        script_output = gr.Textbox(label="📝 Script", lines=6, interactive=False)
+        copy_script_btn = gr.Button("📋 Copy")
+        copy_script_btn.click(
+            None,
+            inputs=[script_output],
+            outputs=None,
+            js="(text) => navigator.clipboard.writeText(text)"
+        )
+
+        # Title + copy button
+        title_output = gr.Textbox(label="🎬 Title", lines=1, interactive=False)
+        copy_title_btn = gr.Button("📋 Copy")
+        copy_title_btn.click(None, inputs=title_output, outputs=None, js="(text) => {navigator.clipboard.writeText(text);}")
+
+        # Description + copy button
+        desc_output = gr.Textbox(label="📄 Description", lines=3, interactive=False)
+        copy_desc_btn = gr.Button("📋 Copy")
+        copy_desc_btn.click(None, inputs=desc_output, outputs=None, js="(text) => {navigator.clipboard.writeText(text);}")
+
+    # ------------------- Generation Callback -------------------
+    generate_btn.click(
+        fn=process_video,
+        inputs=[
+            context_input,
+            instruction_input,
+            duration_slider,
+            script_mode,
+            custom_script_input,
+            lum_slider,
+            contrast_slider,
+            gamma_slider,
+            add_subs_checkbox,
+            videos_state,
+            user_music,
+            show_bar,
+        ],
+        outputs=[script_output, title_output, desc_output, video_output],
+    )
+
+    demo.launch()

scripts/edit_video.py

@@ -0,0 +1,79 @@
+# ============================
+# get_footage.py  (unchanged)
+# ============================
+
+# (contenu identique à la précédente version – pas de modification)
+
+# ============================
+# edit_video.py (révision => musique optionnelle et volume paramétrable)
+# ============================
+
+"""Assemble la voix IA et, si fourni, la musique de fond.
+
+Appel :
+    edit_video(
+        video_path="./assets/video_music/video_silent.mp4",
+        audio_path="./assets/audio/voice.mp3",
+        music_path=None,          # ou chemin .mp3 / .wav
+        output_path="./assets/output/final_video.mp4",
+        music_volume=0.10,        # volume musique (0‑1)
+    )
+"""
+
+from moviepy import VideoFileClip, AudioFileClip, CompositeAudioClip
+import os
+
+
+def edit_video(
+    video_path: str,
+    audio_path: str,
+    music_path: str | None,
+    output_path: str,
+    *,
+    music_volume: float = 0.10,
+):
+    video_clip = VideoFileClip(video_path)
+    voice_clip = AudioFileClip(audio_path)
+    tracks = [voice_clip]
+
+    if music_path and os.path.isfile(music_path):
+        try:
+            music_clip = (
+                AudioFileClip(music_path)
+                .with_volume_scaled(music_volume)
+                .with_duration(video_clip.duration)
+            )
+            tracks.insert(0, music_clip)
+        except Exception as err:
+            print(f"⚠️ Musique ignorée : {err}")
+
+    final_audio = CompositeAudioClip(tracks).with_duration(video_clip.duration)
+    final_clip = video_clip.with_audio(final_audio)
+
+    final_clip.write_videofile(
+        output_path,
+        codec="libx264",
+        audio_codec="aac",
+        fps=30,
+        threads=4,
+        preset="medium",
+        ffmpeg_params=["-pix_fmt", "yuv420p"],
+    )
+    print(f"✅ Vidéo générée : {output_path}")
+
+    video_clip.close()
+    voice_clip.close()
+    if "music_clip" in locals():
+        music_clip.close()
+    final_audio.close()
+    final_clip.close()
+
+
+if __name__ == "__main__":
+    # Démo rapide (remplacer les chemins par les vôtres)
+    edit_video(
+        "./assets/video_music/video_silent.mp4",
+        "./assets/audio/voice.mp3",
+        None,
+        "./assets/output/final_video.mp4",
+    )

scripts/generate_scripts.py

@@ -0,0 +1,86 @@
+import os
+import re
+import json
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import gradio as gr
+from dotenv import load_dotenv
+
+
+# Chargement du modèle et du tokenizer
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model_id = "Qwen/Qwen2.5-0.5B"
+
+tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
+model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.float32, trust_remote_code=True)
+
+
+def generate_local(prompt: str, max_new_tokens: int = 350, temperature: float = 0.7) -> str:
+    device = model.device  # get the device the model is on
+    inputs = tokenizer(prompt, return_tensors="pt").to(device)
+    
+    output_ids = model.generate(
+        **inputs,
+        max_new_tokens=max_new_tokens,
+        do_sample=True,
+        temperature=temperature,
+        pad_token_id=tokenizer.eos_token_id,
+    )
+    return tokenizer.decode(output_ids[0], skip_special_tokens=True)
+
+
+
+def generate_script(prompt: str, word_count: int = 60) -> str:
+    system_prompt = (
+        "You are a professional video scriptwriter. "
+        f"Write a script for a short YouTube video about: {prompt.strip()}.\n"
+        f"The video must be {word_count} words long, engaging, clear, and formatted as plain text."
+    )
+    return generate_local(system_prompt)
+
+
+def one_word(query: str) -> str:
+    prompt_final = (
+        "Extract only the unique central theme of the following text in English in JSON format like this: "
+        '{"keyword": "impact"}. Text: ' + query
+    )
+    result = generate_local(prompt_final, max_new_tokens=30, temperature=0.4)
+    try:
+        keyword_json = json.loads(result)
+        keyword = keyword_json.get("keyword", "")
+    except json.JSONDecodeError:
+        matches = re.findall(r'\b[a-zA-Z]{3,}\b', result)
+        keyword = matches[0] if matches else ""
+    return keyword.lower()
+
+
+def generate_title(text: str) -> str:
+    prompt_final = (
+        "Generate a unique title for a YouTube Short video that is engaging and informative, "
+        "maximum 100 characters, without emojis, introduction, or explanation. Content:\n" + text
+    )
+    return generate_local(prompt_final, max_new_tokens=50, temperature=0.9).strip()
+
+
+def generate_description(text: str) -> str:
+    prompt_final = (
+        "Write only the YouTube video description in English:\n"
+        "1. A compelling opening line.\n"
+        "2. A clear summary of the video (max 3 lines).\n"
+        "3. End with 3 relevant hashtags.\n"
+        "No emojis or introductions. Here is the text:\n" + text
+    )
+    return generate_local(prompt_final, max_new_tokens=300, temperature=0.7).strip()
+
+
+def generate_tags(text: str) -> list:
+    prompt_final = (
+        "List only the important keywords for this YouTube video, separated by commas, "
+        "maximum 10 keywords. Context: " + text
+    )
+    result = generate_local(prompt_final, max_new_tokens=100, temperature=0.5)
+    return [tag.strip() for tag in result.split(",") if tag.strip()]
+

scripts/generate_subtitles.py

@@ -0,0 +1,237 @@
+#generate_subtitles.py
+
+import random
+import os
+import whisper
+from moviepy import (
+    VideoFileClip,
+    TextClip,
+    CompositeVideoClip,
+    ImageClip,
+    vfx
+)
+from moviepy.video.fx import FadeIn, Resize
+
+
+FONT_PATH = "Arial-Bold"
+
+
+
+# Palette de couleurs « flashy »
+SUBTITLE_COLORS = [
+    "white", "yellow", "cyan", "deeppink", "gold", "lightgreen", "magenta", "orange"
+]
+
+
+
+
+def color_for_word(word: str) -> str:
+    return random.choice(SUBTITLE_COLORS)
+
+
+
+
+
+def chunk_text_by_words(segments, max_words=1):
+    """
+    Découpe chaque segment Whisper en mini sous-titres de max_words mots
+    pour un affichage plus dynamique.
+    """
+    print("✂️ Découpage en sous-titres dynamiques (4 mots max)...")
+    subs = []
+    for seg in segments:
+        words = seg['text'].strip().split()
+        seg_duration = seg['end'] - seg['start']
+        if not words or seg_duration <= 0:
+            continue
+
+        word_duration = seg_duration / len(words)
+
+        for i in range(0, len(words), max_words):
+            chunk_words = words[i:i + max_words]
+            chunk_text = " ".join(chunk_words)
+            start_time = seg['start'] + i * word_duration
+            end_time = start_time + len(chunk_words) * word_duration
+
+            subs.append({
+                "start": start_time,
+                "end": end_time,
+                "text": chunk_text
+            })
+
+    print(f"🧩 {len(subs)} sous-titres créés (dynamiques).")
+    return subs
+
+
+def save_subtitles_to_srt(subtitles, output_path):
+    """
+    Sauvegarde les sous-titres au format .srt
+    """
+    def format_timestamp(seconds):
+        h = int(seconds // 3600)
+        m = int((seconds % 3600) // 60)
+        s = int(seconds % 60)
+        ms = int((seconds - int(seconds)) * 1000)
+        return f"{h:02}:{m:02}:{s:02},{ms:03}"
+
+    with open(output_path, "w", encoding="utf-8") as f:
+        for i, sub in enumerate(subtitles, 1):
+            f.write(f"{i}\n")
+            f.write(f"{format_timestamp(sub['start'])} --> {format_timestamp(sub['end'])}\n")
+            f.write(f"{sub['text'].strip()}\n\n")
+
+def transcribe_audio_to_subs(audio_path):
+    """
+    Transcrit le fichier audio en texte (via Whisper), retourne la liste
+    des segments start/end/text, et sauvegarde en .srt.
+    """
+    print("🎙️ Transcription avec Whisper...")
+    model = whisper.load_model("medium")  # ou "small"/"large" selon ton besoin
+    result = model.transcribe(audio_path)
+
+    subtitles = [{
+        "start": seg['start'],
+        "end": seg['end'],
+        "text": seg['text']
+    } for seg in result['segments']]
+
+    print(f"📝 {len(subtitles)} sous-titres générés.")
+
+    # Sauvegarde .srt
+    base_name = os.path.splitext(audio_path)[0]
+    srt_path = f"{base_name}.srt"
+    save_subtitles_to_srt(subtitles, srt_path)
+    print(f"💾 Sous-titres enregistrés dans : {srt_path}")
+
+    return subtitles
+
+def format_subtitle_text(text, max_chars=50):
+    """
+    Coupe le texte en 2 lignes max (~50 caractères max par ligne)
+    pour mieux remplir la vidéo verticale sans déborder.
+    """
+    words = text.strip().split()
+    lines = []
+    current_line = ""
+
+    for word in words:
+        if len(current_line + " " + word) <= max_chars:
+            current_line += (" " + word if current_line else word)
+        else:
+            lines.append(current_line.strip())
+            current_line = word
+    # Ajout de la dernière ligne
+    lines.append(current_line.strip())
+
+    # Retourne uniquement 2 lignes max
+    return "\n".join(lines[:2])
+
+
+def create_animated_subtitle_clip(text, start, end, video_w, video_h):
+    """
+    Crée un TextClip avec :
+      - Couleur aléatoire
+      - Fade-in / pop (resize progressif)
+      - Position verticale fixe (ajustable) ou légèrement aléatoire
+    """
+    word = text.strip()
+    color = color_for_word(word)
+
+
+    # Mise en forme du texte
+
+    # Création du clip texte de base
+    txt_clip = TextClip(
+        text=text,
+        font=FONT_PATH,
+        font_size=100,
+        color=color,
+        stroke_color="black",
+        stroke_width=6,
+        method="caption",
+        size=(int(video_w * 0.8), None),  # 80% de la largeur, hauteur auto
+        text_align="center",             # alignement dans la box
+        horizontal_align="center",       # box centrée horizontalement
+        vertical_align="center",         # box centrée verticalement
+        interline=4,
+        transparent=True
+    )
+
+
+    y_choices = [int(video_h * 0.45), int(video_h * 0.55), int(video_h * 0.6)]
+    base_y = random.choice(y_choices)
+
+    txt_clip = txt_clip.with_position(("center", base_y))
+    txt_clip = txt_clip.with_start(start).with_end(end)
+
+    # On applique un fadein + un petit effet "pop" qui grandit de 5% sur la durée du chunk
+    # 1) fadein de 0.2s
+    clip_fadein = FadeIn(duration=0.2).apply(txt_clip)
+
+    # 2) agrandissement progressif (ex: 1.0 → 1.05 sur la durée)
+    duration_subtitle = end - start
+    def pop_effect(t):
+        if duration_subtitle > 0:
+            progress = t / duration_subtitle
+            scale = 1.0 + 0.07 * (1 - (1 - progress) ** 3)  # easing out cubic
+        else:
+            scale = 1.0
+        return scale
+
+    resize_effect = Resize(pop_effect)
+    clip_pop = resize_effect.apply(clip_fadein)  # ✅ Utilisation correcte
+
+
+
+    return clip_pop
+
+
+def add_subtitles_to_video(video_path, subtitles, output_file="./assets/output/video_with_subs.mp4"):
+    """
+    Insère les sous-titres animés/couleur dans la vidéo,
+    recadre en 1080x1920 si besoin et exporte le résultat.
+    """
+    print("🎬 Insertion des sous-titres optimisés SHORTS...")
+
+    video = VideoFileClip(video_path)
+
+    # Force le format vertical 1080×1920 si non conforme
+    if (video.w, video.h) != (1080, 1920):
+        print("📐 Recadrage vidéo en 1080×1920...")
+        video = video.resize((1080, 1920))
+
+    clips = [video]
+
+    for sub in subtitles:
+        start_time = sub['start']
+        end_time = sub['end']
+        text_chunk = sub['text']
+
+        animated_sub_clip = create_animated_subtitle_clip(
+            text_chunk, start_time, end_time, video_w=video.w, video_h=video.h
+        )
+        clips.append(animated_sub_clip)
+
+
+    final = CompositeVideoClip(clips, size=(1080, 1920)).with_duration(video.duration)
+
+    # Export en MP4 H.264 + AAC, 30 fps
+    final.write_videofile(
+        output_file,
+        codec="libx264",
+        audio_codec="aac",
+        fps=30,
+        threads=4,
+        preset="medium",
+        ffmpeg_params=["-pix_fmt", "yuv420p"]
+    )
+
+    print(f"✅ Vidéo Shorts/TikTok prête : {output_file}")
+
+# test
+if __name__ == "__main__":
+    # Exemple de test
+    video_path = "assets/backgrounds/video_only.mp4"
+    audio_path = "assets/audio/voice.mp3"
+    subtitles = transcribe_audio_to_subs(audio_path)
+    add_subtitles_to_video(video_path, subtitles, output_file="output_with_subs.mp4")

scripts/generate_voice.py

@@ -0,0 +1,35 @@
+import os
+import soundfile as sf
+from kokoro import KPipeline
+import random
+
+pipeline = KPipeline(lang_code='a')  # 'a' for English
+
+ENGLISH_VOICES = [
+    "af_heart",
+    "en_us_amy",
+    "en_deep",
+    "en_female",
+    "en_male"
+]
+
+def generate_voice(text: str, path: str):
+    for voice in random.sample(ENGLISH_VOICES, len(ENGLISH_VOICES)):
+        try:
+            print(f"🔊 Trying voice: {voice}")
+            generator = pipeline(text, voice=voice)
+
+            for i, (gs, ps, audio) in enumerate(generator):
+                if i == 0:
+                    sf.write(path, audio, 24000)
+                    print(f"✅ Audio saved with {voice} at: {path}")
+                    return True
+        except Exception as e:
+            print(f"❌ Failed with {voice}: {e}")
+            continue
+
+    print("🛑 All voices failed.")
+    if os.path.exists(path):
+        os.remove(path)
+        print("🗑️ Removed broken file.")
+    return False

scripts/get_footage.py

@@ -0,0 +1,270 @@
+# get_footage.py
+
+import os
+import math
+import random
+import numpy as np
+from moviepy.video.fx.Resize import Resize
+from moviepy.video.fx.LumContrast import LumContrast
+from moviepy.video.fx.CrossFadeIn import CrossFadeIn
+from moviepy.video.fx.CrossFadeOut import CrossFadeOut
+from moviepy.video.fx.GammaCorrection import GammaCorrection
+from moviepy.video.fx.MultiplyColor import MultiplyColor
+from moviepy.video.fx.MultiplySpeed import MultiplySpeed
+from moviepy.video.fx.Scroll import Scroll
+
+from moviepy import (
+    VideoFileClip,
+    TextClip,
+    AudioFileClip,
+    ImageClip,
+    VideoClip,
+    concatenate_videoclips,
+    CompositeVideoClip
+)
+
+FONT_PATH = "C:/Windows/Fonts/arialbd.ttf"
+
+def add_pan_effect(clip):
+    """
+    Applique un effet de pan léger et aléatoire sur l’axe X.
+    """
+    return Scroll(x_speed=random.uniform(-5, 5), y_speed=0)(clip)
+
+def dynamic_effect(clip, lum, contrast, gamma):
+    """
+    Applique un ensemble d'effets "dynamiques":
+    - Zoom progressif
+    - Luminosité/contraste aléatoire
+    - Gamma correction aléatoire
+    - Filtre coloré subtil
+    - (Optionnel) Pan horizontal
+    - Légère variation de vitesse
+    """
+    duration = clip.duration
+
+    # Zoom progressif
+    max_zoom_factor = random.uniform(0.02, 0.05)  # 2% à 5% d'agrandissement total
+    zoomed_clip = clip.with_effects([
+        Resize(lambda t: 1 + max_zoom_factor * (t / duration))
+    ])
+
+    # Luminosité/Contraste
+    lum_value = lum
+    contrast_value = contrast
+    lum_clip = zoomed_clip.with_effects([
+        LumContrast(lum=lum_value, contrast=contrast_value)
+    ])
+
+    # Gamma correction
+    gamma_clip = lum_clip.with_effects([
+        GammaCorrection(gamma = gamma)
+    ])
+
+    # Filtre coloré subtil
+    color_shift = (
+        1.0 + random.uniform(-0.02, 0.05),
+        1.0 + random.uniform(-0.03, 0.03),
+        1.0 + random.uniform(-0.05, 0.01)
+    )
+    color_clip = gamma_clip.with_effects([
+        MultiplyColor(color_shift)
+    ])
+
+    # (Optionnel) pan horizontal
+    # color_clip = add_pan_effect(color_clip)
+
+    # Variation de vitesse
+    speed_factor = random.uniform(0.9, 1.2)
+    final_clip = color_clip.with_effects([
+        MultiplySpeed(speed_factor)
+    ])
+
+    return final_clip
+
+
+def add_timer_overlay(clip):
+    """
+    Ajoute une barre de progression sur la vidéo.
+    """
+    duration = clip.duration
+    overlay_clips = []
+
+    # Barre de progression
+    bar_height = 50
+    bar_width = int(clip.w * 0.8)
+    bar_x = (clip.w - bar_width) // 2
+    bar_y = int(clip.h * 0.10)
+
+    def make_bar_frame(t):
+        progress = min(t / duration, 1.0)
+        current_width = int(bar_width * progress)
+        frame = np.zeros((bar_height, bar_width, 3), dtype=np.uint8)
+        frame[:, :current_width] = [0, 255, 0]  # barre verte
+        return frame
+
+    bar_clip = VideoClip(make_bar_frame, duration=duration)
+    bar_clip = bar_clip.with_position((bar_x, bar_y))
+    overlay_clips.append(bar_clip)
+
+    # Composition finale
+    final = CompositeVideoClip([clip, *overlay_clips], size=clip.size)
+    return final
+
+
+def apply_crossfade_effects(clips, duration=0.12):
+    """
+    Applique un crossfade (fondu entrée/sortie) entre chaque clip.
+    """
+    clips_with_fades = []
+    for i, clip in enumerate(clips):
+        effects = []
+        if i != 0:
+            effects.append(CrossFadeIn(duration))
+        if i != len(clips) - 1:
+            effects.append(CrossFadeOut(duration))
+        clip_with_effects = clip.with_effects(effects)
+        clips_with_fades.append(clip_with_effects)
+    return clips_with_fades
+
+
+def get_video_montage_from_folder(
+    folder_path: str = "./assets/videos",
+    audio_path: str = "./assets/audio/voice.mp3",
+    output_dir: str = "./assets/backgrounds",
+    lum: float = 6.0,
+    contrast: float = 1.0,
+    gamma: float = 1.0,
+    show_progress_bar: bool = True,
+):
+    """
+    1) Parcourt tous les fichiers vidéo dans 'folder_path'
+    2) Construit un montage vertical (1080x1920) en appliquant dynamic_effect()
+       et un crossfade entre chaque clip.
+    3) La durée totale est bornée à la durée de l'audio (on coupe le surplus).
+    4) Exporte deux versions : avec et sans audio.
+    """
+
+    # Prépare les chemins de sortie
+    os.makedirs(output_dir, exist_ok=True)
+    output_with_audio = os.path.join(output_dir, "video_with_audio.mp4")
+    output_no_audio   = os.path.join(output_dir, "video_silent.mp4")
+
+    # Charge l'audio pour connaître la durée cible
+    voiceover = AudioFileClip(audio_path)
+    audio_duration = voiceover.duration
+    print(f"🎧 Durée audio : {audio_duration:.2f} s")
+
+    # Liste de tous les fichiers vidéo dans le dossier
+    all_videos = [
+        f for f in os.listdir(folder_path)
+        if f.lower().endswith((".mp4", ".mov", ".avi", ".mkv"))
+    ]
+
+    if not all_videos:
+        print(f"❌ Aucune vidéo trouvée dans le dossier : {folder_path}")
+        return None, None
+
+    clips = []
+    total_duration = 0.0
+
+    # Parcours des vidéos dans l'ordre
+    for idx, video_file in enumerate(all_videos):
+        video_path = os.path.join(folder_path, video_file)
+        try:
+            clip = VideoFileClip(video_path)
+
+            # Redimensionne en 1080x1920 (vertical)
+            target_w, target_h = 1080, 1920
+            clip_ar = clip.w / clip.h
+            target_ar = target_w / target_h
+
+            if clip_ar > target_ar:
+                # On adapte la hauteur
+                clip = clip.resized(height=target_h)
+                # On coupe la largeur
+                clip = clip.cropped(width=target_w, x_center=clip.w / 2)
+            else:
+                # On adapte la largeur
+                clip = clip.resized(width=target_w)
+                # On coupe la hauteur
+                clip = clip.cropped(height=target_h, y_center=clip.h / 2)
+
+            # Applique l’effet dynamique
+            dynamic_clip = dynamic_effect(clip, lum, contrast, gamma)
+            clips.append(dynamic_clip)
+            total_duration += dynamic_clip.duration
+
+            # Si la somme dépasse la durée audio, on arrête la boucle
+            if total_duration >= audio_duration:
+                break
+
+        except Exception as e:
+            print(f"⚠️ Erreur avec le fichier {video_file} : {e}")
+
+    if not clips:
+        print("❌ Aucun clip valide. Montage impossible.")
+        return None, None
+
+    # Crossfade entre les clips
+    clips = apply_crossfade_effects(clips, duration=0.15)
+
+    # Concaténation, borne la durée totale à celle de l'audio
+    final_clip = concatenate_videoclips(clips, method="compose").subclipped(0, audio_duration)
+
+    # Overlay (par ex. barre de progression)
+    if show_progress_bar:
+        final_clip = add_timer_overlay(final_clip)
+
+    # --------------------
+    # 1) Version AVEC audio
+    # --------------------
+    final_clip_with_audio = final_clip.with_audio(voiceover)
+    final_clip_with_audio.write_videofile(
+        output_with_audio,
+        codec='libx264',
+        audio_codec='aac',
+        fps=30,
+        threads=4,
+        preset="medium",
+        ffmpeg_params=["-pix_fmt", "yuv420p"]
+    )
+    print(f"✅ Montage créé (AVEC audio) : {output_with_audio}")
+
+
+    # --------------------
+    # 2) Version SANS audio
+    # --------------------
+    final_clip.write_videofile(
+        output_no_audio,
+        codec='libx264',
+        fps=30,
+        threads=4,
+        preset="medium",
+        ffmpeg_params=["-pix_fmt", "yuv420p"],
+        audio=False
+    )
+    print(f"✅ Montage créé (SANS audio) : {output_no_audio}")
+
+    # Libère la mémoire
+    for c in clips:
+        c.close()
+    voiceover.close()
+    final_clip.close()
+    final_clip_with_audio.close()
+
+
+    return output_with_audio, output_no_audio
+
+
+# -----------------------------
+# Exemple d'utilisation local
+# -----------------------------
+if __name__ == "__main__":
+    # Suppose que vous avez déjà un fichier voice.mp3
+    # et un dossier "./assets/videos" contenant plusieurs vidéos.
+    get_video_montage_from_folder(
+        folder_path="./assets/videos",
+        audio_path="./assets/audio/voice.mp3",
+        output_dir="./assets/backgrounds"
+    )