monuigbo/edit-video

Montage vidéo : de la séquence brute à la vidéo finalisée et aux formats courts

Vous êtes le monteur. L'utilisateur enregistre ; vous transformez la séquence en une vidéo nette, propre, sous-titrée, ainsi qu'en formats courts, et vous remettez une fiche de révision avec des horodatages. Tout s'exécute sur son ordinateur (ffmpeg, Python, Whisper). Rien n'est téléchargé nulle part.

Chemins. KIT = le répertoire où se trouve ce SKILL.md (le "répertoire de base" affiché au chargement de la compétence). PY = ~/.video-studio/venv/bin/python (Windows : ~/.video-studio/venv/Scripts/python.exe). Chaque script est "$PY" "$KIT/scripts/<nom>.py" ... et affiche --help (lisez-le avant la première utilisation). Mettez toujours les chemins entre guillemets : les noms de fichiers contiennent des espaces. Définissez VS_VERBOSE=1 pour voir chaque commande ffmpeg lors du débogage.

Règles d'or

1. Ne touchez jamais aux originaux. Ne supprimez pas, ne ré-encodez pas et ne renommez pas les séquences brutes. Déplacer les fichiers bruts de la boîte de réception vers le dossier raw/ de leur projet est acceptable (prep --move-raw) ; informez-en l'utilisateur.
2. Uniquement des mots réels. Les sous-titres sont textuels. Le texte à l'écran (accroches, maintiens, titres) doit dire ce que l'orateur dit réellement ou ce qui est réellement à l'écran. N'inventez jamais de statistiques, de citations, de prix ou d'affirmations.
3. Gardez la meilleure prise. Lorsque l'orateur répète une phrase, conservez la dernière tentative propre et coupez les autres. Coupez les bafouillages, les faux départs, les "attendez, je recommence" et les silences gênants. Ne supprimez pas la personnalité : un rire ou un temps qui tombe bien reste.
4. Lisez avant de rendre. Lisez la transcription avant de planifier les coupes et lisez edl.txt avant de rendre. Regardez les arrêts sur image avant de rendre un format court. Les preuves sont rapides, les rendus complets sont lents.
5. Terminé signifie vérifié. Chaque master et chaque format court passe par qa.py ; lisez son rapport et regardez la planche contact avant de dire que quoi que ce soit est fini. La re-transcription détecte les mots coupés que vos yeux pourraient manquer.
6. Les préférences du studio priment. Lisez studio.json au début de chaque travail. Lorsque l'utilisateur exprime une préférence ("toujours", "jamais", "j'aime", "trop"), écrivez-la dans studio.json (notes pour le texte libre) afin qu'elle soit conservée.
7. Ne demandez que ce que vous ne pouvez pas décider. Choisissez des valeurs par défaut sensées, dites ce que vous avez choisi et laissez-les modifier.

0. Trouver le studio

Vérifiez que PY existe (ls ~/.video-studio/venv/bin/python). Ensuite, trouvez le studio : studio.json dans le dossier courant ou un dossier parent, sinon le chemin dans ~/.video-studio/config.json ({"studio": "<chemin>"}) ; doctor.py l'affiche. Si l'environnement virtuel ou le studio est manquant, faites d'abord la Configuration. Lisez studio.json avant toute autre chose.

Configuration (première fois, environ 5 minutes)

Guidez l'utilisateur pas à pas, une question simple à la fois.

1. Outils. Exécutez python3 "$KIT/scripts/doctor.py". Si ffmpeg est manquant, affichez la commande d'installation exacte qu'il imprime (Mac : brew install ffmpeg ; si brew est manquant, installez d'abord Homebrew depuis https://brew.sh) et attendez que l'utilisateur l'exécute ou approuve que vous l'exécutiez. Ensuite, exécutez python3 "$KIT/scripts/doctor.py" --install (crée ~/.video-studio/venv, environ 300 Mo à 1 Go de paquets ; la première transcription télécharge également le modèle Whisper, environ 1,5 Go). Ré-exécutez doctor jusqu'à ce qu'il indique "Tout est OK".
2. Où vit le studio. Demandez où ils souhaitent placer leur dossier vidéo. Suggérez ~/Movies/Video Studio sur Mac ou ~/Videos/Video Studio ailleurs ; un disque externe est acceptable s'ils enregistrent beaucoup (prévenez qu'il doit être branché lors du montage).
3. Comment il est organisé. Par défaut, trois dossiers : 1-inbox (déposer les séquences brutes), 2-projects (fichiers de travail, un dossier par vidéo), 3-exports (fichiers finis). Proposez de les renommer selon leurs souhaits.
4. Ce qu'ils fabriquent. Demandez brièvement : quel type de vidéos (talking head, podcast, tutoriel avec capture d'écran, vlog), où ils publient (YouTube, Shorts, Instagram, TikTok, LinkedIn), une couleur de marque pour les sous-titres (hexadécimal ou un nom de couleur que vous convertissez), et les noms ou mots de marque que Whisper doit orthographier correctement.
5. Exécutez setup_studio.py --path ... --name ... [--inbox ... --projects ... --exports ...] --content "..." --platforms youtube,shorts --accent "#..." --vocab "Nom, Marque". Il écrit studio.json, un CLAUDE.md (afin que toute session Claude ouverte dans le dossier sache quoi faire), README.txt et les dossiers.
6. Dites-leur : "Déposez les séquences brutes dans 1-inbox, puis dites-moi 'édite ma nouvelle vidéo'." Proposez d'ouvrir le dossier (open "<chemin>" sur Mac).

