Upload 7 files

src/__init__.py

@@ -0,0 +1 @@
+# CapsulesVideoPro package

src/capsule_builder.py

@@ -0,0 +1,227 @@
+import os, json, uuid, gc, traceback
+from moviepy.editor import ImageClip, AudioFileClip, CompositeVideoClip
+from moviepy.video.VideoClip import ColorClip
+
+from .config import OUT_DIR, TMP_DIR, MANIFEST_PATH, W, H
+from .tts_utils import tts_edge, tts_gtts, normalize_audio_to_wav
+from .graphics import make_background
+from .video_utils import prepare_video_presentateur, write_srt, write_video_with_fallback, safe_name
+
+capsules = []
+
+# Load manifest on import
+if os.path.exists(MANIFEST_PATH):
+    try:
+        data = json.load(open(MANIFEST_PATH, "r", encoding="utf-8"))
+        if isinstance(data, dict) and "capsules" in data:
+            capsules.extend(data["capsules"])
+    except Exception:
+        pass
+
+def _save_manifest():
+    with open(MANIFEST_PATH, "w", encoding="utf-8") as f:
+        json.dump({"capsules": capsules}, f, ensure_ascii=False, indent=2)
+
+def build_capsule(titre, sous_titre, texte_voix, texte_ecran, theme,
+                  image_fond=None, logo_path=None, logo_pos="haut-gauche",
+                  fond_mode="plein écran",
+                  video_presentateur=None, voix_type="Féminine",
+                  position_presentateur="bottom-right", plein=False,
+                  moteur_voix="Edge-TTS (recommandé)", langue="fr", speaker=None):
+
+    # 1) TTS
+    try:
+        audio_mp = tts_edge(texte_voix, voice=speaker or ("fr-FR-DeniseNeural" if langue == "fr" else "nl-NL-MaaikeNeural"))
+    except Exception as e:
+        print(f"[Capsule] Erreur TTS Edge ({e}), fallback gTTS.")
+        audio_mp = tts_gtts(texte_voix, lang=langue)
+
+    audio_wav = audio_mp
+    if not audio_mp.lower().endswith(".wav"):
+        try:
+            audio_wav = normalize_audio_to_wav(audio_mp)
+        except Exception as e:
+            print(f"[Audio] Normalisation échouée ({e}), on garde {audio_mp}")
+
+    # 2) Fond
+    print("[Capsule] Génération du fond...")
+    fond_path = make_background(titre, sous_titre, texte_ecran, theme,
+                                logo_path, logo_pos, image_fond, fond_mode)
+    if fond_path is None:
+        print("[Capsule] ❌ fond_path est None, création d'urgence")
+        from PIL import Image
+        try:
+            emergency_bg = Image.new("RGB", (W, H), (0, 82, 147))
+            fond_path = os.path.join(TMP_DIR, f"emergency_{uuid.uuid4().hex[:6]}.png")
+            emergency_bg.save(fond_path)
+            print(f"[Capsule] ✅ Fond d'urgence créé: {fond_path}")
+        except Exception as e:
+            print(f"[Capsule] ❌ Impossible de créer le fond d'urgence: {e}")
+            fond_path = None
+
+    # 3) Composition MoviePy
+    audio = AudioFileClip(audio_wav)
+    dur = float(audio.duration or 5.0)
+    target_fps = 25
+    clips = []
+
+    if fond_path and os.path.exists(fond_path):
+        try:
+            bg = ImageClip(fond_path).set_duration(dur)
+            clips.append(bg)
+            print(f"[Capsule] ✅ Fond chargé: {fond_path}")
+        except Exception as e:
+            print(f"[Capsule] ❌ Erreur ImageClip, fallback ColorClip: {e}")
+            bg = ColorClip(size=(W, H), color=(0, 82, 147)).set_duration(dur)
+            clips.append(bg)
+    else:
+        print("[Capsule] ❌ Aucun fond valide, utilisation ColorClip")
+        bg = ColorClip(size=(W, H), color=(0, 82, 147)).set_duration(dur)
+        clips.append(bg)
+
+    if video_presentateur and os.path.exists(video_presentateur):
+        print(f"[Capsule] Vidéo présentateur trouvée: {video_presentateur}")
+        v_presentateur = prepare_video_presentateur(
+            video_presentateur, dur, position_presentateur, plein
+        )
+        if v_presentateur:
+            print(f"[Capsule] ✅ Vidéo présentateur ajoutée")
+            clips.append(v_presentateur)
+        else:
+            print(f"[Capsule] ❌ Échec préparation vidéo présentateur")
+    else:
+        print(f"[Capsule] Aucune vidéo présentateur: {video_presentateur}")
+
+    final = CompositeVideoClip(clips).set_audio(audio.set_fps(44100))
+    name = safe_name(f"{titre}_{langue}")
+    out_base = os.path.join(OUT_DIR, name)
+    out = write_video_with_fallback(final, out_base, fps=target_fps)
+
+    srt_path = write_srt(texte_voix, dur)
+    capsules.append({
+        "file": out,
+        "title": titre,
+        "langue": langue,
+        "voice": speaker or voix_type,
+        "theme": theme,
+        "duration": round(dur, 1),
+        "inputs": {"image_fond": image_fond, "logo": logo_path, "video_presentateur": video_presentateur},
+        "texte_voix": texte_voix,
+        "texte_ecran": texte_ecran
+    })
+    _save_manifest()
+
+    try:
+        audio.close()
+        final.close()
+        bg.close()
+        if 'v_presentateur' in locals() and v_presentateur is not None:
+            v_presentateur.close()
+        if os.path.exists(audio_mp):
+            os.remove(audio_mp)
+        if audio_wav != audio_mp and os.path.exists(audio_wav):
+            os.remove(audio_wav)
+    except Exception as e:
+        print(f"[Clean] Erreur nettoyage: {e}")
+    gc.collect()
+
+    return out, f"✅ Capsule {langue.upper()} créée ({dur:.1f}s, voix {speaker or voix_type})", srt_path
+
+def table_capsules():
+    import os
+    return [[i+1, c["title"], c.get("langue","fr").upper(),
+             f"{c['duration']}s", c["theme"], c["voice"], os.path.basename(c["file"])]
+            for i, c in enumerate(capsules)]
+
+def assemble_final():
+    if not capsules:
+        return None, "❌ Aucune capsule."
+    from moviepy.editor import VideoFileClip
+    from moviepy.video.compositing.concatenate import concatenate_videoclips
+    clips = [VideoFileClip(c["file"]) for c in capsules]
+    try:
+        out = write_video_with_fallback(
+            concatenate_videoclips(clips, method="compose"),
+            os.path.join(OUT_DIR, "VIDEO_COMPLETE"),
+            fps=25,
+        )
+        return out, f"🎉 Vidéo finale prête ({len(capsules)} capsules)."
+    finally:
+        for c in clips:
+            try: c.close()
+            except: pass
+
+def supprimer_capsule(index):
+    try:
+        idx = int(index) - 1
+        if 0 <= idx < len(capsules):
+            fichier = capsules[idx]["file"]
+            if os.path.exists(fichier):
+                os.remove(fichier)
+            del capsules[idx]
+            _save_manifest()
+            return f"🗑 Capsule supprimée : {fichier}", table_capsules()
+        else:
+            return "⚠️ Index invalide.", table_capsules()
+    except Exception as e:
+        return f"❌ Erreur lors de la suppression : {e}", table_capsules()
+
+def deplacer_capsule(index, direction):
+    try:
+        idx = int(index) - 1
+        if direction == "up" and idx > 0:
+            capsules[idx - 1], capsules[idx] = capsules[idx], capsules[idx - 1]
+        elif direction == "down" and idx < len(capsules) - 1:
+            capsules[idx + 1], capsules[idx] = capsules[idx], capsules[idx + 1]
+        _save_manifest()
+        return f"🔁 Capsule déplacée {direction}.", table_capsules()
+    except Exception as e:
+        return f"❌ Erreur de déplacement : {e}", table_capsules()
+
+
+import shutil, time
+
+def export_project_zip():
+    """Crée un ZIP complet pour toutes les capsules (vidéos, srt, inputs, params, manifest)."""
+    try:
+        zip_root = os.path.join(TMP_DIR, f"zip_export_{int(time.time())}")
+        os.makedirs(zip_root, exist_ok=True)
+        # Manifest global
+        manifest = {"capsules": capsules}
+        with open(os.path.join(zip_root, "manifest.json"), "w", encoding="utf-8") as f:
+            json.dump(manifest, f, ensure_ascii=False, indent=2)
+
+        # Par capsule
+        for i, cap in enumerate(capsules, 1):
+            cap_dir = os.path.join(zip_root, f"capsule_{i}")
+            os.makedirs(os.path.join(cap_dir, "inputs"), exist_ok=True)
+
+            # copy video + srt if exists
+            for key in ["file"]:
+                path = cap.get(key)
+                if path and os.path.exists(path):
+                    shutil.copy2(path, os.path.join(cap_dir, os.path.basename(path)))
+            # try to find srt next to file if not stored
+            if cap.get("file"):
+                base = os.path.splitext(os.path.basename(cap["file"]))[0]
+                # srt names are not strictly tied; we copy any srt in OUT_DIR too
+            for f in os.listdir(OUT_DIR):
+                if f.lower().endswith(".srt"):
+                    shutil.copy2(os.path.join(OUT_DIR, f), os.path.join(cap_dir, f))
+
+            # inputs
+            for k in ["image_fond", "logo", "video_presentateur"]:
+                p = cap.get("inputs", {}).get(k) if cap.get("inputs") else None
+                if p and os.path.exists(p):
+                    shutil.copy2(p, os.path.join(cap_dir, "inputs", os.path.basename(p)))
+
+            # params.json per capsule
+            with open(os.path.join(cap_dir, "params.json"), "w", encoding="utf-8") as pf:
+                json.dump(cap, pf, ensure_ascii=False, indent=2)
+
+        # zip
+        zip_path = shutil.make_archive(os.path.join(TMP_DIR, f"capsules_export_{int(time.time())}"), "zip", zip_root)
+        return zip_path
+    except Exception as e:
+        print(f"[Export] ❌ Erreur ZIP : {e}")
+        return None

