tokentalentlabs/TTL-Media

Rognage vidéo

Transformez un enregistrement brut en un premier montage qu'un éditeur humain approuverait : chaque reprise et faux pas éliminé, le rythme naturel du locuteur intact, aucun mot tronqué, chaque jonction se lisant comme la phrase que le locuteur voulait dire. Cela fonctionne pour n'importe quel créneau, format et langue que les moteurs de reconnaissance vocale comprennent : les règles concernent la façon dont les gens parlent, non pas de quoi ils parlent. Les différences de format et de langue (style de pause, démos, interviews, lieux bruyants, locuteurs non anglophones) se trouvent dans references/formats.md.

Cette compétence ne concerne que la phase de rognage : une source audio/caméra en entrée, une timeline mono-piste en sortie. Placer un enregistrement d'écran, des images de coupe ou des graphiques par-dessus est une phase ultérieure ; elle peut réutiliser segments.json (les entrées/sorties source exactes de chaque segment conservé) pour couper d'autres pistes en synchronisation.

Ce qui est coupé, et ce qui ne l'est jamais

Coupé (erreurs) : reprises (la dernière prise gagne), faux départs, approches abandonnées, bégaiements et mots doublés, sons de remplissage (« euh », « hum », « eh », demi-mots comme « par- »), erreurs corrigées par le locuteur, marmonnements, choses que le locuteur dit à l'éditeur de supprimer à l'écran, et blancs (longs silences, pauses avec seulement respiration/clics).

