Compétence d'édition de podcast
Traiter des enregistrements bruts de podcasts/réunions pour en faire des épisodes de podcast soignés.
Capacités
- Rognage intelligent — Trouver le début et la fin réels du podcast en transcrivant et en détectant les intros/outros
- Suppression des tics de langage — Supprimer les tics verbaux : euh, heu, ben, quoi, du coup, etc.
- Coupure des silences — Réduire les longs silences (>2 s) en pauses naturelles (~0,6 s)
- Amélioration audio — Réduction de bruit, égalisation, équilibrage du volume entre plusieurs intervenants, normalisation de la sonie aux normes du podcast (−16 LUFS)
- Ré-encodage d'un épisode terminé — Supprimer chirurgicalement des sections signalées d'un épisode déjà rendu sans relancer tout le pipeline
- Clips et bande-annonce — Créer des extraits partageables et les assembler en une bande-annonce d'environ 1 minute avec musique
- Coupe vidéo — Appliquer la même édition à un enregistrement vidéo Zoom/Riverside (voir « Épisodes vidéo »)
Prérequis
ffmpegetffprobeinstallésOPENAI_API_KEYdans l'environnement (pour la transcription via l'API Whisper)- Python 3 avec bibliothèque standard uniquement (pas de dépendances supplémentaires pour le script auxiliaire)
- Optionnel :
resemblyzer(pip install resemblyzer) — uniquement pour la diarisation des locuteurs lors de la création de bandes-annonces
Flux de travail
Étape 1 : Inspecter le fichier audio
ffprobe -v quiet -print_format json -show_format -show_streams "FICHIER_ENTRÉE"
Noter : durée, fréquence d'échantillonnage, canaux, codec, débit.
Étape 2 : Trouver le début/fin du podcast (si l'utilisateur demande de rogner le début/la fin)
Diviser en morceaux de 5 minutes et transcrire via l'API Whisper d'OpenAI avec des horodatages au niveau des segments :
# Extraire un morceau
ffmpeg -y -i "FICHIER_ENTRÉE" -ss DÉCALAGE -t 300 -ar 16000 -ac 1 /tmp/morceau_DÉCALAGE.mp3
# Transcrire
curl -s https://api.openai.com/v1/audio/transcriptions \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-F file="@/tmp/morceau_DÉCALAGE.mp3" \
-F model="whisper-1" \
-F response_format="verbose_json" \
-F language="LANG" \
-F 'timestamp_granularities[]=segment' > /tmp/transcription_DÉCALAGE.json
Parcourir les transcriptions à la recherche de :
- Marqueurs de début : "bienvenue", "bonjour à tous", intro musicale, première phrase de sujet substantif
- Marqueurs de fin : "à la prochaine", "au revoir", "merci de nous avoir écoutés", suivi de bavardages de fin
Effectuer un rognage initial avec -ss DÉBUT -to FIN et -c copy (pas de ré-encodage) pour créer un fichier de travail.
Étape 3 : Supprimer les tics de langage
Diviser le fichier rogné en morceaux de 5 minutes et transcrire chacun avec des horodatages au niveau des mots :
# Extraire les morceaux
for i in $(seq 0 300 DURÉE); do
ffmpeg -y -i "FICHIER_ROGNÉ" -ss $i -t 300 -ar 16000 -ac 1 /tmp/wmorceau_${i}.mp3
done
# Transcrire chaque morceau (peut être exécuté en parallèle)
for i in $(seq 0 300 DURÉE); do
curl -s https://api.openai.com/v1/audio/transcriptions \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-F file="@/tmp/wmorceau_${i}.mp3" \
-F model="whisper-1" \
-F response_format="verbose_json" \
-F language="LANG" \
-F 'timestamp_granularities[]=word' \
-F 'timestamp_granularities[]=segment' > /tmp/wtranscription_${i}.json &
done
wait
Exécuter ensuite le script de suppression des tics de langage fourni avec cette compétence :
python3 ./suppression_tic.py \
--total-duration DURÉE \
--end-at HORODATAGE_FIN \
--cut DÉBUT1:FIN1 --cut DÉBUT2:FIN2 \
--chunk-offsets 0,300,600,900,...
Arguments :
--total-duration: Durée du fichier d'entrée rogné en secondes (obligatoire)--end-at: Couper tout ce qui se trouve après cet horodatage (p. ex., début des bavardages de fin)--cut DÉBUT:FIN: Couper une plage spécifique. Peut être répété.--chunk-offsets: Décalages des morceaux séparés par des virgules (par défaut : auto 0,300,600,…)
Le script produit /tmp/ffmpeg_filter.txt avec un filtre atrim+concat.
Appliquer le filtre en deux passes :
# Étape A : Couper les tics → WAV intermédiaire (évite les artefacts de ré-encodage)
ffmpeg -y -i "FICHIER_ROGNÉ" \
-filter_complex_script /tmp/ffmpeg_filter.txt \
-map '[out]' -c:a pcm_s16le -ar 44100 /tmp/podcast_cut.wav
# Étape B : Améliorer l'audio → MP3 final
ffmpeg -y -i /tmp/podcast_cut.wav \
-af "CHAÎNE_AMÉLIORATION" \
-c:a libmp3lame -b:a 192k "FICHIER_SORTIE"
Limitations : Les horodatages au niveau des mots de Whisper pour le chinois peuvent manquer certains tics de langage qui sont intégrés dans la parole adjacente. Le script capture les tics isolés de manière fiable, mais peut en manquer environ 10 à 20 % des tics intégrés.
Étape 4 : Chaîne de filtres d'amélioration audio
Chaîne par défaut (adaptée aux invités — gère les déséquilibres de volume entre plusieurs intervenants). La plus grande erreur dans les exécutions passées est l'utilisation d'un gate de bruit (agate) qui réduit au silence l'invité le plus calme. N'ajoutez jamais agate à la chaîne par défaut.
highpass=f=80, # Supprimer le grondement de la pièce
lowpass=f=12000, # Supprimer le souffle (utiliser 7500 pour les sources 16 kHz)
afftdn=nf=-25:nr=8:nt=w, # Réduction de bruit FFT douce
equalizer=f=180:t=q:w=1.5:g=-2, # Réduire les fréquences basses boueuses
equalizer=f=2500:t=q:w=1.2:g=3, # Renforcer la présence
equalizer=f=4500:t=q:w=1.5:g=1.5, # Renforcer la clarté
dynaudnorm=f=200:g=5:p=0.95:m=5:s=0, # Normalisation par fenêtre glissante — augmente indépendamment le volume de l'intervenant le plus calme
acompressor=threshold=-20dB:ratio=2:attack=5:release=200:makeup=1, # Compression douce
loudnorm=I=-16:TP=-1.5:LRA=13 # Sonie standard du podcast
Pourquoi dynaudnorm est l'élément clé : il normalise dans des fenêtres glissantes de 200 ms, de sorte que lorsque l'invité parle, cette fenêtre est augmentée indépendamment des fenêtres plus fortes de l'hôte. L'ordre est important : exécutez dynaudnorm AVANT acompressor pour que le compresseur voie un signal équilibré.
N'ajoutez jamais ces éléments à la chaîne par défaut :
agate(gate de bruit) — coupe tout intervenant plus calme que le seuil ; tue l'invité.- Compression forte (ratio >3:1, makeup >2 dB) — aplatit la dynamique et donne à l'invité un son compressé.
- LRA étroit (<12) dans
loudnorm— écrase la dynamique naturelle de la parole.
Ajustez le filtre passe-bas en fonction de la fréquence d'échantillonnage de la source :
- Source 16 kHz →
lowpass=7500 - Source 44,1 kHz+ →
lowpass=12000(ou sautez)
Vérifiez l'audibilité de l'invité après le rendu : exécutez ffmpeg -i SORTIE -af "ebur128=peak=true" -f null - et vérifiez que I: est proche de −16 LUFS et que LRA: est de 4–6 LU (un LRA plus serré est acceptable car dynaudnorm a d'abord effectué un équilibrage par fenêtre). Si la sortie donne l'impression que l'invité a été coupé, suspectez un gate ou un compresseur agressif qui s'est glissé dans la chaîne.
Étape 5 : Vérifier la sortie
ls -lh "FICHIER_SORTIE"
ffprobe -v quiet -show_entries format=duration -of csv=p=0 "FICHIER_SORTIE"
Rapporter : durée, taille du fichier, ce qui a été supprimé (nombre de tics, nombre de silences, temps gagné).
Épisodes vidéo (enregistrements Zoom / Riverside)
Lorsque la source est une vidéo et que l'utilisateur souhaite obtenir une vidéo coupée (par exemple, un co-animateur a besoin de l'épisode édité pour le doubler dans une autre langue), exécutez les étapes 1 à 3 exactement comme ci-dessus — extrayez les morceaux audio directement du fichier mp4 avec -vn — puis appliquez les mêmes points de coupe à l'image et au son en une seule passe :
# 1) mêmes morceaux + transcription qu'à l'étape 3, mais provenant de la vidéo
for i in $(seq 0 300 DURÉE); do
ffmpeg -y -v error -ss $i -t 300 -i SOURCE.mp4 -vn -ar 16000 -ac 1 /tmp/wmorceau_${i}.mp3 &
done; wait
# 2) suppression_tic.py comme d'habitude -> /tmp/ffmpeg_filter.txt
# 3) transformer ses segments conservés en un filtre vidéo+audio combiné
python3 coupe_video.py /tmp/filtre_video.txt
# 4) une seule passe de rendu (encodeur matériel ; ~7 min pour un épisode 1080p de 60 min)
ffmpeg -y -i SOURCE.mp4 -filter_complex_script /tmp/filtre_video.txt \
-map '[vout]' -map '[aout]' \
-c:v h264_videotoolbox -b:v 3500k -c:a aac -b:a 160k \
-movflags +faststart episode-edited.mp4
Utilisez -c:v libx264 -crf 21 -preset veryfast au lieu de h264_videotoolbox sur du matériel non Apple.
Remarques :
- Construisez
--chunk-offsetsavec$(seq 0 300 3600 | paste -sd, -). Un champ vide en fin de chaîne plante l'analyseur d'arguments. - Le résultat est un style de coupure sèche . C'est attendu et acceptable pour une grille de têtes parlantes ; un fondu court à plus de 400 points de coupe semble moins bon qu'une coupure franche.
coupe_video.pyintègre la chaîne d'amélioration dans la même passe, donc contrairement à la partie audio, il n'y a pas d'intermédiaire WAV en deux passes. N'exécutez pas la chaîne à nouveau après.- Prévoyez environ 1,5 Go pour une sortie 1080p de 60 min — trop volumineux pour un email, donc téléchargez et partagez un lien.
- Enregistrez la liste des segments conservés à côté de l'épisode. Sans cela, une demande ultérieure de « même coupe, mais en vidéo » devra recalculer les coupes, et elles ne correspondront pas à la version audio déjà livrée.
Conventions de sortie
- Format : MP3, 192 kbps, mono (sauf si la source est stéréo avec des canaux séparés par intervenant)
- Sonie : −16 LUFS (norme podcast)
- Toujours deux passes : couper d'abord en WAV, puis améliorer en MP3
Ré-encodage d'un épisode déjà terminé
Lorsque l'utilisateur signale des problèmes spécifiques dans un épisode publié (« quelques phrases ont été laissées », « coupe la partie sur X », « la fin a été réenregistrée », « supprime l'intro en double »), ne relancez PAS tout le pipeline à partir des fichiers bruts. Supprimez chirurgicalement les plages incriminées du MP3 final et réencodez une seule fois :
- Retranscrivez le fichier final en morceaux de 5 min (granularité segment) → une transcription unifiée avec des horodatages absolus. C'est votre carte.
- Pour chaque élément signalé, obtenez des horodatages au niveau des mots pour le seul morceau qui le contient (ces phrases sont généralement intégrées au milieu d'une phrase, pas aux limites des segments). Déterminez précisément les points d'entrée/sortie.
- Construisez un filtre
atrim+concatqui conserve tout sauf les plages coupées ; rendez en WAV (pcm_s16le) puis une seule passe MP3. N'appliquez pas la chaîne d'amélioration — le fichier final est déjà amélioré/normalisé ; la réappliquer double le traitement. - Vérifiez chaque jonction : extrayez une fenêtre d'environ 11 secondes centrée sur chaque nouvelle jonction (dans la nouvelle timeline) et retranscrivez-la. Confirmez que le mauvais audio a disparu et que la transition est propre.
- Recalculez toute timeline de notes de show : chaque horodatage après une coupe est décalé plus tôt de la somme des longueurs de toutes les coupes avant lui. Si le fichier publié ajoute une bande-annonce en préfixe, tenez également compte de la durée de la bande-annonce comme décalage (une bande-annonce recoupée change de longueur, donc tout l'épisode se décale).
Liste de vérification pour le ré-encodage — ce que la première passe laisse généralement passer
Ceux-ci survivent à la suppression des tics/silences car ils sont mélangés à des phrases réelles. Recherchez-les explicitement dans la transcription :
- Bavardages de réunion/techniques : "vous êtes en sourdine / activez votre micro", "tu es trop silencieux / tu m'entends ?", "pouvez-vous voir mon écran", "attendez, je regarde". Coupez la phrase, conservez le contenu environnant.
- Sujets sans issue : le panel soulève un produit/une affaire que personne n'a étudié, puis dit "passons à autre chose" — coupez toute la digression, pas seulement la ligne de passage.
- Segments réenregistrés (surtout les fins) : une première prise brouillonne, puis un marqueur comme "recommençons / c'est redondant", puis une reprise propre. Coupez la première prise, conservez le réenregistrement. Inspectez toujours les ~3 dernières minutes pour cela.
- Pré-show / intros en double : une auto-présentation enregistrée avant le début officiel qui est répétée plus tard — coupez la copie du pré-show.
Imprévisibilité de l'API Whisper
Les appels parallèles au niveau des mots renvoient parfois un résultat vide (0 octet). Relancez les résultats vides séquentiellement avec un sleep 1 entre les appels.
Clips et bande-annonce d'une minute
Créez des extraits courts et partageables à partir d'un épisode terminé (moments controversés / perspicaces), et éventuellement assemblez-les en une bande-annonce d'environ 1 minute avec musique.
Choix des extraits
- Chaque clip ≈ 2 phrases, ~8–20 s. Privilégiez les lignes controversées, surprenantes ou citables.
- COUVREZ CHAQUE INTERVENANT — y compris l'hôte/les animateurs. Dans un panel de plusieurs invités, ne laissez pas la bande-annonce se réduire aux 1–2 voix les plus bavardes — choisissez au moins un extrait percutant par participant et vérifiez l'attribution avant de construire. (C'est l'erreur n°1 : un "point fort" qui est en réalité une seule personne.) L'animateur/hôte est le plus facile à omettre car il pose principalement des questions — trouvez une ligne citable de l'hôte (une réaction, une blague, un cadrage pertinent) et incluez-la aussi.
- Vous ne pouvez pas attribuer les locuteurs à partir du texte de la transcription — n'essayez pas, et ne demandez pas à l'utilisateur de le faire pour vous. Whisper vous donne des mots, pas qui les a dits ; deviner le locuteur à partir de la formulation échoue (une ligne qui semble être de l'hôte s'avère souvent être d'un invité). Lorsque la bande-annonce nécessite une personne spécifique, diarisez l'audio (recette ci-dessous) et l'attribution devient une mesure, pas une supposition.
- Ordonnez la bande-annonce pour le flux (accroche → … → conclusion forte) et ne mettez jamais le même locuteur dos à dos.
Identifier QUI parle — diarisation des locuteurs (resemblyzer)
Lorsque vous avez besoin d'un clip d'une personne spécifique (ou que l'utilisateur dit "X n'est pas dans la bande-annonce"), résolvez-le par la voix, pas en lisant la transcription. pip install resemblyzer (intègre son propre encodeur — pas de token HF). Recette qui a fonctionné sur un panel de 5 locuteurs :
- Construisez des voix de référence propres pour tous ceux que vous pouvez identifier, à partir de segments où ils disent leur propre nom (intros) ou présentent leur propre produit (promotions de fin) — ceux-ci garantissent un seul locuteur. Faites la moyenne de 2 à 3 fenêtres par personne pour plus de stabilité :
enc.embed_utterance(preprocess_wav(slice, source_sr=16000)), moyenne, normalisation L2. - Ne regroupez pas à l'aveugle tout l'épisode — les segments Whisper contiennent des interférences, donc
AgglomerativeClusteringse réduit en un gros bloc + singletons. Au lieu de cela, évaluez l'encastrement de chaque segment (cosinus) par rapport à vos références propres. Les segments qui ne correspondent à personne correctement (meilleure sim ≲ 0,78 lorsque les vrais correspondances sont de 0,88–0,94) sont le Nième locuteur non identifié. - Confirmez qu'il s'agit d'une voix cohérente : prenez ces segments à faible correspondance, vérifiez qu'ils sont mutuellement similaires (≳0,87) et collectivement distincts de chaque référence connue. Construisez une référence à partir d'eux, réévaluez tous les segments — les correspondances de haute confiance devraient toutes être cette personne.
- Vérifiez la cohérence avec un connu : un clip confirmé (par exemple, la présentation d'un produit de quelqu'un) doit obtenir le score le plus élevé par rapport à sa propre référence (≳0,9). Si vos références ne se séparent pas, allongez les fenêtres et faites la moyenne de plus d'échantillons.
Chargez tout l'épisode une fois en mono flottant 16 kHz via un pipe ffmpeg (-f f32le -) et découpez en mémoire — beaucoup plus rapide qu'un appel ffmpeg par segment.
Vérifiez avant de couper (obligatoire)
Pour chaque candidat, extrayez la fenêtre et re-transcrivez-la via Whisper API (appel au niveau des mots). Vérifiez que l'extrait commence et se termine sur une phrase complète, et que toutes les phrases coupées sont grammaticalement autonomes. Ne vous fiez pas aux horodatages de la transcription principale — l'API Whisper a une erreur ±0,5 s sur les limites de mots, et vos points de coupe doivent être décalés de 0,2 s de chaque côté pour éviter une coupure abrupte. Utilisez l'extrait retranscrit -> l'horodatage absolu ré-ancré pour le point d'entrée/sortie précis.
Construire la bande-annonce finale
# Marquer les extraits
ffmpeg -y -i "FICHIER_SORTIE" -ss DÉBUT -to FIN -map a -c copy EXTRAIT1.mp3
ffmpeg -y -i "FICHIER_SORTIE" -ss DÉBUT -to FIN -map a -c copy EXTRAIT2.mp3
...
# Créer une piste de fond musical (en boucle)
# (demander à l'utilisateur de fournir un fichier ; sinon utiliser un silence)
# Concaténer les extraits avec fondu enchaîné (500 ms) + fond musical
# Le script asm du filtre concat + crossfeed est verbeux — utilisez le script d'aide :
python3 ./reel_compiler.py EXTRAIT1.mp3 EXTRAIT2.mp3 ... \
--background MUSIQUE.mp3 louiebg.mp3 \
--fade 500 \
--total 60 \
--output bande-annonce-final.mp3
Scripts fournis
suppression_tic.py — Génère le filtre de coupe
Entrée : transcription Whisper (fichiers avec horodatages au niveau des mots), durée totale.
Sortie : /tmp/ffmpeg_filter.txt contenant un filtre graphique atrim+concat.
Comportement : analyse les transcriptions, identifie les plages de tics (mots dont la durée <0,15 s ? — en fait les tics sont souvent très courts ou accolés). Utilise une similarité cosinus de l'encastrement (importé d'un mini-encodeur) entre chaque nucléotide et des motifs de tics ? Non, trop lent. Approche actuelle : seuil heuristique sur la probabilité d'être un tic via une liste de mots-cibles et de contexte (mot précédent, mot suivant).
coupe_video.py — Génère le pipeline vidéo
Convertit le /tmp/ffmpeg_filter.txt de suppression_tic.py en un script de filtre vidéo+audio combiné pour une administrative unique.
- Il prend la liste des segments à conserver (dans l'ordre) et produit un
select=' ... 'avec lesetpts=N/FR/TBcorrespondant pour la vidéo etaselect+asetptspour l'audio. Ajoute la chaîne d'amélioration viaaresample+ le filtreaeval. - Sortie :
/tmp/filtre_video.txtsous forme de script de filtre ffmpeg.
reel_compiler.py — Compile la bande-annonce
Concatène les répertoires d'extraits avec fondu enchaîné + piste de fond musical. Utilise acrossfade en série et amix pour le fond. Se termine par loudnorm.
Dépannage
- La transcription est vide : l'API a planté silencieusement. Les appels parallèles échouent parfois avec du contenu vide. Solution : réessayez séquentiellement avec
sleep 1. - Les horodatages des mots ne correspondent pas : Whisper dérive parfois entre les segments du mot et ceux du segment. Vérifiez le
start/enddu mot par rapport au segment ; s'ils diffèrent de >1 s, utilisez l'horodatage du segment comme point d'ancrage. - Le MP3 de sortie est plus long que l'original : un tic en fin de fichier a mal été aligné à la fin ; le script a supprimé la mauvaise plage. Vérifiez l'horodatage
--end-at. - La vidéo a un décalage audio : le filtre
asetptsn'a pas été synchronisé avec le filtre vidéo. Les scriptscoupe_video.pyvérifient cela, mais si vous construisez manuellement, utilisezsetpts=PTS-STARTPTSetasetpts=PTS-STARTPTSet vérifiez que les longueurs de segment correspondent (la vidéo n'a pas de trames de remplissage).