video_processor.py

# video_processor.py
# ─────────────────────────────────────────────────────────────────────────────
# Pipeline vidéo : source (YouTube/local) → transcription Whisper → plan de
# clips (LLM ou séquentiel aligné sur les phrases) → analyse visages (YuNet)
# restreinte aux fenêtres retenues → rendu ffmpeg en une passe (crop + fond
# flou + sous-titres + hook + barre de progression + watermark + loudnorm +
# audio) → découpe en clips.
# ─────────────────────────────────────────────────────────────────────────────
import asyncio
import os
import re
import shutil
import subprocess
import tempfile
import traceback
from pathlib import Path

import cv2
from yt_dlp import YoutubeDL

import utils
from utils import get_downloads_dir, safe_rmtree

_YUNET_MODEL = utils.ASSETS_DIR / "models" / "face_detection_yunet_2023mar.onnx"


class VideoProcessor:
    """
    MVP minimal et non configurable.
    - Sortie fixe: 1080x1920 (9:16), H.264/AAC, loudnorm -14 LUFS
    - Confiance détection visage: 0.80 (YuNet)
    - Marge de sécurité: 15 px
    - Clips ≤ 61s alignés sur les fins de phrases (ou sélectionnés par LLM
      si ANTHROPIC_API_KEY est défini), coupes exactes via keyframes forcées
    """
    _OUT_W = 1080
    _OUT_H = 1920
    _MIN_CONF = 0.80
    _MARGIN_PX = 15
    _DETECTION_STEP = 10
    _CLIP_SECONDS = 61
    _MIN_CLIP_SECONDS = 10
    _HOOK_SECONDS = 3.0
    _PUNCH_INTERVAL = 4.0   # punch-in : alternance de zoom toutes les N secondes
    _PUNCH_ZOOM = 1.08      # niveau de zoom (1.0 = désactivé)
    _MUSIC_VOLUME = 0.20    # volume de la musique de fond avant ducking
    _WM_WIDTH_RATIO = 0.20  # largeur du watermark (fraction de la largeur de sortie)
    _WM_MARGIN_X = 24       # marge droite du watermark (px)
    _WM_MARGIN_Y = 40       # marge basse (px) — au-dessus de la barre de progression
    _WM_OPACITY = 0.80      # opacité du watermark (1.0 = opaque)
    _WM_DARK_LUMA = 90      # luminance moyenne (0-255) sous laquelle la vidéo
                            # est jugée sombre → black-watermark.png

    # Bornes de progression cumulées par phase
    _P_SOURCE = 0.10      # téléchargement / chargement
    _P_TRANSCRIBE = 0.32  # transcription Whisper
    _P_PLAN = 0.36        # sélection des clips (LLM ou séquentiel)
    _P_ANALYSIS = 0.45    # analyse visages (restreinte aux clips retenus)
    _P_RENDER = 0.90      # rendu ffmpeg
    _P_CLIPS = 0.98       # découpe en clips

    def __init__(self, log_callback, progress_callback, done_callback):
        # Callbacks (doivent être thread-safe : appelés depuis des threads workers)
        self.log = log_callback
        self.update_progress = progress_callback
        self.done_callback = done_callback

        # État / fichiers
        self.tmp_dir = tempfile.mkdtemp(prefix="yt_dl_")
        self.output_video: str | None = None
        self.audio_path: str | None = None
        self.video_path: str | None = None
        self.title: str | None = None
        self.author: str | None = None
        self.description_tiktok: str | None = None
        self.hashtag: list[str] = []
        self.clips: list[str] = []
        self.clips_meta: list[dict] = []
        self.error: str | None = None
        self._src_w = 0
        self._src_h = 0
        self._src_fps = 25.0
        self._mean_luma: float | None = None  # mesurée pendant analyze_faces

    # ---------- IO ----------
    def download_youtube_video(self, url: str) -> None:
        """Télécharge la vidéo (mp4) et l'audio séparément via yt-dlp."""
        self.log("📥 [1/6] Téléchargement de la vidéo depuis YouTube…")
        common = {
            "quiet": True,
            "noprogress": True,
            "no_warnings": True,
            # Réessaie automatiquement en cas d'erreur transitoire (403/timeout)
            "retries": 3,
            "fragment_retries": 3,
        }

        video_opts = {
            **common,
            "format": "bestvideo[ext=mp4]/bestvideo/best",
            "outtmpl": os.path.join(self.tmp_dir, "video.%(ext)s"),
        }
        with YoutubeDL(video_opts) as ydl:
            info = ydl.extract_info(url, download=True)
            self.video_path = ydl.prepare_filename(info)

        self.log(f"   ✓ Vidéo récupérée : {info.get('title')}")
        self.title = re.sub(r'[\\/*?:"<>|]', "_", info.get("title") or "video")
        self.author = info.get("uploader") or ""
        self.hashtag = re.findall(r"#\w+", info.get("description") or "")

        self.log("🎧 Récupération de la piste audio…")
        audio_opts = {
            **common,
            "format": "bestaudio[ext=m4a]/bestaudio",
            "outtmpl": os.path.join(self.tmp_dir, "audio.%(ext)s"),
        }
        with YoutubeDL(audio_opts) as ydl:
            audio_info = ydl.extract_info(url, download=True)
            self.audio_path = ydl.prepare_filename(audio_info)

    def load_local_video(self, path: str) -> None:
        """Prépare un fichier vidéo local et extrait l'audio AAC temporaire."""
        p = Path(path)
        if not p.exists():
            raise FileNotFoundError(f"Fichier introuvable: {path}")
        self.log(f"📂 [1/6] Chargement du fichier local : {p.name}")
        self.video_path = str(p)
        self.title = p.stem
        self.author = ""
        self.hashtag = []

        self.log("🎧 Extraction de la piste audio…")
        audio_out = os.path.join(self.tmp_dir, f"{p.stem}.m4a")
        extract_cmd = ["ffmpeg", "-y", "-i", str(p), "-vn", "-acodec", "aac", audio_out]
        subprocess.run(extract_cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
        self.audio_path = audio_out

    # ---------- Probing ----------
    def _probe_duration(self, path: str) -> float:
        """Durée (s) via ffprobe."""
        cmd = [
            "ffprobe", "-v", "error", "-show_entries", "format=duration",
            "-of", "default=noprint_wrappers=1:nokey=1", path,
        ]
        res = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
        try:
            return float((res.stdout or "0").strip())
        except Exception:
            return 0.0

    # ---------- Smart crop : analyse ----------
    def _probe_video_meta(self) -> None:
        """Lit largeur/hauteur/fps de la source (sans scanner les frames)."""
        assert self.video_path, "Chemin vidéo introuvable"
        cap = cv2.VideoCapture(self.video_path)
        self._src_w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH) or 0)
        self._src_h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT) or 0)
        fps = float(cap.get(cv2.CAP_PROP_FPS) or 0.0)
        self._src_fps = fps if fps > 0 else 25.0
        cap.release()

    def analyze_faces(
        self, segments: list[tuple[float, float]] | None = None
    ) -> list[tuple[float, float, float]]:
        """
        Scanne la vidéo (frames sous-échantillonnées) avec YuNet (OpenCV) et
        retourne des échantillons (timestamp, x_min, x_max) englobant tous les
        visages de chaque frame. Le plan de recadrage par clip est calculé
        ensuite via _compute_crop_plan().

        :param segments: intervalles (start, end) en secondes — timeline
                         ORIGINALE — à analyser (seek direct sur chacun).
                         None → toute la vidéo.
        """
        in_path = self.video_path
        assert in_path, "Chemin vidéo introuvable"
        if not _YUNET_MODEL.exists():
            raise FileNotFoundError(
                f"Modèle YuNet introuvable: {_YUNET_MODEL} — voir assets/models/"
            )
        where = "dans les clips retenus" if segments else "dans la vidéo"
        self.log(f"👤 Repérage des visages {where} (cadrage vertical)…")

        cap = cv2.VideoCapture(in_path)
        W = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH) or 0)
        H = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT) or 0)
        n_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0)
        fps = float(cap.get(cv2.CAP_PROP_FPS) or 0.0)
        self._src_w, self._src_h = W, H
        self._src_fps = fps if fps > 0 else 25.0
        fps = self._src_fps

        # Plages de frames à scanner (toute la vidéo si segments absent)
        if segments:
            ranges = [(max(0, int(a * fps)), int(b * fps) + 1) for a, b in segments]
        else:
            ranges = [(0, n_frames if n_frames > 0 else (1 << 31))]
        total_to_scan = max(1, sum(b - a for a, b in ranges))

        small_w = 320
        small_h = max(1, int(H * small_w / max(1, W)))
        detector = cv2.FaceDetectorYN.create(
            str(_YUNET_MODEL), "", (small_w, small_h),
            self._MIN_CONF, 0.3, 50,
        )

        samples: list[tuple[float, float, float]] = []
        frames_seen = 0
        scanned = 0
        luma_sum = 0.0  # luminosité moyenne → choix de la watermark

        for f0, f1 in ranges:
            if f0 > 0:
                cap.set(cv2.CAP_PROP_POS_FRAMES, f0)
            i = f0 - 1
            while i < f1 - 1:
                i += 1
                ok = cap.grab()
                if not ok:
                    break
                scanned += 1
                if self._DETECTION_STEP > 1 and (i % self._DETECTION_STEP) != 0:
                    continue
                ok, frame = cap.retrieve()
                if not ok:
                    break
                frames_seen += 1

                # Progression réelle de l'analyse dans la tranche [PLAN, ANALYSIS)
                if frames_seen % 20 == 0:
                    ratio = min(1.0, scanned / total_to_scan)
                    self.update_progress(
                        self._P_PLAN + ratio * (self._P_ANALYSIS - self._P_PLAN)
                    )

                small = cv2.resize(frame, (small_w, small_h))
                luma_sum += float(cv2.cvtColor(small, cv2.COLOR_BGR2GRAY).mean())
                _, faces = detector.detect(small)
                if faces is None or len(faces) == 0:
                    continue

                scale = W / small_w
                x_min, x_max = float(W), 0.0
                for face in faces:
                    x = float(face[0]) * scale
                    bw = float(face[2]) * scale
                    x_min = min(x_min, x)
                    x_max = max(x_max, x + bw)
                samples.append((i / fps, max(0.0, x_min), min(float(W), x_max)))

        cap.release()

        if frames_seen:
            self._mean_luma = luma_sum / frames_seen

        if samples:
            self.log("   ✓ Visages repérés — le cadrage suivra les personnes à l'écran")
        else:
            self.log("   ✓ Analyse terminée — pas de visage détecté, cadrage centré")
        return samples

    def _compute_crop_plan(
        self,
        windows: list[dict],
        samples: list[tuple[float, float, float]],
    ) -> tuple[int, int, list[tuple[float, float, int]]]:
        """
        Plan de recadrage dynamique : une largeur de crop constante (contrainte
        ffmpeg : taille de frame fixe) et une position x PAR CLIP, centrée sur
        les visages détectés dans la fenêtre — au lieu d'un crop global timide
        qui devait garder tous les visages de toute la vidéo dans le cadre.

        :return: (crop_w, x_défaut, [(start, end, x)]) — timestamps de la même
                 timeline que `windows` et `samples`.
        """
        W, H = self._src_w, self._src_h
        if not samples or W <= 0:
            return W, 0, []

        ideal_w = min(W, int(H * 9 / 16))  # largeur d'un cadrage 9:16 plein écran

        spans: list[tuple[float, float] | None] = []
        for w in windows:
            sel = [s for s in samples if w["start"] <= s[0] <= w["end"]]
            if sel:
                spans.append((min(s[1] for s in sel), max(s[2] for s in sel)))
            else:
                spans.append(None)

        needed = [(b - a) + 2 * self._MARGIN_PX for sp in spans if sp for a, b in [sp]]
        if not needed:
            return W, 0, []

        crop_w = int(min(W, max(ideal_w, max(needed))))
        default_x = (W - crop_w) // 2

        plan: list[tuple[float, float, int]] = []
        for w, sp in zip(windows, spans):
            if sp is None:
                x = default_x
            else:
                a, b = sp
                lo = max(0, int(b + self._MARGIN_PX) - crop_w)
                hi = min(int(a - self._MARGIN_PX), W - crop_w)
                hi = max(lo, hi)
                x = int((a + b) / 2 - crop_w / 2)
                x = max(lo, min(x, hi))
                x = max(0, min(x, W - crop_w))
            plan.append((w["start"], w["end"], x))

        self.log("   ✓ Cadrage ajusté clip par clip, centré sur les visages")
        return crop_w, default_x, plan

    # ---------- Plan de clips ----------
    def _sequential_windows(self, sentences: list[dict], total: float) -> list[dict]:
        """Fenêtres contiguës ≤ 61s dont les fins coïncident avec des fins de phrases."""
        points: list[float] = []
        start = 0.0
        while total - start > self._CLIP_SECONDS + 0.5:
            limit = start + self._CLIP_SECONDS
            candidates = [
                s["end"] for s in sentences
                if start + self._MIN_CLIP_SECONDS < s["end"] <= limit
            ]
            cut = max(candidates) if candidates else limit
            points.append(cut)
            start = cut
        bounds = [0.0] + points + [total]
        return [
            {"start": a, "end": b, "hook": self.title or "", "description": None, "hashtags": None}
            for a, b in zip(bounds, bounds[1:])
        ]

    def plan_clips(self, sentences: list[dict], total: float, context: str = "") -> list[dict]:
        """
        Plan de découpe : sélection des meilleurs passages via l'API Claude si
        ANTHROPIC_API_KEY est défini, sinon découpage séquentiel aligné sur les
        fins de phrases.
        """
        windows = utils.select_best_clips(
            sentences, total_duration=total, context=context, log=self.log
        )
        if windows:
            self.log(f"   ✓ {len(windows)} moments forts retenus par l'IA")
            return windows
        windows = self._sequential_windows(sentences, total)
        self.log(
            f"   ✓ Vidéo découpée en {len(windows)} clips "
            f"({', '.join(f'{w['end'] - w['start']:.0f}s' for w in windows)})"
        )
        return windows

    # ---------- Rendu ----------
    @staticmethod
    def _escape_filter_path(path: str) -> str:
        """Échappe un chemin pour un filtre ffmpeg (subtitles=...)."""
        return path.replace("\\", "\\\\").replace(":", "\\:").replace("'", "\\'")

    def render_final(
        self,
        ass_filepath: str,
        crop_w: int,
        default_x: int,
        crop_plan: list[tuple[float, float, int]],
        windows: list[dict],
        keep_segments: list[tuple[float, float]] | None,
        duration: float,
    ) -> None:
        """
        Rendu final en une seule passe ffmpeg :
        jump cuts (select/aselect) + crop dynamique par clip + fond flou
        éventuel + saturation/netteté + sous-titres (avec hooks) + barre de
        progression par clip + audio loudnorm -14 LUFS.
        Keyframes forcées aux frontières de clips → découpe exacte en stream copy.

        :param crop_plan: [(start, end, x)] positions de crop par clip (timeline post-coupes).
        :param keep_segments: segments à conserver (timeline ORIGINALE) pour les
                              jump cuts, ou None pour garder toute la vidéo.
        :param duration: durée attendue de la sortie (timeline post-coupes).
        """
        self.log("🎬 [4/6] Montage de la vidéo (cadrage, sous-titres, effets, audio)…")
        in_path = self.video_path
        assert in_path, "Chemin vidéo introuvable"
        W, H = self._src_w, self._src_h
        ow, oh = self._OUT_W, self._OUT_H

        sub_filter = f"subtitles='{self._escape_filter_path(ass_filepath)}'"
        if utils.FONTS_DIR.is_dir():
            sub_filter += f":fontsdir='{self._escape_filter_path(str(utils.FONTS_DIR))}'"

        grade = "eq=saturation=1.15:contrast=1.05,unsharp=5:5:0.5"

        # Jump cuts : suppression des silences (timeline originale), puis
        # regénération de timestamps continus (timeline compressée)
        cut_v = cut_a = ""
        if keep_segments:
            expr = "+".join(
                f"between(t\\,{a:.4f}\\,{b:.4f})" for a, b in keep_segments
            )
            cut_v = f"select='{expr}',setpts=N/FRAME_RATE/TB,"
            cut_a = f"aselect='{expr}',asetpts=N/SR/TB,"

        # Crop dynamique : position x par clip (expression sur t, timeline post-coupes)
        x_expr = str(default_x)
        for s, e, x in reversed(crop_plan):
            x_expr = f"if(between(t\\,{s:.3f}\\,{e:.3f})\\,{x}\\,{x_expr})"

        # Punch-ins : zoom alterné (1.0 ↔ _PUNCH_ZOOM) toutes les _PUNCH_INTERVAL s
        # à l'intérieur de chaque clip — appliqué AVANT les sous-titres pour ne
        # pas faire pulser le texte. `it` = timestamp d'entrée de zoompan.
        punch = ""
        if windows and self._PUNCH_ZOOM > 1.0:
            z_expr = "1"
            for w in windows:
                s, e = w["start"], w["end"]
                z_expr = (
                    f"if(between(it\\,{s:.3f}\\,{e:.3f})\\,"
                    f"if(mod(floor((it-{s:.3f})/{self._PUNCH_INTERVAL:g})\\,2)\\,"
                    f"{self._PUNCH_ZOOM:g}\\,1)\\,{z_expr})"
                )
            z_expr = f"if(isnan(it)\\,1\\,{z_expr})"
            punch = (
                f"zoompan=z='{z_expr}':x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)':"
                f"d=1:s={ow}x{oh}:fps={self._src_fps:g},"
            )

        new_h = int(H * ow / max(1, crop_w))
        if new_h >= oh:
            # La zone croppée remplit la hauteur : crop vertical centré
            chain = (
                f"[0:v]{cut_v}crop={crop_w}:{H}:x='{x_expr}':y=0,scale={ow}:-2,"
                f"crop={ow}:{oh},{grade},{punch}{sub_filter}"
            )
        else:
            # Hauteur insuffisante : fond flou plein cadre + overlay centré
            chain = (
                f"[0:v]{cut_v}split=2[bg][fg];"
                f"[bg]scale={ow}:{oh}:force_original_aspect_ratio=increase,"
                f"crop={ow}:{oh},gblur=sigma=12[bgb];"
                f"[fg]crop={crop_w}:{H}:x='{x_expr}':y=0,scale={ow}:-2[fgs];"
                f"[bgb][fgs]overlay=(W-w)/2:(H-h)/2,{grade},{punch}{sub_filter}"
            )

        # Barre de progression par clip (drawbox animé sur t, activé par fenêtre)
        for w in windows:
            s, e = w["start"], w["end"]
            d = max(0.1, e - s)
            chain += (
                f",drawbox=x=0:y=ih-14:w='iw*clip((t-{s:.3f})/{d:.3f}\\,0\\,1)':h=14:"
                f"color=white@0.85:t=fill:enable='between(t,{s:.3f},{e:.3f})'"
            )
        # Chaîne audio : voix normalisée -14 LUFS (standard TikTok), et musique
        # de fond éventuelle bouclée + duckée sous la voix (sidechaincompress)
        voice = (
            f"[1:a]{cut_a}loudnorm=I=-14:TP=-1.5:LRA=11,"
            "aresample=48000,aformat=channel_layouts=stereo"
        )
        music_path = utils.pick_music_track()
        if music_path:
            self.log(f"🎵 Musique de fond ajoutée : {Path(music_path).stem} (atténuée sous la voix)")
            audio_chain = (
                voice + "[voice];"
                "[voice]asplit=2[vmix][vsc];"
                f"[2:a]aresample=48000,aformat=channel_layouts=stereo,"
                f"volume={self._MUSIC_VOLUME:g}[music];"
                "[music][vsc]sidechaincompress="
                "threshold=0.03:ratio=12:attack=50:release=500[duck];"
                "[vmix][duck]amix=inputs=2:duration=first:"
                "dropout_transition=0:normalize=0[a]"
            )
        else:
            audio_chain = voice + "[a]"

        inputs = ["-i", in_path, "-i", self.audio_path]
        if music_path:
            inputs += ["-stream_loop", "-1", "-i", music_path]

        # Watermark : incrustée en bas à droite, au-dessus de la barre de
        # progression — variante black/white selon la luminosité de la vidéo
        dark = None if self._mean_luma is None else self._mean_luma < self._WM_DARK_LUMA
        wm_path = utils.pick_watermark(dark)
        if wm_path:
            tone = "" if dark is None else (" (vidéo sombre)" if dark else " (vidéo claire)")
            self.log(f"💧 Watermark ajoutée : {Path(wm_path).name}{tone}")
            wm_idx = 3 if music_path else 2  # index d'input du watermark
            inputs += ["-i", wm_path]
            wm_w = int(self._OUT_W * self._WM_WIDTH_RATIO)
            chain += (
                f"[vmain];[{wm_idx}:v]scale={wm_w}:-1,format=rgba,"
                f"colorchannelmixer=aa={self._WM_OPACITY:g}[wm];"
                f"[vmain][wm]overlay=W-w-{self._WM_MARGIN_X}:H-h-{self._WM_MARGIN_Y}"
            )

        filter_complex = chain + "[v];" + audio_chain

        # Keyframes exactement aux frontières de clips (coupes stream copy exactes)
        boundaries = sorted({w["start"] for w in windows} | {w["end"] for w in windows})
        keyframes = ",".join(f"{t:.3f}" for t in boundaries)

        output = os.path.join(self.tmp_dir, f"{Path(in_path).stem}_final.mp4")
        cmd = [
            "ffmpeg", "-y",
            *inputs,
            "-filter_complex", filter_complex,
            "-map", "[v]", "-map", "[a]",
            "-c:v", "libx264", "-preset", "medium", "-crf", "18",
            "-pix_fmt", "yuv420p",
            "-force_key_frames", keyframes if keyframes else "0",
            "-c:a", "aac", "-b:a", "192k",
            "-shortest", "-movflags", "+faststart",
            "-progress", "pipe:1", "-nostats", "-loglevel", "error",
            output,
        ]

        total = max(0.001, duration)
        stderr_log = os.path.join(self.tmp_dir, "ffmpeg_render.log")
        next_milestone = 25  # jalons de log : 25 %, 50 %, 75 %
        with open(stderr_log, "w") as err_file:
            proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=err_file, text=True)
            for line in proc.stdout:
                if line.startswith("out_time_us="):
                    try:
                        t = int(line.split("=", 1)[1]) / 1_000_000
                    except ValueError:
                        continue
                    ratio = min(1.0, t / total)
                    if next_milestone <= 75 and ratio * 100 >= next_milestone:
                        self.log(f"   … montage : {next_milestone} %")
                        next_milestone += 25
                    self.update_progress(
                        self._P_ANALYSIS + ratio * (self._P_RENDER - self._P_ANALYSIS)
                    )
            proc.wait()

        if proc.returncode != 0:
            tail = Path(stderr_log).read_text()[-2000:]
            raise RuntimeError(f"ffmpeg a échoué pendant le rendu final : {tail}")

        self.output_video = output
        self.log("   ✓ Montage terminé")

    # ---------- Clips ----------
    def cut_into_clips(self, windows: list[dict]) -> list[str]:
        """Découpe la vidéo finale selon le plan de clips (stream copy, coupes
        exactes grâce aux keyframes forcées au rendu)."""
        if not self.output_video or not os.path.exists(self.output_video):
            self.log("Avertissement: aucune vidéo de sortie trouvée pour le découpage.")
            return []

        self.log(f"✂️ [5/6] Export des {len(windows)} clips…")
        clips_dir = get_downloads_dir() / "clips"
        clips_dir.mkdir(parents=True, exist_ok=True)

        default_desc = f"{self.title} - {self.author}\n{' '.join(self.hashtag[:3])}"
        output_clips: list[str] = []
        self.clips_meta = []
        for index, w in enumerate(windows, start=1):
            clip_path = clips_dir / f"clip_{index:02d}.mp4"
            cut_cmd = [
                "ffmpeg", "-y",
                "-ss", f"{w['start']:.3f}",
                "-i", self.output_video,
                "-t", f"{w['end'] - w['start']:.3f}",
                "-c", "copy",
                "-avoid_negative_ts", "make_zero",
                "-movflags", "+faststart",
                str(clip_path),
            ]
            subprocess.run(cut_cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
            output_clips.append(str(clip_path))
            self.clips_meta.append(
                {
                    "path": str(clip_path),
                    "hook": w.get("hook") or self.title or "",
                    "description": w.get("description") or default_desc,
                    "hashtags": w.get("hashtags") or self.hashtag[:5],
                    "virality_score": w.get("virality_score"),
                }
            )
            self.log(f"   ✓ Clip {index}/{len(windows)} prêt ({w['end'] - w['start']:.0f}s)")

        self.log(f"   ✓ {len(output_clips)} clips enregistrés dans {clips_dir}")
        self.clips = output_clips
        return output_clips

    def _persist_output(self) -> str | None:
        """Déplace la vidéo finale vers ~/Downloads/final et retourne le chemin persistant.
        Évite que Streamlit pointe vers un fichier supprimé lors du nettoyage du répertoire temporaire.
        """
        downloads = get_downloads_dir()
        out_dir = downloads / "final"
        out_dir.mkdir(parents=True, exist_ok=True)
        if not self.output_video:
            return None
        src = Path(self.output_video)
        if not src.exists():
            return None
        base = re.sub(r'[\\/*?:"<>|]', "_", (self.title or src.stem))
        dest = out_dir / f"{base}.mp4"
        i = 1
        while dest.exists():
            dest = out_dir / f"{base}_{i:02d}.mp4"
            i += 1
        shutil.move(str(src), str(dest))
        self.output_video = str(dest)
        return self.output_video

    # ---------- Orchestration ----------
    async def process(self, source: str) -> None:
        """Pipeline fixe sans paramètres personnalisables."""
        self.log("🚀 Démarrage du montage")
        try:
            self.update_progress(0.0)

            # 1) Source
            if source.lower().startswith(("http://", "https://")):
                self.download_youtube_video(source)
            else:
                self.load_local_video(source)
            self.update_progress(self._P_SOURCE)

            # 2) Transcription Whisper (l'analyse visages viendra APRÈS la
            # sélection des clips, restreinte aux fenêtres retenues)
            self._probe_video_meta()
            self.log("🎙️ [2/6] Transcription de la voix pour les sous-titres…")
            ass_filepath, sentences = await asyncio.to_thread(
                utils.generate_styled_subtitles, self.audio_path
            )
            self.log("   ✓ Sous-titres générés")
            self.update_progress(self._P_TRANSCRIBE)

            total = self._probe_duration(self.video_path)

            # 2bis) Jump cuts : suppression des silences → timeline intermédiaire
            # utilisée pour planifier les clips. Le remap des sous-titres attend
            # la timeline FINALE (étape 3bis).
            keep_speech = utils.compute_keep_segments(
                sentences, total, fps=self._src_fps
            )
            if keep_speech:
                self.log(
                    f"✂️ Silences supprimés : "
                    f"{total - sum(b - a for a, b in keep_speech):.0f}s de gagnées "
                    f"sur la vidéo"
                )
            else:
                keep_speech = [(0.0, max(0.001, total))]  # identité : rien à couper
            tmap_speech = utils.TimeMap(keep_speech)
            sentences = utils.remap_sentences(sentences, tmap_speech)

            # 3) Plan de clips (LLM si clé API, sinon séquentiel aligné phrases)
            self.log("🧠 [3/6] Sélection des meilleurs moments…")
            context = " — ".join(x for x in (self.title, self.author) if x)
            windows = await asyncio.to_thread(
                self.plan_clips, sentences, tmap_speech.new_total, context
            )
            self.update_progress(self._P_PLAN)

            # 3bis) Timeline finale : seuls les segments appartenant aux clips
            # seront encodés (les silences ET le hors-clips sont écartés du rendu).
            keep_segments, windows = utils.restrict_to_windows(
                windows, tmap_speech, fps=self._src_fps
            )
            if not keep_segments or not windows:
                raise RuntimeError("Aucun contenu de clip à encoder (plan de clips vide)")
            tmap = utils.TimeMap(keep_segments)
            self.log(
                f"   ✓ Durée finale du montage : {tmap.new_total:.0f}s "
                f"(sur {total:.0f}s de vidéo d'origine)"
            )

            # 3ter) Analyse des visages restreinte aux fenêtres retenues
            # (timeline ORIGINALE), puis remap vers la timeline finale
            face_samples = await asyncio.to_thread(self.analyze_faces, keep_segments)
            face_samples = [(tmap.map(t), a, b) for t, a, b in face_samples]

            # Toute la source est conservée (bornes en timeline ORIGINALE) →
            # pas besoin du filtre select
            if (
                len(keep_segments) == 1
                and keep_segments[0][0] <= 0.05
                and keep_segments[0][1] >= total - 0.5
            ):
                keep_segments = None
            utils.remap_ass(ass_filepath, tmap)
            total = tmap.new_total

            # 3quater) Mots-clés surlignés + hooks incrustés (3 premières secondes)
            self.log("✨ Ajout des accroches et mots-clés surlignés dans les sous-titres…")
            utils.highlight_keywords(ass_filepath, windows)
            # Départ avancé de 0,1s avant la frontière du clip : garantit que le
            # hook est visible dès la frame 0 du clip découpé (couverture TikTok)
            # malgré les arrondis de découpe.
            hooks = [
                (max(0.0, w["start"] - 0.10),
                 min(w["start"] + self._HOOK_SECONDS, w["end"]),
                 w.get("hook") or self.title or "")
                for w in windows
            ]
            utils.add_hook_events(ass_filepath, hooks)

            # 3quinquies) Plan de recadrage dynamique par clip
            crop_w, default_x, crop_plan = self._compute_crop_plan(windows, face_samples)
            self.update_progress(self._P_ANALYSIS)

            # 4) Rendu final en une passe
            await asyncio.to_thread(
                self.render_final, ass_filepath, crop_w, default_x, crop_plan,
                windows, keep_segments, total,
            )
            self.update_progress(self._P_RENDER)

            # 5) Découpe en clips
            self.cut_into_clips(windows)
            self.update_progress(self._P_CLIPS)

            # 6) Déplacer la vidéo finale dans un emplacement persistant (Downloads/final)
            self.log("📦 [6/6] Enregistrement de la vidéo finale…")
            self._persist_output()

            # 7) Description globale (les descriptions par clip sont dans clips_meta)
            self.description_tiktok = f"{self.title} - {self.author} \n{' '.join(self.hashtag[:3])}"
            self.update_progress(1.0)

            self.log("✅ Montage terminé ! Vidéo et clips prêts.")
            if self.output_video:
                self.done_callback(self.output_video)
        except Exception as exc:
            self.error = str(exc)
            self.log(f"❌ Erreur pendant le montage : {exc}")
            self.log(traceback.format_exc())
        finally:
            # Nettoyage strict: ne supprimer que le répertoire temporaire alloué par l'instance
            if self.tmp_dir and os.path.isdir(self.tmp_dir):
                safe_rmtree(self.tmp_dir)