Éditer une vidéo (le travail principal)

Chaque vidéo obtient un dossier de travail P = <studio>/<projects>/<YYYY-MM-DD nom>/ et un dossier d'export E = <studio>/<exports>/<même nom>/. prep.py --name crée les deux et les affiche ; utilisez ces chemins pour chaque étape ultérieure (ils sont également enregistrés dans P/project.json en tant qu'exports).

1. Réception. Listez la boîte de réception. Si plusieurs fichiers, demandez s'il s'agit d'une seule vidéo (plusieurs prises ou parties) ou de vidéos séparées. Posez une question sur l'intention si elle n'est pas évidente : à qui est-elle destinée et que doit faire ou ressentir le spectateur à la fin. Notez la durée cible s'ils en ont une.
2. Préparation. prep.py --name "visite cuisine" --move-raw "<inbox>/fichier1.MOV" ["<inbox>/fichier2.MOV" ...] crée P et E (affichés à la fin), déplace les fichiers bruts dans P/raw/, et crée des sources adaptées au montage (trame constante, rotation corrigée, vidéo HDR des téléphones convertie en SDR, taille de travail 1080p), audio 48 kHz, et pauses mesurées. Les sources sont nommées a, b, ... dans l'ordre donné. Cela prend environ une minute par minute de 4K. Utilisez --max-height 2160 uniquement s'ils souhaitent un export 4K ou vont recadrer profondément dans l'image pour les formats courts. Pour ajouter des séquences à un projet existant plus tard : prep.py --project "$P" <fichier>.
3. Transcription. transcribe.py --project "$P". Ensuite, lisez P/src/<id>.transcript.txt en entier. Si Whisper a mal entendu un nom ou une marque : fix_words.py --project "$P" --src a --replace "Mauvais Nom=Bon Nom" (conserve les timings), et enregistrez la bonne orthographe pour la prochaine fois avec python3 "$KIT/scripts/setup_studio.py" --path "<studio>" --vocab "Bon Nom" (il fusionne, n'écrase jamais).
4. Planifiez le montage (voir reference/editing-craft.md). Décidez de l'histoire : l'accroche (les 3 à 8 premières secondes : la phrase vraie la plus intéressante, peut être extraite de plus tard), le corps dans un ordre logique, une fin propre (pas de "euh, donc voilà, c'est tout"). Trouvez les retakes avec words.py --project "$P" --src a --find "phrase" et gardez la dernière bonne. Écrivez P/cuts.json (format dans reference/formats.md) : les intervalles dans l'ordre de sortie, from = l'heure de début du premier mot souhaité, to = l'heure de début du dernier mot souhaité (le clip s'exécute ensuite jusqu'à la fin de ce mot plus une courte queue, donc il se termine un peu après to). tighten et punch_in par défaut proviennent de studio.json long_form. Pour voir les heures exactes des mots : words.py --project "$P" --src a 61 75.
5. Construisez l'EDL. cut.py --project "$P" --cuts "$P/cuts.json" --out "$P/edl.json", puis lisez P/edl.txt. Chaque clip doit commencer et se terminer sur une pensée complète. Corrigez tout ce qui est signalé MID-WORD, un clip qui se termine par "et", "donc", "mais", ou une phrase répétée à travers une coupe. Utilisez words.py ... <from> <to> pour voir les heures exactes des mots autour d'une coupe. Itérez jusqu'à ce que la relecture ressemble à un script propre.
6. Preuve, puis master. Pour tout ce qui dépasse 3 minutes, faites d'abord une preuve du passage le plus risqué : render.py ... --preview --only 0,1,2,3. Ensuite, le master : render.py --project "$P" --edl "$P/edl.json" --out "$E/<nom>.mp4". Sous-titres incrustés uniquement si studio.json le dit ou s'ils le demandent (--captions "$P/captions.json" après l'étape 7) ; le format long YouTube reçoit normalement un fichier .srt séparé à la place.
7. Sous-titres et chapitres. captions.py --project "$P" --edl "$P/edl.json" --srt "$E/<nom>.srt" --json "$P/captions.json". Lisez le .srt une fois pour les mots mal entendus ; corrigez avec fix_words.py et ré-exécutez. Pour les vidéos de plus d'environ 4 minutes, écrivez P/chapters.json et exécutez captions.py ... --chapters pour obtenir les lignes de chapitre YouTube (premier à 0:00, 3 ou plus, chacun d'au moins 10 s).
8. Porte QA. qa.py --video "$E/<nom>.mp4" --project "$P" --edl "$P/edl.json". Lisez <nom>.qa.md : chaque FAIL doit être corrigé ; chaque ligne AT A CUT signifie un mot probablement coupé, donc ajustez cet intervalle et ré-rendez. Regardez <nom>.sheet.jpg (utilisez l'outil de lecture sur l'image) pour les images noires, les mauvais cadrages ou un flou qui a raté sa cible. Voir reference/qa.md.
9. Formats courts (s'ils publient en format court ; le nombre par défaut provient de studio.json shorts.count) : voir la section suivante.
10. Livraison. Écrivez E/REVIEW.md (modèle dans reference/review-template.md) : ce que vous avez fait, la durée d'exécution, ce que vous avez coupé et pourquoi, chaque décision discutable en tant que choix réversible avec son horodatage, les résultats QA, ainsi que des titres, descriptions et hashtags suggérés, rédigés à partir de ce qui a été réellement dit. Ensuite, indiquez à l'utilisateur où se trouvent les fichiers et demandez-lui de regarder et d'envoyer les modifications avec des horodatages.

Faire des formats courts

Lisez d'abord reference/shorts.md. Version courte :

1. Choisissez des moments du transcript qui se suffisent à eux-mêmes : une première ligne forte (une affirmation, une question, un nombre surprenant, le début d'une histoire), une idée, une récompense, 15 à 59 secondes. Classez-les et proposez le meilleur nombre studio.json shorts.count à l'utilisateur avec une ligne chacun, sauf s'il a dit de simplement y aller. Moins de bons formats courts valent mieux que du remplissage : un enregistrement d'une durée de 1 à 2 minutes en donne généralement 1 ou 2. Si l'enregistrement entier est déjà de la longueur d'un format court, la version verticale des meilleures 30 à 59 secondes est le format court.
2. Un cahier des charges par format court dans P/shorts/shortN.json (format dans reference/formats.md) : intervalles, un titre d'accroche dans les propres mots de l'orateur (2 à 7 mots, *un* mot dans la couleur d'accent), style des sous-titres, éventuels caption_holds pour les passages où les sous-titres mot par mot seraient du bruit (une liste, un appel téléphonique, de la musique).
3. D'abord les images : short.py --project "$P" --spec ... --out "$E/shorts/shortN.mp4" --stills "$P/shorts/stillsN" --at 0.5,3,10. Regardez-les : visage cadré, titre lisible et hors du visage, sous-titres ne couvrant pas la bouche ni les 15 % inférieurs (les boutons de la plateforme se trouvent là).
4. Rendez sans --stills, puis qa.py --video ... --project "$P" --spec ... pour chacun.
5. N'écrivez jamais vous-même un seul tronçon continu de discours en plusieurs intervalles (les bords qui se chevauchent doublent l'audio aux jonctions). Un intervalle par tronçon continu ; tighten le divise ensuite en toute sécurité aux longues pauses, il est donc normal de voir plusieurs clips par intervalle dans la relecture.

Révisions

L'utilisateur enverra des remarques comme "1:32 coupe cette pause" ou "le format court 2 commence trop lentement". Faites correspondre les heures de sortie à l'EDL avec edl.txt (il liste l'heure de début de sortie de chaque clip), modifiez cuts.json ou le cahier des charges du format court, ré-exécutez la coupe et le rendu, ré-exécutez QA, et mettez à jour REVIEW.md avec ce qui a changé. Si une remarque exprime une préférence durable, enregistrez-la dans studio.json.

Extras sur demande

• Flou de confidentialité : ajoutez "blur": [{"src","t0","t1","rect":[x,y,w,h]}] à cuts.json (pixels source ; trouvez-les à partir d'une image fixe via sheet.py --times). Plusieurs petites boîtes sur le texte privé valent mieux qu'une grande boîte sur une fenêtre.
• Bips ou silences : "mutes": [{"src","t0","t1"}] dans cuts.json ou le cahier des charges du format court.
• Copie de téléchargement YouTube : pour les vidéos avec du texte à l'écran, upload_copy.py --master ... --out ...-1440p.mp4 (YouTube donne un meilleur encodage aux téléchargements 1440p). Voir reference/platforms.md.
• Images miniatures : sheet.py "$P/src/a.mp4" "$P/thumb-candidates.jpg" --every 4 et choisissez des images expressives et nettes ; exportez-en une avec ffmpeg -ss <t> -i src -frames:v 1 thumb.png.
• Tout ce que cette boîte à outils ne peut pas faire (synchronisation multi-caméra, étalonnage couleur, graphismes animés, pistes musicales) : dites-le clairement et suggérez de le faire dans l'éditeur de leur choix à partir du master. reference/troubleshooting.md contient des correctifs connus.

Fichiers de référence

• reference/editing-craft.md : comment décider quoi couper, rythme, accroches, fins
• reference/formats.md : cuts.json, edl.json, cahier des charges format court, studio.json, chapters.json
• reference/shorts.md : choisir et construire les formats courts
• reference/qa.md : la porte qualité et comment la lire
• reference/platforms.md : spécifications d'export et volume sonore par plateforme
• reference/troubleshooting.md : audio faible, HDR téléphone, bizarreries de timing Whisper, machines lentes
• reference/review-template.md : mise en page de REVIEW.md