src/config.py

@@ -0,0 +1,32 @@
+import os, json
+import PIL.Image
+
+# Pillow ANTIALIAS patch for compatibility with MoviePy
+if not hasattr(PIL.Image, "ANTIALIAS"):
+    PIL.Image.ANTIALIAS = PIL.Image.LANCZOS
+
+ROOT = os.getcwd()
+OUT_DIR = os.path.join(ROOT, "export")
+TMP_DIR = os.path.join(ROOT, "_tmp_capsules")
+os.makedirs(OUT_DIR, exist_ok=True)
+os.makedirs(TMP_DIR, exist_ok=True)
+
+CONFIG_PATH = os.path.join(ROOT, "app_config.json")
+if os.path.exists(CONFIG_PATH):
+    cfg = json.load(open(CONFIG_PATH, "r", encoding="utf-8"))
+    THEMES = cfg["themes"]
+    FONT_REG = cfg["font_paths"]["regular"]
+    FONT_BOLD = cfg["font_paths"]["bold"]
+else:
+    THEMES = {
+        "Bleu Professionnel": {"primary": [0, 82, 147], "secondary": [0, 126, 200]},
+        "Vert Gouvernemental": {"primary": [0, 104, 55], "secondary": [0, 155, 119]},
+        "Violet Élégant": {"primary": [74, 20, 140], "secondary": [103, 58, 183]},
+    }
+    FONT_REG = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"
+    FONT_BOLD = "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf"
+
+W, H = 1920, 1080
+MARGIN_X, SAFE_Y_TOP = 140, 140
+
+MANIFEST_PATH = os.path.join(OUT_DIR, "manifest.json")

