Lorsque cette compétence est activée, commencez toujours votre première réponse par l'emoji :speaker:.
Conception Audio Vidéo
La conception audio vidéo est la pratique qui consiste à superposer la narration, les effets sonores et la musique de fond dans des compositions vidéo programmatiques. Un son de qualité transforme une simple présentation en une production soignée : la narration guide le spectateur, la musique définit le ton émotionnel et les effets sonores ponctuent les moments clés. Cette compétence couvre la génération de parole avec ElevenLabs et d'autres fournisseurs de TTS, la création d'effets sonores synthétiques avec FFmpeg, la recherche de musique de fond libre de droits, l'implémentation du ducking audio pour que la parole reste intelligible, et le mixage de toutes les couches dans des compositions Remotion avec un timing image par image.
Quand utiliser cette compétence
Déclenchez cette compétence lorsque l'utilisateur :
- Souhaite ajouter une narration ou un voice-over à une vidéo programmatique
- A besoin de générer de la parole avec ElevenLabs, OpenAI TTS ou Edge TTS
- Pose des questions sur la sélection de voix, les réglages de voix ou le clonage vocal
- Veut ajouter de la musique de fond ou chercher des sources de musique libre de droits
- Demande comment créer des effets sonores de manière programmatique
- Veut implémenter le ducking audio (baisser la musique pendant la parole)
- A besoin de mixer plusieurs couches audio dans Remotion
- Pose des questions sur le timing audio, les niveaux de volume ou la synchronisation audio basée sur les images
Ne PAS déclencher cette compétence pour :
- L'écriture de scripts vidéo ou le storyboard - utilisez la compétence d'écriture de scripts vidéo
- L'architecture ou le rendu de composants Remotion - utilisez la compétence vidéo Remotion
- La production audio professionnelle dans un DAW (Ableton, Logic, Pro Tools)
- La composition musicale ou la programmation MIDI
Principes clés
-
Architecture audio en couches - Chaque vidéo comporte trois couches audio : la narration au premier plan (la plus forte), les SFX au milieu (volume d'accentuation), et la musique de fond à la base (la plus faible).
-
La narration dicte le timing - Générez la narration en premier, mesurez sa durée, puis calquez le timing des scènes sur cette durée. N'essayez jamais de faire tenir la narration dans des longueurs de scène arbitraires.
-
Duck la musique pendant la parole - La musique de fond doit baisser de 50 à 60 % lorsque la narration est jouée. Utilisez des transitions progressives (10 à 15 images) pour éviter les sauts brusques.
-
Les SFX comme accents, pas comme distractions - Gardez les SFX courts (moins de 0,5 s), subtils en volume et pertinents par rapport à l'action à l'écran.
-
Testez l'audio en contexte - Prévisualisez toujours le mix complet avec toutes les couches ensemble. Écoutez les signes de parole brouillée, de pics de volume ou de silence mort.
Concepts de base
Architecture audio à 3 couches
| Couche | Rôle | Volume de base | Pendant la narration |
|---|---|---|---|
| Narration | Transmet l'information, rythme le déroulement | 0,8-1,0 | N/A (couche supérieure) |
| SFX | Accentue les transitions et les actions | 0,3-0,5 | 0,3-0,5 (inchangé) |
| Musique de fond | Définit le ton émotionnel, comble les silences | 0,3-0,5 | 0,15-0,25 (ducké) |
Modèle d'API ElevenLabs
ElevenLabs fournit un TTS neuronal via une API REST. Le flux principal :
- Choisissez une voix (préfabriquée ou clonée) - chacune a un
voice_id - Envoyez le texte et les réglages de voix à
/v1/text-to-speech/{voice_id} - Recevez les octets audio bruts (mp3 par défaut)
- Écrivez dans un fichier et mesurez la durée pour le timing de la scène
Réglages de la voix :
| Réglage | Plage | Bas | Haut | Recommandé |
|---|---|---|---|---|
| stability | 0-1 | Plus expressif, variable | Plus cohérent, monotone | 0,4-0,6 |
| similarity_boost | 0-1 | Plus créatif | Plus proche de la voix originale | 0,6-0,8 |
| style | 0-1 | Délivrance neutre | Style exagéré | 0,3-0,6 |
Concept de ducking audio
Le ducking audio réduit le volume de la musique de fond lorsque la narration commence et le restaure lorsque la narration se termine. Dans Remotion, utilisez interpolate() :
Volume musique : 0.4 ---\ /--- 0.4
\ /
0.15 \__________/
début narration → fin
Les transitions doivent prendre 10 à 15 images (~0,3-0,5 s à 30 ips).
Synchronisation audio basée sur les images dans Remotion
useCurrentFrame()retourne le numéro de l'image actuelleinterpolate()mappe les plages d'images à des plages de valeurs (par exemple, le volume)<Sequence from={frame}>place l'audio à une image spécifique<Audio volume={fn}>accepte un nombre statique ou une fonction par image
Convertissez les secondes en images : images = secondes * ips.
Tâches courantes
1. Configurer la clé API ElevenLabs et générer une narration
import fs from 'fs';
const ELEVENLABS_API_URL = 'https://api.elevenlabs.io/v1';
async function generateNarration(
text: string,
voiceId: string,
outputPath: string
): Promise<void> {
const response = await fetch(
`${ELEVENLABS_API_URL}/text-to-speech/${voiceId}`,
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
'xi-api-key': process.env.ELEVEN_LABS_API_KEY!,
},
body: JSON.stringify({
text,
model_id: 'eleven_multilingual_v2',
voice_settings: {
stability: 0.5,
similarity_boost: 0.75,
style: 0.5,
use_speaker_boost: true,
},
}),
}
);
if (!response.ok) {
const error = await response.text();
throw new Error(`Erreur API ElevenLabs ${response.status}: ${error}`);
}
const buffer = Buffer.from(await response.arrayBuffer());
fs.writeFileSync(outputPath, buffer);
}
2. Sélectionner et configurer les réglages de voix
Questions pour la sélection de la voix : genre, tranche d'âge, accent, niveau d'énergie, chaleur.
interface VoiceSettings {
stability: number;
similarity_boost: number;
style: number;
use_speaker_boost: boolean;
}
const presets: Record<string, VoiceSettings> = {
explainer: { stability: 0.6, similarity_boost: 0.75, style: 0.4, use_speaker_boost: true },
promo: { stability: 0.3, similarity_boost: 0.7, style: 0.7, use_speaker_boost: true },
tutorial: { stability: 0.7, similarity_boost: 0.8, style: 0.2, use_speaker_boost: false },
};
3. Générer la narration par scène à partir d'un script
import { execSync } from 'child_process';
import path from 'path';
interface Scene { id: string; narrationText: string; }
interface SceneWithAudio extends Scene {
audioPath: string;
durationMs: number;
durationFrames: number;
}
function getAudioDurationMs(filePath: string): number {
const output = execSync(
`ffprobe -v error -show_entries format=duration -of csv=p=0 "${filePath}"`
).toString().trim();
return Math.round(parseFloat(output) * 1000);
}
async function generateSceneNarrations(
scenes: Scene[], voiceId: string, outputDir: string, fps: number
): Promise<SceneWithAudio[]> {
const results: SceneWithAudio[] = [];
for (const scene of scenes) {
const audioPath = path.join(outputDir, `${scene.id}.mp3`);
await generateNarration(scene.narrationText, voiceId, audioPath);
const durationMs = getAudioDurationMs(audioPath);
results.push({
...scene, audioPath, durationMs,
durationFrames: Math.ceil((durationMs / 1000) * fps),
});
}
return results;
}
4. Trouver de la musique de fond
Sources de musique libre de droits :
- Pixabay Audio: https://pixabay.com/music/ (gratuit, pas d'attribution requise)
- Freesound: https://freesound.org/ (CC0/CC-BY)
- YouTube Audio Library: téléchargement depuis YouTube Studio
- Fichiers locaux: placez-les dans
public/audio/pourstaticFile()de Remotion
5. Générer des SFX avec FFmpeg
# Son de clic - courte salve sinusoïdale
ffmpeg -f lavfi -i "sine=frequency=800:duration=0.05" \
-af "afade=t=out:st=0.02:d=0.03" click.wav
# Frappe au clavier - salve de bruit filtré
ffmpeg -f lavfi -i "anoisesrc=d=0.08:c=white:a=0.3" \
-af "highpass=f=2000,lowpass=f=8000,afade=t=out:st=0.04:d=0.04" type.wav
# Whoosh - balayage de fréquence
ffmpeg -f lavfi -i "sine=frequency=200:duration=0.4" \
-af "vibrato=f=8:d=0.5,afade=t=in:d=0.1,afade=t=out:st=0.2:d=0.2,lowpass=f=1000" \
whoosh.wav
# Ding/carillon - synthèse de cloche
ffmpeg -f lavfi -i "sine=frequency=1200:duration=0.6" \
-af "afade=t=out:st=0.1:d=0.5,aecho=0.8:0.88:40:0.4" ding.wav
# Pop - impulsion
ffmpeg -f lavfi -i "sine=frequency=400:duration=0.08" \
-af "afade=t=out:st=0.02:d=0.06,lowpass=f=600" pop.wav
# Swoosh de transition
ffmpeg -f lavfi -i "sine=frequency=300:duration=0.3" \
-af "vibrato=f=12:d=0.8,afade=t=in:d=0.05,afade=t=out:st=0.15:d=0.15,bandpass=f=500:w=400" \
swoosh.wav
6. Implémenter le ducking audio dans Remotion
import React from 'react';
import { Audio, useCurrentFrame, interpolate, Sequence } from 'remotion';
const AudioMixer: React.FC<{
narrationSrc: string;
musicSrc: string;
narrationStart: number;
narrationDuration: number;
}> = ({ narrationSrc, musicSrc, narrationStart, narrationDuration }) => {
const frame = useCurrentFrame();
const duckRampFrames = 10;
const musicVolume = interpolate(
frame,
[
narrationStart - duckRampFrames,
narrationStart,
narrationStart + narrationDuration,
narrationStart + narrationDuration + duckRampFrames,
],
[0.4, 0.15, 0.15, 0.4],
{ extrapolateLeft: 'clamp', extrapolateRight: 'clamp' }
);
return (
<>
<Audio src={musicSrc} volume={musicVolume} />
<Sequence from={narrationStart} durationInFrames={narrationDuration}>
<Audio src={narrationSrc} volume={0.9} />
</Sequence>
</>
);
};
export default AudioMixer;
7. Mixer 3 couches audio dans une composition Remotion
import React from 'react';
import { Audio, Sequence, useCurrentFrame, interpolate } from 'remotion';
interface NarrationSegment { src: string; startFrame: number; durationFrames: number; }
interface SfxEvent { src: string; frame: number; }
const FullAudioMix: React.FC<{
narrations: NarrationSegment[];
sfxEvents: SfxEvent[];
musicSrc: string;
}> = ({ narrations, sfxEvents, musicSrc }) => {
const frame = useCurrentFrame();
const duckRamp = 10;
let musicVolume = 0.4;
for (const seg of narrations) {
const duck = interpolate(
frame,
[seg.startFrame - duckRamp, seg.startFrame,
seg.startFrame + seg.durationFrames, seg.startFrame + seg.durationFrames + duckRamp],
[1, 0.375, 0.375, 1],
{ extrapolateLeft: 'clamp', extrapolateRight: 'clamp' }
);
musicVolume = musicVolume * duck;
}
return (
<>
<Audio src={musicSrc} volume={musicVolume} loop />
{sfxEvents.map((sfx, i) => (
<Sequence key={i} from={sfx.frame} durationInFrames={30}>
<Audio src={sfx.src} volume={0.4} />
</Sequence>
))}
{narrations.map((seg, i) => (
<Sequence key={i} from={seg.startFrame} durationInFrames={seg.durationFrames}>
<Audio src={seg.src} volume={0.9} />
</Sequence>
))}
</>
);
};
export default FullAudioMix;
8. Utiliser des fournisseurs TTS alternatifs
OpenAI TTS - bonne qualité, API simple, six voix intégrées :
import OpenAI from 'openai';
import fs from 'fs';
const openai = new OpenAI();
async function generateWithOpenAI(
text: string,
outputPath: string,
voice: 'alloy' | 'echo' | 'fable' | 'onyx' | 'nova' | 'shimmer' = 'alloy'
): Promise<void> {
const mp3 = await openai.audio.speech.create({
model: 'tts-1-hd',
voice,
input: text,
});
const buffer = Buffer.from(await mp3.arrayBuffer());
fs.writeFileSync(outputPath, buffer);
}
Edge TTS - gratuit, nombreuses voix, utilise le service TTS de Microsoft Edge :
pip install edge-tts
edge-tts --voice en-US-AriaNeural --text "Bonjour tout le monde" --write-media output.mp3
edge-tts --list-voices
Anti-patrons / erreurs courantes
| Erreur | Pourquoi c'est faux | Que faire à la place |
|---|---|---|
| Musique au même volume pendant la narration | La parole devient inintelligible | Implémenter le ducking audio - baisser la musique de 50 à 60 % pendant la parole |
| Coder en dur la clé API ElevenLabs | La clé fuit dans le contrôle de version | Utiliser les variables d'environnement : process.env.ELEVEN_LABS_API_KEY |
| Utiliser le TTS sans mesurer la durée | Mauvais timing de la scène, narration coupée | Mesurer la durée audio avec ffprobe après la génération |
| SFX plus forts que la narration | Distrait du contenu | SFX à 0,3-0,5, narration à 0,8-1,0 |
| Pas de fondu au début/fin de la musique | Un début/arrêt brusque ressemble à un bug | Ajouter un fondu d'entrée de 0,5 à 1 s au début et un fondu de sortie à la fin |
| Utiliser un modèle TTS de faible qualité | Une voix robotique nuit à la qualité | Utiliser eleven_multilingual_v2 ou tts-1-hd |
| Ignorer le format de fichier audio | Certains formats ajoutent un silence de remplissage | Utiliser MP3 pour la narration, WAV pour les SFX |
Pièges
-
Limites de débit et quotas de caractères ElevenLabs - Le niveau gratuit a une limite mensuelle de caractères. Mettez en cache l'audio généré de manière agressive et ne régénérez que lorsque le texte change. Utilisez un hachage du texte comme clé de cache.
-
Le remplissage de l'encodeur MP3 ajoute du silence - Les fichiers MP3 ont souvent 20 à 50 ms de silence au début. Coupez avec
ffmpeg -af silenceremove=1:0:-50dBou tenez compte du décalage dans le timing des images. -
Le volume audio de Remotion est par composant, pas global - Deux composants
<Audio>à volume 1.0 peuvent s'écrêter. Maintenez le volume total des couches simultanées en dessous de 1.0. -
Les SFX FFmpeg sonnent différemment selon les systèmes - Spécifiez toujours
-ar 44100 -sample_fmt s16pour une sortie cohérente entre les machines. -
Cohérence de la voix entre les scènes - ElevenLabs peut produire des tons différents pour les mêmes réglages avec un texte différent. Utilisez stability >= 0,5 pour une narration multi-scène.
Références
Pour des patrons détaillés sur des sous-domaines audio spécifiques, lisez le fichier
correspondant dans le dossier references/ :
references/elevenlabs-api.md- patrons avancés de l'API ElevenLabs, y compris le clonage vocal, le TTS en streaming, l'API websocket, les dictionnaires de prononciation, et la gestion des quotasreferences/audio-mixing-patterns.md- patrons de mixage avancés, y compris le ducking multi-segment, les fondus enchaînés entre les scènes, les courbes d'automatisation du volume, et le mastering du mix finalreferences/sfx-generation.md- génération complète de SFX avec FFmpeg, y compris la synthèse complexe, la superposition de plusieurs générateurs, et la construction d'une bibliothèque SFX réutilisable
Ne chargez un fichier de référence que si la tâche actuelle l'exige - ils sont longs et consommeront du contexte.