Gardé : pauses naturelles (moins d'~1 s), la formulation du locuteur même maladroite, opinions, histoires, blagues, répétition rhétorique qui construit (« c'est ce que font les pros, c'est ce que font ceux qui gagnent »), lignes qui pointent vers quelque chose à l'écran, moments de démonstration que le spectateur doit voir, et tout ce qui n'a pas de reprise.

Pas de ressort de cette compétence : coupes créatives (supprimer une histoire, une digression, une revendication de sponsor pour le rythme). Un éditeur humain peut les faire ; ne les imitez pas et ne les signalez pas. Si l'utilisateur vous montre plus tard la version de l'éditeur, apprenez-en uniquement les leçons sur les erreurs, pas les leçons créatives.

Pourquoi cette séparation : les utilisateurs de cette compétence sont des éditeurs. Un premier montage qui ne supprime que les erreurs est quelque chose en quoi ils ont confiance et sur lequel ils peuvent construire ; un montage qui prend aussi des décisions de goût les oblige à tout revérifier.

Règles complètes avec exemples réels : lisez references/cutting-rules.md avant d'écrire des coupes. C'est le cœur de cette compétence.

Configuration (une fois par machine)

Python 3.10+, ffmpeg, et :

pip install numpy soundfile num2words torch torchaudio
# moteur vocal principal : NVIDIA Parakeet (anglais + 24 langues européennes)
pip install parakeet-mlx                  # Apple Silicon (sur le GPU)
pip install "nemo_toolkit[asr]"           # Windows/Linux avec un GPU NVIDIA
# Whisper : utilisé par l'analyse des écarts (on peut lui demander d'écrire les « euh »/« hum ») et pour les langues que Parakeet ne couvre pas
pip install mlx-whisper                   # Apple Silicon
pip install faster-whisper                # autre chose
pip install uroman                        # uniquement pour les langues en écriture non latine (hindi, arabe, japonais, …)

Le premier lancement télécharge Parakeet (~1,2 Go), Whisper large-v3 (~3 Go) et l'aligneur MMS (~1,2 Go).

Pourquoi Parakeet : sur un enregistrement test de 41 minutes avec 9 reprises cachées connues (des répétitions qu'une transcription ordinaire fusionne en une ligne nette, ce qui avait nécessité des vérifications supplémentaires et des corrections), Parakeet en a entendu 8 et Whisper 1. Parakeet écrit aussi les marmonnements (« Mm-hmm ») que Whisper ignore, et le passage verbatim a pris 3 minutes au lieu d'environ 11. Chaque moteur manque encore quelques bégaiements d'un mot que l'autre entend (« Parce que… Parce que »), c'est pourquoi la vérification par réécoute et l'analyse des écarts restent. Le choix du moteur est automatique (config "asr" : "auto") ; définissez "parakeet" ou "whisper" pour en forcer un.

Flux de travail

Travaillez dans un « dossier de coupe » (un par enregistrement). Les scripts se trouvent dans le dossier scripts/ de cette compétence ; exécutez-les avec python <competence>/scripts/<nom>.py <dossier de coupe>.

1. Importation (2 min)

• Copiez assets/config.example.json dans <dossier de coupe>/config.json ; définissez title, source (le fichier caméra, avec son audio), timeline_fps (la fréquence d'images de livraison ; la fréquence source est détectée) et language (code de langue : « en », « es », « hi », … ou « auto »). Laissez les chiffres de timing tranquilles, sauf si le format nécessite un style de pause différent (references/formats.md) : chacun est le résultat d'une vraie erreur (references/edges-and-pauses.md).
• Notez le format (solo, scripté, tutoriel, podcast, court-métrage…) et lisez sa ligne dans references/formats.md.
• Extrayez l'audio : ffmpeg -i <fichier caméra> -vn -ac 1 -ar 16000 <dossier de coupe>/audio.wav
• Si un profil de locuteur existe (profiles/<locuteur>.md, voir ci-dessous), lisez-le maintenant.

2. Transcription verbatim (~5 s par minute d'audio avec Parakeet ; lancez-la tout de suite, en arrière-plan)

python scripts/transcribe_verbatim.py <coupe>/audio.wav <coupe>/verbatim.json

Ce n'est pas une transcription ordinaire. Un passage complet et ordinaire cache de nombreux bégaiements et reprises (« parce que le, parce que le » revient comme « parce que le » ; Whisper en a caché environ un tiers) et ses temps de mots ne sont qu'à peu près corrects, ce qui tronque les fins de mots. Ce passage transcrit de petits morceaux séparés aux pauses, puis aligne de force chaque mot sur l'audio. Chaque coupe est placée sur ces temps de mots.

3. Trouver les candidats

Exécutez les trois, puis lisez leur sortie avec la transcription :

• python scripts/make_reading_copy.py <coupe> : écrit reading.txt, la transcription avec chaque mot numéroté.
• python scripts/retake_finder.py <coupe> : chaque endroit où le locuteur redémarre avec les mêmes mots d'ouverture. La plupart sont des reprises (gardez la dernière prise) ; certains sont des répétitions rhétoriques (gardez les deux). Décidez pour chacun.
• python scripts/gap_scan.py <coupe> : réécoute chaque long écart qui contient du son. Des redémarrages marmonnés s'y cachent (« La batterie dure- la batterie dure ») ; la transcription les saute souvent.

4. Lire toute la transcription et écrire les coupes

Lisez reading.txt du début à la fin comme le ferait un éditeur, en gardant references/cutting-rules.md à l'esprit. Écrivez <coupe>/cuts.json :

{"remove" :   [[0, 236, "reprises : deux prises précédentes de l'introduction"],
              [1047, 1064, "faux départs : 'parce que nous n'avons tout simplement pas eu, parce que nous avons…'"]],
 "remove_t" : [[1125.80, 1129.45, "reprise cachée entendue dans l'analyse des écarts : 'Donc dans chacune de ces recettes…'"]],
 "markers" :  [[2680, "NOTE ANIMATEUR : 'Supprimez juste le passage sur mon propriétaire' -> supprimé 'Alors mon propriétaire a appelé…' (3 phrases)"]],
 "markers_t" : [[1501.2, "VÉRIFIER : gardé le versement silencieux de 4 s, le locuteur fait la démo"]]}

• remove = plages d'indices de mots inclusives depuis reading.txt (préféré : limites exactes, gratuites).
• remove_t = secondes, uniquement pour les sons que la transcription n'a pas comme mots (de l'analyse des écarts ou de la vérification).
• markers (indice de mot) / markers_t (secondes) = marqueurs To-Do rouges dans la timeline pour chaque instruction de l'animateur, chaque décision nécessitant un jugement, et chaque retour en arrière qui supprime 20+ secondes de contenu unique, afin que l'éditeur puisse les vérifier en quelques secondes.
• Donnez une raison à chaque coupe. Elle se retrouve dans CUTS.md, et les raisons sont ce qui rend une liste de coupes vérifiable.

Avant de passer à la suite, lisez les mots de chaque côté de chaque coupe comme une seule phrase. Si elle ne se lit pas comme la phrase que le locuteur voulait dire, la coupe est au mauvais endroit. Cette seule habitude évite la plupart des retours « la coupe n'a pas de sens ».

5. Construction

python scripts/trim.py <coupe> écrit timeline.fcpxml, timeline.edl, segments.json, words-cut.json et CUTS.md, et imprime les longueurs brute et coupée. Vérification de cohérence : une coupe qui supprime 30 à 45 % d'un enregistrement non scripté décousu est normale (10 à 20 % pour un enregistrement scripté) ; moins de 10 % sur un enregistrement non scripté signifie généralement que des reprises ont été manquées.

6. Réécouter et corriger (~15 s par minute de montage)

python scripts/check_cut.py <coupe> rend l'audio coupé, le transcrit de la même manière et le compare mot par mot à ce que le montage devrait dire. Ensuite, python scripts/retake_finder.py <coupe> --kept liste les ouvertures répétées où les deux prises ont survécu.

Considérez chaque ligne JOIN comme un bogue jusqu'à ce qu'une réécoute prouve le contraire. Comment lire la sortie, le bruit de transcription habituel, et comment corriger chaque type de problème : references/checks.md. Corrigez, reconstruisez, revérifiez. Deux ou trois passages sont normaux.

Ensuite, lisez words-cut.json du début à la fin une fois, comme un spectateur l'entendrait. Le vérificateur compare l'audio avec l'intention ; seule la lecture permet de détecter une intention qui est elle-même erronée (une phrase laissée en suspens, une reprise gardée par méprise).

7. Livraison

• Final Cut Pro : double-cliquez sur timeline.fcpxml (Fichier → Importer → XML). Premiere/Resolve : importez timeline.edl et reliez au fichier caméra.
• Dites à l'utilisateur, en termes simples : longueur brute → longueur coupée, nombre de coupes, chaque marqueur (temps + action effectuée), tout ce dont vous n'étiez pas sûr, et combien de temps cela a pris.
• Si l'éditeur de l'utilisateur publie une version finale, demandez sa transcription et exécutez python scripts/compare_editor.py <coupe> <leur transcription.txt> : le moyen le plus rapide de trouver ce que vous avez manqué (references/checks.md → « Comparer avec la version d'un éditeur »).

Apprendre des retours (la partie qui rend cette compétence meilleure)

Chaque créateur parle différemment. Conservez ce que vous apprenez sur un locuteur dans un profil : profiles/<slug-locuteur>.md (commencez à partir de references/speaker-profile-template.md ; un exemple rempli, construit à partir de critiques réelles, se trouve dans assets/profiles/example-solo-youtube-host.md). Il contient leurs habitudes verbales, comment ils donnent des instructions à l'éditeur, leur style de pause, leur glossaire, et chaque correction que l'utilisateur a faite.

Lorsque l'utilisateur examine un montage :

1. Associez chaque plainte à sa cause avant de la corriger. S'agit-il d'une décision de coupe (une règle), d'un placement de limite (un nombre), ou de quelque chose que la transcription a caché (un écart de détection) ? references/lessons.md liste les causes vues jusqu'à présent, et la plupart des nouvelles plaintes s'avèrent être l'une d'entre elles.
2. Corrigez la cause, pas seulement l'instance. Un mot tronqué signifie qu'une règle de limite est erronée quelque part ; une reprise manquée signifie qu'il faut ajouter un modèle au profil.
3. Avant de modifier un nombre de timing, réappliquez d'abord la modification sur les jonctions d'un enregistrement précédent. Une modification qui corrige une plainte peut en créer silencieusement trente nouvelles (references/lessons.md, histoire d'introduction).
4. Écrivez la leçon dans le profil avec l'exemple et la raison. Si elle s'applique à tous les locuteurs, ajoutez-la à references/cutting-rules.md.

Fichiers de cette compétence

• scripts/transcribe_verbatim.py : Parakeet (ou Whisper) par morceaux + alignement forcé → verbatim.json
• scripts/make_reading_copy.py : transcription numérotée → reading.txt
• scripts/retake_finder.py : ouvertures répétées → retakes.txt (--kept après construction)
• scripts/gap_scan.py : réécoute des écarts sonores → gaps.txt
• scripts/trim.py : coupes → timeline.fcpxml, timeline.edl, segments.json, words-cut.json, CUTS.md
• scripts/check_cut.py : diff de réécoute → check.txt
• scripts/compare_editor.py : diff avec la transcription finale d'un éditeur → compare-editor.txt
• references/cutting-rules.md : quoi couper et garder, avec exemples (lire avant chaque coupe)
• references/edges-and-pauses.md : pourquoi chaque nombre de timing est ce qu'il est
• references/checks.md : lire les vérifications, bruit de transcription, corriger chaque type de problème
• references/lessons.md : vraies erreurs, leurs causes et corrections
• references/formats.md : styles de pause et particularités par format, audio bruyant, plusieurs locuteurs, autres langues
• references/speaker-profile-template.md : le modèle de profil par locuteur
• assets/config.example.json, assets/profiles/example-solo-youtube-host.md