src/graphics.py

@@ -0,0 +1,137 @@
+import os, uuid, re, traceback
+from PIL import Image, ImageDraw, ImageFont, ImageFilter, ImageOps
+from .config import THEMES, FONT_REG, FONT_BOLD, W, H, MARGIN_X, SAFE_Y_TOP, TMP_DIR
+
+def wrap_text(text, font, max_width, draw):
+    lines = []
+    for para in text.split("\n"):
+        current = []
+        for word in para.split(" "):
+            test = " ".join(current + [word])
+            try:
+                w = draw.textlength(test, font=font)
+            except AttributeError:
+                bbox = draw.textbbox((0, 0), test, font=font)
+                w = bbox[2] - bbox[0]
+            if w <= max_width or not current:
+                current.append(word)
+            else:
+                lines.append(" ".join(current))
+                current = [word]
+        if current:
+            lines.append(" ".join(current))
+    return lines
+
+def draw_text_shadow(draw, xy, text, font, fill=(255, 255, 255)):
+    x, y = xy
+    draw.text((x + 2, y + 2), text, font=font, fill=(0, 0, 0))
+    draw.text((x, y), text, font=font, fill=fill)
+
+def make_background(titre, sous_titre, texte_ecran, theme, logo_path, logo_pos, img_fond, fond_mode="plein écran"):
+    try:
+        print(f"[Fond] Création du fond - Thème: {theme}")
+        if not titre:
+            titre = "Titre CPAS"
+        if not theme or theme not in THEMES:
+            theme = list(THEMES.keys())[0]
+            print(f"[Fond] Thème invalide, utilisation par défaut: {theme}")
+
+        c = THEMES[theme]
+        primary = tuple(c["primary"])
+        secondary = tuple(c["secondary"])
+
+        bg = Image.new("RGB", (W, H), primary)
+        draw = ImageDraw.Draw(bg)
+
+        if img_fond and os.path.exists(img_fond):
+            try:
+                img = Image.open(img_fond).convert("RGB")
+                if fond_mode == "plein écran":
+                    img = img.resize((W, H))
+                    img = img.filter(ImageFilter.GaussianBlur(1))
+                    overlay = Image.new("RGBA", (W, H), (*primary, 90))
+                    bg = Image.alpha_composite(img.convert("RGBA"), overlay).convert("RGB")
+                elif fond_mode == "moitié gauche":
+                    img = img.resize((W//2, H))
+                    mask = Image.linear_gradient("L").resize((W//2, H))
+                    color = Image.new("RGB", (W//2, H), primary)
+                    comp = Image.composite(img, color, ImageOps.invert(mask))
+                    bg.paste(comp, (0, 0))
+                elif fond_mode == "moitié droite":
+                    img = img.resize((W//2, H))
+                    mask = Image.linear_gradient("L").resize((W//2, H))
+                    color = Image.new("RGB", (W//2, H), primary)
+                    comp = Image.composite(color, img, mask)
+                    bg.paste(comp, (W//2, 0))
+                elif fond_mode == "moitié bas":
+                    img = img.resize((W, H//2))
+                    mask = Image.linear_gradient("L").rotate(90).resize((W, H//2))
+                    color = Image.new("RGB", (W, H//2), primary)
+                    comp = Image.composite(color, img, mask)
+                    bg.paste(comp, (0, H//2))
+                draw = ImageDraw.Draw(bg)
+                print(f"[Fond] Image de fond appliquée: {fond_mode}")
+            except Exception as e:
+                print(f"[Fond] Erreur image de fond: {e}")
+
+        try:
+            f_title = ImageFont.truetype(FONT_BOLD, 84)
+            f_sub = ImageFont.truetype(FONT_REG, 44)
+            f_text = ImageFont.truetype(FONT_REG, 40)
+            f_small = ImageFont.truetype(FONT_REG, 30)
+        except Exception as e:
+            print(f"[Fond] Erreur polices, utilisation par défaut: {e}")
+            f_title = ImageFont.load_default()
+            f_sub = ImageFont.load_default()
+            f_text = ImageFont.load_default()
+            f_small = ImageFont.load_default()
+
+        draw.rectangle([(0, 0), (W, 96)], fill=secondary)
+        draw.rectangle([(0, H-96), (W, H)], fill=secondary)
+
+        draw_text_shadow(draw, (MARGIN_X, 30), "CPAS BRUXELLES • SERVICE PUBLIC", f_small)
+        draw_text_shadow(draw, (W//2-280, H-72), "📞 0800 35 550 • 🌐 cpasbru.irisnet.be", f_small)
+        draw_text_shadow(draw, (MARGIN_X, SAFE_Y_TOP), titre, f_title)
+        draw_text_shadow(draw, (MARGIN_X, SAFE_Y_TOP + 100), sous_titre, f_sub)
+
+        y = SAFE_Y_TOP + 200
+        if texte_ecran:
+            for line in texte_ecran.split("\n"):
+                wrapped_lines = wrap_text("• " + line.strip("• "), f_text, W - MARGIN_X*2, draw)
+                for l in wrapped_lines:
+                    draw_text_shadow(draw, (MARGIN_X, y), l, f_text)
+                    y += 55
+
+        if logo_path and os.path.exists(logo_path):
+            try:
+                logo = Image.open(logo_path).convert("RGBA")
+                logo.thumbnail((260, 260))
+                lw, lh = logo.size
+                if logo_pos == "haut-gauche":
+                    pos = (50, 50)
+                elif logo_pos == "haut-droite":
+                    pos = (W - lw - 50, 50)
+                else:
+                    pos = ((W - lw)//2, 50)
+                bg.paste(logo, pos, logo)
+                print(f"[Fond] Logo appliqué: {logo_pos}")
+            except Exception as e:
+                print(f"[Fond] Erreur logo: {e}")
+
+        out_path = os.path.join(TMP_DIR, f"fond_{uuid.uuid4().hex[:6]}.png")
+        bg.save(out_path)
+        print(f"[Fond] ✅ Fond créé avec succès: {out_path}")
+        return out_path
+
+    except Exception as e:
+        print(f"[Fond] ❌ ERREUR CRITIQUE: {e}")
+        print(f"[Fond] Traceback: {traceback.format_exc()}")
+        try:
+            emergency_bg = Image.new("RGB", (W, H), (0, 82, 147))
+            out_path = os.path.join(TMP_DIR, f"emergency_fond_{uuid.uuid4().hex[:6]}.png")
+            emergency_bg.save(out_path)
+            print(f"[Fond] ✅ Fond d'urgence créé: {out_path}")
+            return out_path
+        except Exception as e2:
+            print(f"[Fond] ❌ Même le fallback a échoué: {e2}")
+            return None

src/tts_utils.py

@@ -0,0 +1,95 @@
+import os, uuid, asyncio
+from typing import Dict
+from pydub import AudioSegment
+import edge_tts
+
+from .config import TMP_DIR
+
+EDGE_VOICES: Dict[str, str] = {}
+
+async def fetch_edge_voices_async():
+    """Charge dynamiquement toutes les voix FR/NL depuis Edge-TTS."""
+    global EDGE_VOICES
+    try:
+        voices = await edge_tts.list_voices()
+        filtered = [v for v in voices if v.get("Locale", "").startswith(("fr", "nl"))]
+        filtered.sort(key=lambda v: (v.get("Locale"), v.get("Gender"), v.get("ShortName")))
+        EDGE_VOICES = {
+            f"{v['ShortName']} - {v['Locale']} ({v['Gender']})": v["ShortName"]
+            for v in filtered
+        }
+        print(f"[Edge-TTS] {len(EDGE_VOICES)} voix FR/NL chargées.")
+    except Exception as e:
+        print(f"[Edge-TTS] Erreur chargement voix : {e}")
+        EDGE_VOICES.update({
+            "fr-FR-DeniseNeural - fr-FR (Female)": "fr-FR-DeniseNeural",
+            "nl-NL-MaaikeNeural - nl-NL (Female)": "nl-NL-MaaikeNeural",
+        })
+
+def init_edge_voices():
+    """Démarre le chargement asynchrone sans bloquer Gradio."""
+    try:
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            import nest_asyncio
+            nest_asyncio.apply()
+            loop.create_task(fetch_edge_voices_async())
+        else:
+            loop.run_until_complete(fetch_edge_voices_async())
+    except RuntimeError:
+        asyncio.run(fetch_edge_voices_async())
+
+def get_edge_voices(lang="fr"):
+    """Retourne les voix déjà chargées (selon la langue)."""
+    global EDGE_VOICES
+    if not EDGE_VOICES:
+        init_edge_voices()
+    if lang == "fr":
+        return [v for k, v in EDGE_VOICES.items() if k.startswith("fr-")]
+    elif lang == "nl":
+        return [v for k, v in EDGE_VOICES.items() if k.startswith("nl-")]
+    return list(EDGE_VOICES.values())
+
+async def _edge_tts_async(text, voice, outfile):
+    communicate = edge_tts.Communicate(text, voice)
+    await communicate.save(outfile)
+    return outfile
+
+def tts_edge(text: str, voice: str = "fr-FR-DeniseNeural") -> str:
+    """Génère un fichier WAV avec Edge-TTS (et fallback gTTS)."""
+    out_mp3 = os.path.join(TMP_DIR, f"edge_{uuid.uuid4().hex}.mp3")
+    try:
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                import nest_asyncio
+                nest_asyncio.apply()
+        except RuntimeError:
+            pass
+        asyncio.run(_edge_tts_async(text, voice, out_mp3))
+
+        out_wav = os.path.join(TMP_DIR, f"edge_{uuid.uuid4().hex}.wav")
+        AudioSegment.from_file(out_mp3).export(out_wav, format="wav")
+        os.remove(out_mp3)
+        return out_wav
+    except Exception as e:
+        print(f"[Edge-TTS] Erreur : {e} → fallback gTTS")
+        return tts_gtts(text, lang="fr" if voice.startswith("fr") else "nl")
+
+def tts_gtts(text: str, lang: str = "fr") -> str:
+    from gtts import gTTS
+    out = os.path.join(TMP_DIR, f"gtts_{uuid.uuid4().hex}.mp3")
+    gTTS(text=text, lang=lang).save(out)
+    out_wav = os.path.join(TMP_DIR, f"gtts_{uuid.uuid4().hex}.wav")
+    AudioSegment.from_file(out).export(out_wav, format="wav")
+    os.remove(out)
+    return out_wav
+
+def normalize_audio_to_wav(in_path: str) -> str:
+    """Convertit n'importe quel format en WAV 44.1kHz stéréo."""
+    from pydub import AudioSegment
+    wav_path = os.path.join(TMP_DIR, f"norm_{uuid.uuid4().hex}.wav")
+    snd = AudioSegment.from_file(in_path)
+    snd = snd.set_frame_rate(44100).set_channels(2).set_sample_width(2)
+    snd.export(wav_path, format="wav")
+    return wav_path

src/ui.py

@@ -0,0 +1,123 @@
+import gradio as gr
+from .config import THEMES
+from .tts_utils import get_edge_voices, init_edge_voices
+from .capsule_builder import (
+    build_capsule, table_capsules, assemble_final, supprimer_capsule, deplacer_capsule
+)
+
+def build_ui():
+    print("[INIT] Lancement de Gradio...")
+    init_edge_voices()
+
+    with gr.Blocks(title="Créateur de Capsules CPAS – Version avec vidéo présentateur",
+                   theme=gr.themes.Soft()) as demo:
+
+        gr.Markdown("## 🎬 Créateur de Capsules CPAS – Version avec vidéo présentateur")
+        gr.Markdown("**Nouveau** : Utilisez directement une vidéo de présentateur au lieu d'une image.")
+
+        with gr.Tab("Créer une capsule"):
+            with gr.Row():
+                with gr.Column():
+                    image_fond = gr.Image(label="🖼 Image de fond", type="filepath")
+                    fond_mode = gr.Radio(["plein écran", "moitié gauche", "moitié droite", "moitié bas"],
+                                         label="Mode d'affichage du fond", value="plein écran")
+                    logo_path = gr.Image(label="🏛 Logo", type="filepath")
+                    logo_pos = gr.Radio(["haut-gauche","haut-droite","centre"],
+                                        label="Position logo", value="haut-gauche")
+                    video_presentateur = gr.Video(label="🎬 Vidéo du présentateur")
+                    position_presentateur = gr.Radio(["bottom-right","bottom-left","top-right","top-left","center"],
+                                                     label="Position", value="bottom-right")
+                    plein = gr.Checkbox(label="Plein écran présentateur", value=False)
+                with gr.Column():
+                    titre = gr.Textbox(label="Titre", value="Aide médicale urgente / Dringende medische hulp")
+                    sous_titre = gr.Textbox(label="Sous-titre", value="Soins accessibles à tous / Toegankelijke zorg voor iedereen")
+                    theme = gr.Radio(list(THEMES.keys()), label="Thème", value="Bleu Professionnel")
+                    langue = gr.Radio(["fr", "nl"], label="Langue de la voix", value="fr")
+
+                    def maj_voix(lang):
+                        try:
+                            voices = get_edge_voices(lang)
+                            return gr.update(choices=voices, value=voices[0] if voices else None)
+                        except Exception:
+                            return gr.update(choices=[], value=None)
+
+                    speaker_id = gr.Dropdown(
+                        label="🎙 Voix Edge-TTS",
+                        choices=get_edge_voices("fr"),
+                        value="fr-FR-DeniseNeural",
+                        info="Liste dynamique des voix Edge-TTS (FR & NL)"
+                    )
+                    langue.change(maj_voix, [langue], [speaker_id])
+
+                    voix_type = gr.Radio(["Féminine","Masculine"], label="Voix IA", value="Féminine")
+                    moteur_voix = gr.Radio(["Edge-TTS (recommandé)", "gTTS (fallback)"],
+                                           label="Moteur voix", value="Edge-TTS (recommandé)")
+                    texte_voix = gr.Textbox(label="Texte voix off", lines=4,
+                                            value="Bonjour, le CPAS de Bruxelles vous aide pour vos soins de santé.")
+                    texte_ecran = gr.Textbox(label="Texte à l'écran", lines=4,
+                                             value="💊 Aides médicales\n🏥 Soins urgents\n📋 Formalités simplifiées")
+                    btn = gr.Button("🎬 Créer Capsule", variant="primary")
+
+            sortie = gr.Video(label="Capsule générée")
+            srt_out = gr.File(label="Sous-titres .srt")
+            statut = gr.Markdown()
+
+        with gr.Tab("Gestion & Assemblage"):
+            gr.Markdown("### 🗂 Gestion des capsules")
+            liste = gr.Dataframe(
+                headers=["N°","Titre","Langue","Durée","Thème","Voix","Fichier"],
+                value=table_capsules(),
+                interactive=False
+            )
+            with gr.Row():
+                index = gr.Number(label="Index capsule", value=1, precision=0)
+                btn_up = gr.Button("⬆️ Monter")
+                btn_down = gr.Button("⬇️ Descendre")
+                btn_del = gr.Button("🗑 Supprimer")
+            message = gr.Markdown()
+
+            btn_up.click(lambda i: deplacer_capsule(i, "up"), [index], [message, liste])
+            btn_down.click(lambda i: deplacer_capsule(i, "down"), [index], [message, liste])
+            btn_del.click(supprimer_capsule, [index], [message, liste])
+
+            gr.Markdown("### 🎬 Assemblage final")
+            btn_asm = gr.Button("🎥 Assembler la vidéo complète", variant="primary")
+            sortie_finale = gr.Video(label="Vidéo finale")
+            btn_asm.click(lambda: assemble_final(), [], [sortie_finale, message])
+
+            # --- Export ZIP intégré ---
+            from .capsule_builder import export_project_zip
+            btn_zip = gr.Button("📦 Télécharger projet complet (ZIP)", variant="secondary")
+            zip_file = gr.File(label="ZIP exporté")
+
+            def zip_action():
+                path = export_project_zip()
+                if path and os.path.exists(path):
+                    return path
+                else:
+                    raise gr.Error("Erreur : impossible de générer le ZIP.")
+
+            btn_zip.click(zip_action, [], [zip_file])
+
+
+        def creer_capsule_ui(t, st, tv, te, th, img, fmode, logo, pos_logo, vp, vx, pos_p, plein, motor, lang, speaker):
+            try:
+                vid, msg, srt = build_capsule(t, st, tv, te, th,
+                                              img, logo, pos_logo, fmode,
+                                              vp, vx, pos_p, plein,
+                                              motor, lang, speaker=speaker)
+                return vid, srt, msg, table_capsules()
+            except Exception as e:
+                import traceback
+                return None, None, f"❌ Erreur: {e}\n\n{traceback.format_exc()}", table_capsules()
+
+        btn.click(
+            creer_capsule_ui,
+            [titre, sous_titre, texte_voix, texte_ecran, theme,
+             image_fond, fond_mode, logo_path, logo_pos,
+             video_presentateur, voix_type, position_presentateur,
+             plein, moteur_voix, langue, speaker_id],
+            [sortie, srt_out, statut, liste]
+        )
+
+    return demo

src/video_utils.py

@@ -0,0 +1,96 @@
+import os, re, uuid, traceback
+from moviepy.editor import VideoFileClip
+import moviepy.video.fx.all as vfx
+from .config import OUT_DIR, W, H
+
+def safe_name(stem, ext=".mp4"):
+    stem = re.sub(r"[^\w\-]+", "_", stem)[:40]
+    return f"{stem}_{uuid.uuid4().hex[:6]}{ext}"
+
+def prepare_video_presentateur(video_path, audio_duration, position, plein_ecran=False):
+    """Prépare la vidéo du présentateur avec la bonne durée et position."""
+    try:
+        print(f"[Video] Chargement: {video_path}")
+        if not os.path.exists(video_path):
+            print(f"[Video] ❌ Fichier introuvable: {video_path}")
+            return None
+
+        v = VideoFileClip(video_path).without_audio()
+        print(f"[Video] Durée vidéo: {v.duration}s, Audio: {audio_duration}s")
+
+        if v.duration < audio_duration:
+            print(f"[Video] Bouclage nécessaire ({v.duration}s -> {audio_duration}s)")
+            v = v.fx(vfx.loop, duration=audio_duration)
+        elif v.duration > audio_duration:
+            print(f"[Video] Découpage nécessaire ({v.duration}s -> {audio_duration}s)")
+            v = v.subclip(0, audio_duration)
+
+        if plein_ecran:
+            print(f"[Video] Mode plein écran")
+            v = v.resize(newsize=(W, H)).set_position(("center", "center"))
+        else:
+            print(f"[Video] Mode incrustation, position: {position}")
+            v = v.resize(width=520)
+            pos_map = {
+                "bottom-right": ("right", "bottom"),
+                "bottom-left": ("left", "bottom"),
+                "top-right": ("right", "top"),
+                "top-left": ("left", "top"),
+                "center": ("center", "center"),
+            }
+            v = v.set_position(pos_map.get(position, ("right", "bottom")))
+
+        print(f"[Video] ✅ Vidéo préparée avec succès")
+        return v
+
+    except Exception as e:
+        print(f"[Video] ❌ Erreur préparation: {e}")
+        print(f"[Video] Traceback: {traceback.format_exc()}")
+        return None
+
+def write_srt(text, duration):
+    parts = re.split(r'(?<=[\.!?])\s+', text.strip())
+    parts = [p for p in parts if p]
+    total = len("".join(parts)) or 1
+    cur = 0.0
+    srt = []
+    for i, p in enumerate(parts, 1):
+        prop = len(p)/total
+        start = cur
+        end = min(duration, cur + duration*prop)
+        cur = end
+        def ts(t):
+            m, s = divmod(t, 60)
+            h, m = divmod(m, 60)
+            return f"{int(h):02}:{int(m):02}:{int(s):02},000"
+        srt += [f"{i}", f"{ts(start)} --> {ts(end)}", p, ""]
+    path = os.path.join(OUT_DIR, f"srt_{uuid.uuid4().hex[:6]}.srt")
+    open(path, "w", encoding="utf-8").write("\n".join(srt))
+    return path
+
+def write_video_with_fallback(final_clip, out_path_base, fps=25):
+    attempts = [
+        {"ext": ".mp4", "codec": "libx264", "audio_codec": "aac"},
+        {"ext": ".mp4", "codec": "mpeg4",  "audio_codec": "aac"},
+        {"ext": ".mp4", "codec": "libx264", "audio_codec": "libmp3lame"},
+    ]
+    ffmpeg_params = ["-pix_fmt", "yuv420p", "-movflags", "+faststart", "-threads", "1", "-shortest"]
+    last_err = None
+    for opt in attempts:
+        out = out_path_base if out_path_base.endswith(opt["ext"]) else out_path_base + opt["ext"]
+        try:
+            final_clip.write_videofile(
+                out,
+                fps=fps,
+                codec=opt["codec"],
+                audio_codec=opt["audio_codec"],
+                audio=True,
+                ffmpeg_params=ffmpeg_params,
+                logger=None,
+                threads=1,
+            )
+            if os.path.exists(out) and os.path.getsize(out) > 150000:
+                return out
+        except Exception as e:
+            last_err = f"{type(e).__name__}: {e}"
+    raise RuntimeError(last_err or "FFmpeg a échoué")