Montage vidéo avec FFmpeg en langage naturel

ffmpeg-skill

Les scripts se trouvent dans scripts/ à côté de ce fichier ; exécutez-les avec python3 <chemin-du-dossier>/scripts/<nom>.py, et les modèles de livraison dans templates/. Ce fichier suffit pour effectuer un travail : le tableau ci-dessous oriente la requête, et --help sur le script sur le point d'être exécuté est la liste complète des options la plus rapide. Un fichier de référence coûte autant que celui-ci ; n'en ouvrez un que pour une question que vous avez : references/scripts.md (tous les drapeaux des 42 scripts), references/devices.md (iPhone HDR, GoPro, DJI, enregistrements d'écran, Zoom), references/gotchas.md (la forme longue des règles en une ligne à la fin). MCP : tools/list n'affiche par défaut que les 12 scripts de base ; les 30 autres (selon ce tableau) restent appelables par leur nom via tools/call, décrits par contract --json ; définissez FFMPEG_SKILL_MCP_FULL=1 pour les 42.

Drapeaux partagés (tous les scripts) : --dry-run ; --json (chemin de sortie, son sondage, les commandes exécutées) ; --json-brief (statut/sortie/vérifié + un summary ; privilégiez lors des étapes d'écriture) ; --fast (qualité d'aperçu) ; --progress (pourcentage/ETA) ; --timeout SECONDES (kind: timeout, défaut 1800) ; --overwrite (étape 7) ; --plan FICHIER (un render.py FILE dry run exécuté plus tard ; refuse si une entrée a changé). Les outils de ré-encodage prennent également --hw (GPU Apple Silicon, gros fichiers ; FFMPEG_SKILL_HW=1 = défaut, pas d'export), --codec h264|hevc|av1|prores et --quality N : non défini, SDR est x264 (cut.py --keep-hevc : source HEVC reste HEVC), HDR est x265 Main10 ; prores nécessite -o NOM.mov, h264 refuse HDR (color.py --to-sdr d'abord).

Les outils d'écriture n'exécutent rien sous --dry-run ; les outils de mesure (probe, check, sync, multicam, scenes, cropdetect, report, silence, loudness, stabilize ; overlay pour un --text multi-lignes sur FFmpeg 8.0-8.1.0) peuvent quand même exécuter ffmpeg/ffprobe, en sautant les artefacts/fichiers annexes (--edl, --sheet, un .ass généré) ; verify ignore le drapeau. Par outil : contract --json dry_run.

Flux de travail (dans cet ordre)

0. Environnement, seulement en cas d'échec. Ne démarrez jamais un travail avec doctor : une machine défaillante échoue avec kind: missing_tool ou une erreur ffmpeg nommant le filtre/encodeur. Exécutez python3 <chemin-du-dossier>/scripts/_contract.py doctor (ou npx ffmpeg-skill doctor) après un tel échec, ou lorsqu'on vous demande ce que la machine peut faire : lisez ok/usable, signalez la capacité manquante. Le schéma d'outil de contract --json est destiné à un agent planificateur, pas à ce workflow.
1. Sondez ce que vous devez planifier. Exécutez probe.py sur chaque entrée que vous planifiez — durée, fps, résolution, codecs, canaux, variable_frame_rate_suspected — et chaque fois que l'utilisateur pose une question sur un fichier. Pas de sondage séparé avant chaque édition : le --json de chaque outil d'écriture contient déjà son entrée et un sondage de la sortie. Planifiez à partir de nombres réels, jamais d'hypothèses.
2. Privilégiez la perte. Si la requête peut être satisfaite sans ré-encodage (coupes sur des images-clés, remuxage, modifications audio uniquement), ne ré-encodez pas. cut.py et loudness.py copient le flux vidéo par défaut ; --accurate sur cut.py uniquement pour des coupes image par image.
3. Planifiez avec --dry-run --json, puis exécutez. Faites confiance à --json, pas à la ligne de résumé d'un dry run, pour tout nombre dans le plan (une dimension peut y être un espace réservé). Utilisez avant les longs encodages, pour rapporter des faits. Ne pointez jamais -o vers un fichier que vous n'avez pas créé dans ce travail, sauf si l'utilisateur a demandé son remplacement ; ne passez --overwrite que dans ce cas.
4. Chaînez dans un ordre logique. Une demande de livraison sans autre édition est une exécution de modèle unique (render.py --template NOM ENTREE), pas une chaîne construite à la main. Sinon : couleur (HDR→SDR / LUT) → coupe → jointure → silence → ajustement → légende/superposition → synchronisation → audio → volume → export. Les changements d'image avant les légendes, pour que le texte soit dimensionné pour l'image finale. Ré-encodez le moins de fois possible : intermédiaires à CRF 18, export.py en dernier. Trois étapes ou plus : render.py avec un project.json.
5. Vérifiez le livrable. Avant de faire rapport, exécutez check.py SORTIE --plateforme X pour la destination nommée (une exécution de modèle le fait déjà). Les lignes de format (codec, format de pixel, taille, pic réel, balises de couleur, VFR) sont sûres à corriger. Les lignes de jugement changent le contenu : durée (la coupe perd du matériel), aspect (le recadrage perd des bords), fps (perd du mouvement), volume (l'ambiance ne doit pas être augmentée) — ne corrigez que lorsque la requête implique la réponse, sinon énoncez le choix et son coût. Mentionnez les WARNs ; ne les poursuivez pas.
6. Vérifiez la sortie. Confirmez que la durée, la résolution, les fps et l'audio correspondent à la requête, à partir du sondage --json/--json-brief de l'outil d'écriture ou de probe.py, et rapportez ces nombres ("final.mp4 : 59,98 s, 1080x1920, 30 ips, AAC stéréo"). Une étape est terminée uniquement lorsque le script s'est terminé avec 0 et que la sortie est sondée comme attendu : un code de retour non nul, un fichier manquant ou vide, ou un sondage qui contredit la requête est un échec rapporté avec le message d'erreur du script.
7. Conservez les originaux de l'utilisateur. N'écrasez jamais la source ; écrivez de nouveaux fichiers à côté de l'entrée ou à l'endroit demandé. Un chemin de sortie existant est refusé (kind: input) ; --overwrite est la seule façon de dire "oui, remplacez-le".
8. Regardez l'image. Chaque fois que l'image change (légendes, superpositions, graphismes, recadrage/bordure, redimensionnement, couleur, transitions, un join.py redimensionnant un clip au cadre du premier clip, color.py --to-sdr), exécutez look.py SORTIE --tiles 3x2 (ou --at T pour une seule image) et visualisez le PNG (4x3 pour une disposition de tout le clip). Pas terminé tant que Look: ne nomme pas ce PNG — un sondage ne peut pas voir une légende sur un visage. Audio uniquement : Look: not needed. Ce qu'il faut chercher se divise comme les lignes de check.py à l'étape 5 :
   • Mécanique (le travail de cette compétence pour vérifier et rapporter) : le texte/logo spécifié est à la position spécifiée, les sous-titres apparaissent aux horodatages spécifiés, les dimensions sont paires. Le letterboxing de fit.py --fit pad est le résultat correct de ce mode, jamais un défaut à signaler.
   • Jugement (signalez-le, ne le passez pas ou ne l'échouez pas silencieusement) : si un sujet ou un visage est coupé, le texte recouvre un visage, les couleurs semblent délavées, une transition atterrit. Ceux-ci nécessitent de décider ce qu'est le sujet est, l'appel de l'agent appelant — dites ce que vous voyez en une ligne ; ils jugent. Sans capacité de vision, écrivez Look: CHEMIN (pixels non inspectés ; l'agent n'a pas de vue d'image) — ne prétendez jamais qu'une image a été inspectée quand ce n'est pas le cas, sans attendre une capacité qui n'existe pas.

Avant d'exécuter quoi que ce soit : que demander, quoi supposer

Posez une question courte uniquement lorsque la réponse modifie sensiblement la sortie et que la requête ne l'implique pas. Lorsque plusieurs éléments sont ouverts en même temps (un vague "fais-le pour les réseaux sociaux" laisse la destination, l'aspect, la durée et les légendes ouverts), ne demandez pas un par tour : proposez un ensemble avec vos valeurs par défaut et laissez l'utilisateur modifier n'importe quelle partie ("Reels : 9:16 avec bordures, 60 s, -14 LUFS, pas de légendes — OK ?"). Une question, une réponse, puis l'exécution. Ne demandez jamais ce que probe.py peut vous dire.

• Destination détermine l'aspect, la limite de durée, le volume et le codec ; "pour Reels" répond aux quatre et nomme un modèle. Pas de destination et une simple coupe/légende : conservez le format source et dites-le. Si l'utilisateur dit "exporte", "poste" ou "livre", demandez où.
• Durée ("fais-le de 60 s") sans méthode : accélérez pour les changements ≤1,5×, coupez sinon, dites lequel. Demandez quand le contenu est une conversation (couper perd des mots) et que le changement est important.
• Légendes sans source de texte : --transcribe si un moteur local existe, sinon demandez le texte ou un fichier temporisé ; n'inventez jamais de dialogue.
• Polices et marque : si l'utilisateur mentionne une marque, des couleurs ou "notre police", demandez ou créez brand.json une fois, réutilisez-le.
• Texte CJK / non latin : laissez l'outil choisir la police par script (--font le désactive) ; --lang ja|ko pour le texte Han uniquement. doctor --json .fonts.scripts indique ce qui rend ici. Tofu est un travail échoué.
• Position de recadrage pour --fit crop : centrée par défaut, mais lorsque la requête ou la source nomme un sujet décentré ("gardez le produit à droite", quelqu'un visiblement décentré dans la fiche), utilisez --crop-x/--crop-y (0=gauche/haut, 1=droite/bas) au lieu de deviner le centre, ou demandez quel bord conserver.
• Tout le reste (type de transition, style de légende) : choisissez la valeur par défaut conventionnelle, dites ce que vous avez choisi, proposez l'alternative en une ligne.

Ce que cette compétence fait et ne décide pas

Cette compétence coupe, joint, mesure, synchronise, exporte et vérifie des fichiers — elle exécute une édition, elle ne la décide pas. Ce qui appartient à l'humain, à l'agent appelant ou à une autre compétence :

• Quelle coupe est correcte, ou si un livrable est approuvable — cette compétence mesure et rapporte (check.py's PASS/WARN/FAIL, cut.py's erreur de durée) ; l'utilisateur ou l'agent de production décide si cela est livré.
• Ce qui rend un moment fort intéressant — scenes.py --highlights classe par un proxy mesuré (énergie audio, durée) : candidats, pas un verdict.
• Composition de la miniature ou de la couverture — une décision de conception, pas une mesure.
• Comprendre ce qu'est une vidéo à propos — il n'y a pas de vision ici au-delà des fiches contact de look.py, pour les yeux de l'agent appelant, pas pour que cette compétence interprète.
• Juger ce qui est beau — "applique cette LUT", "corrige l'exposition de +0,3 stops" (color.py) est mécanique ; "étalonne cette scène pour qu'elle soit cinématographique" appartient à une compétence d'étalonnage (color-grading-skill) qui décide des paramètres, puis appelle color.py.
• Les mots dans une légende — le texte de la queue est brûlé tel qu'écrit. Trop long pour le cadre signifie une taille plus petite, --max-lines, ou l'édition par l'utilisateur ; ne réécrivez, raccourcissez ou paraphrasez jamais, même lorsqu'on vous demande de "faire tenir" — dites-le, proposez --max-lines 1 à une taille plus petite.
• Choisir un sujet ou une région qui ne vous a pas été donnée — "recadrer à x=200,y=0" est mécanique une fois que la boîte est connue ; "recadrer pour garder l'orateur dans le cadre" nécessite de décider ce qu'est l'orateur, un jugement pour l'agent appelant (à partir d'une fiche look.py).

La ligne : même entrée + mêmes paramètres explicites produisant toujours la même sortie vérifiable appartient ici ; tout ce qui dépend du goût, de la compréhension ou de ce qui semble bon appartient à celui qui porte ce jugement.

Si une requête nécessite une fonctionnalité FFmpeg qu'aucun des 42 scripts n'expose, dites-le et nommez l'option intégrée la plus proche — ne devinez jamais une invocation brute ffmpeg/ffprobe en dehors de scripts/*.py. Cela contourne toutes les garanties offertes par cette compétence, donc ce n'est jamais un recours.

Requête → script

Ce tableau et la liste tools de doctor --json sont la source de vérité sur ce qui existe : ne nommez qu'un script que vous avez vu dans l'un d'eux (il n'y a pas de doctor.py, trim.py, subtitle.py).

Les drapeaux d'horodatage (--start, --end, --at, --from, --duration, --offset, et les temps dans les fichiers de repère et de chapitre) prennent des secondes, mm:ss(.fff), hh:mm:ss(.fff) ou SMPTE hh:mm:ss:ff avec @fps (00:01:02:[email protected]) — collez une feuille de repère NLE telle quelle ; les drapeaux de longueur (--min-silence, --margin, --fade) sont en secondes.

L'utilisateur dit	Faites
"coupe de 1:20 à 2:05", "rogne les 10 premières s"	cut.py entree.mp4 --start 1:20 --end 2:05
"garde seulement ces parties", "enlève le milieu"	cut.py entree.mp4 --segments 0-1:00,1:30-2:00
"fais-le exactement de 60 secondes"	fit.py entree.mp4 --duration 60 (vitesse) ou --method trim
"coupe ça et fais-le en HEVC / AV1 / ProRes" (codec de sortie nommé)	cut.py entree.mp4 --start 0:10 --end 0:40 --codec hevc (ProRes nécessite -o NOM.mov)
"enlève les pauses", "coupures sèches"	silence.py entree.mp4 [--threshold -40 --min-silence 0.8]
"enlève les euh et les hum", "supprime les mots de remplissage"	silence.py entree.mp4 --filler --words mots.json (horodatages de mots mesurés ; --transcribe les crée)
"ne coupe pas à l'intérieur d'une phrase, seulement les vraies pauses"	silence.py entree.mp4 --speech-aware — une respiration sous --min-silence à l'intérieur d'une phrase est conservée, seules les pauses en fin de phrase sont coupées ; se compose avec --filler en une seule liste
"un moment fort de 60 s à partir de cette heure"	scenes.py long.mp4 --highlights 6 --target 60 --edl picks.txt → cut.py --segments
"coupe sur le tempo", "édite-le en musique"	scenes.py track.mp4 --beats --json > beats.json, puis cut.py entree.mp4 --segments ... --snap beats --snap-source beats.json (--snap-source transporte la grille mesurée)
"accélère ici, ralentis là" (segments connus)	speedramp.py action.mp4 --segment 0-3:1.0 --segment 3-4:0.25 --segment 4-8:2.0
"tiens cette image", "fige la dernière image"	freeze.py clip.mp4 --hold 2
"ralenti fluide", "moitié vitesse mais fluide"	fit.py entree.mp4 --duration 2x --smooth interpolate (lent) ou --smooth blend
"inverse ce clip"	reverse.py entree.mp4
"boucle ce clip pour remplir 30 secondes"	loop.py bg_loop.mp4 --duration 30
"fais-le vertical / 9:16 / carré"	fit.py entree.mp4 --aspect 9:16 --fit pad (ou --fit crop ; --pad-fill blur pour des barres floues)
"redimensionne à une hauteur/largeur"	fit.py entree.mp4 --height 1080 (ou --width, ou les deux pour une image exacte)
"recadre à cette boîte exacte" (x/y/w/h connus)	crop.py entree.mp4 --x 100 --y 0 --width 1080 --height 1920
"fond flou au lieu de barres noires"	fit.py entree.mp4 --aspect 9:16 --fit blur (image entière conservée, bordures d'une copie floutée et assombrie)
"tourne de 90 degrés", "miroir"	fit.py entree.mp4 --rotate 90 / fit.py entree.mp4 --flip h
"l'horizon est penché" (degrés connus)	straighten.py penche.mp4 --degrees -2.5
"vue plate de cette vidéo 360" (yaw/pitch/fov connus)	sphere.py insta360.mp4 --yaw 90 --pitch 0 --h-fov 100 --v-fov 70
"ce vieux métrage est entrelacé"	deinterlace.py entree.mp4
"c'est granuleux/bruyant, nettoie-le"	denoise.py entree.mp4 --strength medium
"floute/pixellise ce visage/plaque" (boîte connue)	redact.py entree.mp4 --x 820 --y 140 --width 240 --height 240 --mode pixelate
"enlève ce logo fixe" (boîte connue)	redact.py entree.mp4 --x 40 --y 20 --width 180 --height 60 --mode delogo
"stabilise ce métrage tremblant"	stabilize.py entree.mp4
"y a-t-il des barres noires là-dessus ?"	cropdetect.py entree.mp4
"le clip iPhone Dolby Vision semble faux"	color.py entree.mp4 --to-sdr
"il fait trop sombre/clair, corrige l'exposition"	color.py entree.mp4 --exposure +0.3 (ou --brightness, --contrast, --saturation)
"ça tire vers le vert/bleu, corrige la balance des blancs"	color.py entree.mp4 --temperature -500 (ou --tint)
"applique cette LUT" (fichier .cube connu)	color.py entree.mp4 --lut /chemin/vers/lut.cube
"ajoute ce logo/watermark" (fichier PNG connu, position)	overlay.py entree.mp4 --image /chemin/vers/logo.png --position top-right
"ajoute ce texte au coin supérieur droit" / "un titre de tiers inférieur"	overlay.py entree.mp4 --text "Titre" --position top-right (ou laissez la position à défaut pour un tiers inférieur)
"ajoute des sous-titres (légendes incrustées)" (fichier .srt/.ass connu)	burn.py entree.mp4 --subtitles sous-titres.srt --style 'FontName=...'`
"ajoute des légendes style karaoké karaoké"	burn.py entree.mp4 --subtitles paroles.srt --style 'FontName=...,Outline=...,...' --karaoke
"ajoute des légendes, transcris la piste audio"	burn.py entree.mp4 --transcribe --style 'FontName=...'
"rend ce texte animé" (fichier .ass avec styles)	burn.py entree.mp4 --subtitles anim.ass (le fichier .ass contient déjà l'animation)
"ajoute des sous-titres (séparés, pas incrustés)"	burn.py entree.mp4 --subtitles sous-titres.srt --mode embed (les sous-titres sont intégrés, pas incrustés définitivement)
"ajoute une bordure de bande dessinée"	border.py entree.mp4 (par exemple --border avec des --args pour un style spécifique)
"ajuste la vitesse au ralenti / accéléré"	fit.py entree.mp4 --speed 0.5 (ralenti ; --speed 2.0 pour accéléré)
"rassemble tous les sous-titres dans un fichier"	report.py entree.mp4 --subtitle-stats > rapport_sous-titres.txt
"fais une bande-annonce des meilleures parties"	scenes.py entree.mp4 --highlights 5 --target 30 --edl picks.txt puis cut.py entree.mp4 --segments picks.txt
"normalise l'audio à -14 LUFS"	loudness.py entree.mp4 --target -14
"réduis les bruits de fond"	denoise.py entree.mp4 --noise-reduction audio
"remplace l'audio par ce fichier" (fichier connu)	audio.py entree.mp4 --replace /chemin/vers/nouvel_audio.wav
"mix cette musique en fond en baissant lorsque quelqu'un parle" (fichier de musique connu)	audio.py entree.mp4 --add /chemin/vers/musique.mp3 --volume -10 --duck
"exporte en HEVC pour YouTube"	export.py entree.mp4 --platform youtube --codec hevc
"prépare pour Instagram Reels"	render.py entree.mp4 --template reels (ou export.py entree.mp4 --platform instagram --aspect 9:16)
"contrôle la conformité pour TikTok"	check.py entree.mp4 --platform tiktok
"fais un montage vidéo complet" (plusieurs fichiers)	Créez un fichier project.json avec les étapes et exécutez render.py project.json
"génère une fiche contact pour inspecter le résultat"	Après avoir exécuté la commande d'édition principale : look.py sortie.mp4 --tiles 4x3
J'ai un projet d'édition complexe avec plusieurs clips	Utilisez render.py avec un project.json qui définit toutes les étapes
"donne-moi un résumé rapide du fichier"	report.py entree.mp4 --brief
"quels sont les sous-titres dans ce fichier ?"	report.py entree.mp4 --subtitle-stats
"affiche les métadonnées de ce fichier"	probe.py entree.mp4 --json
"convertir en .mp4" (ou tout autre conteneur)	cut.py entree.mov -o sortie.mp4 --stream-copy (pas de ré-encodage, seulement un changement de conteneur)
"prendre une capture d'écran à 0:30"	look.py entree.mp4 --at 0:30 -o capture.png
"diviser ce long enregistrement en chapitres"	scenes.py entree.mp4 --workspace ./chapitres (génère plusieurs clips)
"créer une vidéo time-lapse à partir de ces images"	Utilisez join.py avec des images en entrée (par exemple, une séquence d'images)
"assembler ces deux vidéos côte à côte"	Utilisez join.py avec le paramètre --layout side-by-side (ou un projet complexe dans render.py)
"corriger le métrage fisheye de cette GoPro"	Utilisez goPro.py (s'il existe) ou un outil de correction d'objectif dans color.py
"je n'ai besoin que de l'audio en .wav"	cut.py entree.mp4 --audio-only -o sortie.wav
"mélange les deux pistes audio en une seule"	audio.py entree.mp4 --merge-tracks
"ajouter un délai à la piste audio pour synchroniser"	sync.py entree.mp4 --offset -0.5
"synchroniser l'audio de cette caméra externe avec cette vidéo" (deux fichiers)	sync.py video.mp4 audio_externe.wav --output synced.mp4
"multicam : synchroniser ces 3 angles avec l'audio de la caméra A" (trois fichiers d'angles + fichier de projet)	multicam.py angleA.mp4 angleB.mp4 angleC.mp4 --audio angleA.mp4 --output --project multicam.json
"étalonner cette vidéo pour qu'elle ait l'air cinématographique"	Acheminez vers color-grading-skill ; celle-ci ne peut exécuter que des LUTs spécifiques (color.py --lut)
"rends-le plus lent mais reste fluide"	fit.py entree.mp4 --duration 2x --smooth interpolate
"est-ce que ça respecte les spécifications YouTube ?"	check.py sortie.mp4 --platform youtube
"quels sont les niveaux de volume (LUFS) ?"	loudness.py entree.mp4 --measure
"ce cachet est gênant sur le métrage GoPro"	Utilisez redact.py avec la boîte connue du cachet
"créer un arrêt sur image d'une durée de 2 secondes"	Utilisez freeze.py input.mp4 --hold 2
"redresser ce métrage incliné"	Utilisez straighten.py entree.mp4 --degrees -2.5

Scripts et leurs appels

Scripts de sonde et de rapport

• probe.py : Sonde un fichier multimédia et affiche les métadonnées (durée, fps, résolution, codecs, canaux audio, suspect VFR). python3 <chemin-du-dossier>/scripts/probe.py entree.mp4 --json
• report.py : Fournit un rapport détaillé sur un fichier multimédia, y compris les statistiques de sous-titres, s'il y en a. python3 <chemin-du-dossier>/scripts/report.py entree.mp4 --brief
• check.py : Vérifie la conformité d'un fichier vidéo pour une plateforme spécifique. python3 <chemin-du-dossier>/scripts/check.py sortie.mp4 --plateforme youtube
• loudness.py : Mesure ou normalise le volume audio (LUFS). python3 <chemin-du-dossier>/scripts/loudness.py entree.mp4 --measure (mesure) ou --target -14 (normalise).
• cropdetect.py : Détecte les barres noires et le recadrage nécessaire. python3 <chemin-du-dossier>/scripts/cropdetect.py entree.mp4

Scripts d'édition de base

• cut.py : Coupe, rogne ou extrait des segments d'un fichier vidéo/audio. python3 <chemin-du-dossier>/scripts/cut.py entree.mp4 --start 0:10 --end 0:40
• crop.py : Recadre une vidéo à une boîte spécifique. python3 <chemin-du-dossier>/scripts/crop.py entree.mp4 --x 100 --y 0 --width 1080 --height 1920
• fit.py : Ajuste une vidéo à des dimensions, un rapport d'aspect ou une durée spécifiques. python3 <chemin-du-dossier>/scripts/fit.py entree.mp4 --aspect 9:16 --fit pad
• speedramp.py : Crée des changements de vitesse variables sur des segments. python3 <chemin-du-dossier>/scripts/speedramp.py entree.mp4 --segment 0-3:1.0 --segment 3-4:0.25
• reverse.py : Inverse un clip vidéo/audio. python3 <chemin-du-dossier>/scripts/reverse.py entree.mp4
• freeze.py : Crée un arrêt sur image (fige). python3 <chemin-du-dossier>/scripts/freeze.py entree.mp4 --hold 2
• loop.py : Boucle un clip pour remplir une durée spécifiée. python3 <chemin-du-dossier>/scripts/loop.py entree.mp4 --duration 30
• stabilize.py : Stabilise un métrage tremblant. python3 <chemin-du-dossier>/scripts/stabilize.py entree.mp4
• straighten.py : Redresse une vidéo inclinée. python3 <chemin-du-dossier>/scripts/straighten.py entree.mp4 --degrees -2.5
• deinterlace.py : Désentrelace une vidéo entrelacée. python3 <chemin-du-dossier>/scripts/deinterlace.py entree.mp4
• denoise.py : Supprime le bruit/grain d'une vidéo. python3 <chemin-du-dossier>/scripts/denoise.py entree.mp4 --strength medium

Scripts de couleur et d'effets

• color.py : Ajuste les propriétés de couleur (exposition, température, LUT, conversion HDR→SDR). python3 <chemin-du-dossier>/scripts/color.py entree.mp4 --to-sdr
• redact.py : Floute, pixellise ou supprime des logos/visages (masquage). python3 <chemin-du-dossier>/scripts/redact.py entree.mp4 --x 800 --y 200 --width 200 --height 200 --mode pixelate
• overlay.py : Superpose du texte ou des images. python3 <chemin-du-dossier>/scripts/overlay.py entree.mp4 --text "Titre" --position top-right
• burn.py : Incruste des sous-titres (SRT/ASS) dans la vidéo. python3 <chemin-du-dossier>/scripts/burn.py entree.mp4 --subtitles sous-titres.srt --style 'FontName=...'
• border.py : Ajoute des bordures (par exemple, style bande dessinée). python3 <chemin-du-dossier>/scripts/border.py entree.mp4
• sphere.py : Extrait une vue plate d'une vidéo 360. python3 <chemin-du-dossier>/scripts/sphere.py entree.mp4 --yaw 90 --pitch 0 --h-fov 100 --v-fov 70

Scripts audio

• silence.py : Supprime les silences ou les mots de remplissage. python3 <chemin-du-dossier>/scripts/silence.py entree.mp4 [--threshold -40 --min-silence 0.8]
• audio.py : Remplace, ajoute ou mixe des pistes audio. python3 <chemin-du-dossier>/scripts/audio.py entree.mp4 --replace /chemin/vers/nouvel_audio.wav

Scripts avancés

• sync.py : Synchronise une piste audio avec une vidéo. python3 <chemin-du-dossier>/scripts/sync.py video.mp4 audio_externe.wav --output synced.mp4
• multicam.py : Synchronise plusieurs angles de caméra avec une piste audio de référence. python3 <chemin-du-dossier>/scripts/multicam.py angleA.mp4 angleB.mp4 angleC.mp4 --audio angleA.mp4 --project multicam.json
• scenes.py : Détecte les changements de scène, les moments forts, ou les beats. python3 <chemin-du-dossier>/scripts/scenes.py entree.mp4 --highlights 5 --target 30 --edl picks.txt
• join.py : Assemble plusieurs clips (concatène ou côte à côte). python3 <chemin-du-dossier>/scripts/join.py clip1.mp4 clip2.mp4 clip3.mp4

Scripts de sortie et de workflow

• look.py : Génère des fiches contact ou des captures d'écran pour inspection visuelle. python3 <chemin-du-dossier>/scripts/look.py sortie.mp4 --tiles 4x3
• render.py : Exécute un projet d'édition complet à partir d'un fichier project.json. python3 <chemin-du-dossier>/scripts/render.py project.json
• export.py : Exporte une vidéo pour une plateforme spécifique avec des paramètres optimisés. python3 <chemin-du-dossier>/scripts/export.py entree.mp4 --plateforme youtube --codec hevc
• verify.py : Vérifie l'intégrité d'un fichier après traitement. python3 <chemin-du-dossier>/scripts/verify.py sortie.mp4

Conclusion

Cette compétence est un outil puissant et flexible pour l'automatisation de l'édition vidéo et audio en local à l'aide de FFmpeg. Elle est conçue pour être fiable, reproductible et pour responsabiliser l'utilisateur ou l'agent appelant en se concentrant sur l'exécution mécanique plutôt que sur la prise de décision subjective.

Reportez-vous à references/ pour des informations détaillées sur les scripts, les appareils et les conseils de dépannage.