Wenn dieses Skill aktiviert wird, beginne deine erste Antwort immer mit dem :speaker: Emoji.
Video-Audio-Design
Video-Audio-Design ist die Praxis, Erzählung, Soundeffekte und Hintergrundmusik zu programmatischen Videokompositionen zusammenzufügen. Großartiger Ton verwandelt eine Dia-Präsentation in eine professionelle Produktion – die Erzählung führt die Zuschauer, die Musik setzt die emotionale Stimmung und SFX betonen Schlüsselmomente. Dieses Skill umfasst die Sprachgenerierung mit ElevenLabs und alternativen TTS-Anbietern, die Erstellung synthetischer Soundeffekte mit FFmpeg, die Beschaffung lizenzfreier Hintergrundmusik, die Implementierung von Audio-Ducking, damit Sprache verständlich bleibt, und das Zusammenmischen aller Ebenen in Remotion-Kompositionen mit frame-genauer Zeitsteuerung.
Wann dieses Skill verwendet werden soll
Aktiviere dieses Skill, wenn der Benutzer:
- Eine Erzählung oder einen Voiceover zu einem programmatischen Video hinzufügen möchte
- Sprache mit ElevenLabs, OpenAI TTS oder Edge TTS generieren muss
- Fragen zur Auswahl von Stimmen, Stimmeneinstellungen oder Stimmklonen stellt
- Hintergrundmusik hinzufügen oder Quellen für lizenzfreie Musik benötigt
- Fragt, wie man Soundeffekte programmatisch erstellt
- Audio-Ducking implementieren möchte (Musik während der Sprache absenken)
- Mehrere Audiospuren in Remotion mischen muss
- Fragen zur Audio-Timing, Lautstärkepegeln oder frame-basierter Audio-Synchronisation hat
Aktiviere dieses Skill NICHT für:
- Videoskripting oder Storyboarding – verwende das Video-Skripterstellungs-Skill
- Remotion-Komponentenarchitektur oder Rendering – verwende das Remotion-Video-Skill
- Professionelle Audioproduktion in einer DAW (Ableton, Logic, Pro Tools)
- Musikkomposition oder MIDI-Programmierung
Schlüsselprinzipien
-
Mehrschichtige Audio-Architektur – Jedes Video hat drei Audiospuren: Erzählung oben (am lautesten), SFX in der Mitte (Akzentlautstärke) und Hintergrundmusik an der Basis (am leisesten).
-
Erzählung bestimmt das Timing – Generiere zuerst die Erzählung, messe ihre Dauer und stimme dann die Szenenzeitsteuerung darauf ab. Passe die Erzählung niemals an willkürliche Szenenlängen an.
-
Ducke Musik während der Sprache – Hintergrundmusik muss um 50-60% sinken, wenn die Erzählung läuft. Verwende sanfte Rampen (10-15 Frames), um abrupte Wechsel zu vermeiden.
-
SFX als Akzente, nicht als Ablenkung – Halte SFX kurz (unter 0,5s), subtil in der Lautstärke und relevant für die Bildschirmaktion.
-
Teste Audio im Kontext – Vorschau des vollständigen Mixes immer mit allen Ebenen zusammen. Achte auf undeutliche Sprache, Lautstärkespitzen oder tote Stille.
Kernkonzepte
3-schichtige Audio-Architektur
| Schicht | Rolle | Basislautstärke | Während der Erzählung |
|---|---|---|---|
| Erzählung | Vermittelt Informationen, bestimmt das Tempo | 0,8-1,0 | N/A (oberste Schicht) |
| SFX | Betont Übergänge und Aktionen | 0,3-0,5 | 0,3-0,5 (unverändert) |
| Hintergrundmusik | Setzt emotionale Stimmung, füllt Stille | 0,3-0,5 | 0,15-0,25 (geduckt) |
ElevenLabs API-Modell
ElevenLabs bietet neuronales TTS über eine REST-API. Der Kernablauf:
- Wähle eine Stimme (vorgefertigt oder geklont) – jede hat eine
voice_id - Sende Text + Stimmeneinstellungen an
/v1/text-to-speech/{voice_id} - Erhalte rohe Audiobytes (standardmäßig mp3)
- Schreibe in eine Datei und messe die Dauer für das Szenen-Timing
Stimmeneinstellungen:
| Einstellung | Bereich | Niedrig | Hoch | Empfohlen |
|---|---|---|---|---|
| stability | 0-1 | Ausdrucksstärker, variabel | Konsistenter, monotoner | 0,4-0,6 |
| similarity_boost | 0-1 | Kreativer | Näher an der Originalstimme | 0,6-0,8 |
| style | 0-1 | Neutrale Wiedergabe | Übertriebener Stil | 0,3-0,6 |
Konzept des Audio-Duckings
Audio-Ducking reduziert die Lautstärke der Hintergrundmusik, wenn die Erzählung beginnt, und stellt sie wieder her, wenn die Erzählung endet. Verwende in Remotion interpolate():
Musiklautstärke: 0.4 ---\ /--- 0.4
\ /
0.15 \__________/
Erzählung start → Ende
Rampen sollten 10-15 Frames dauern (~0,3-0,5s bei 30fps).
Frame-basierte Audio-Synchronisation in Remotion
useCurrentFrame()gibt die aktuelle Frame-Nummer zurückinterpolate()bildet Frame-Bereiche auf Wertebereiche ab (z. B. Lautstärke)<Sequence from={frame}>platziert Audio an einem bestimmten Frame<Audio volume={fn}>akzeptiert eine statische Zahl oder eine Frame-Funktion
Sekunden in Frames umrechnen: frames = seconds * fps.
Häufige Aufgaben
1. ElevenLabs API-Schlüssel einrichten und Erzählung generieren
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(`ElevenLabs API error ${response.status}: ${error}`);
}
const buffer = Buffer.from(await response.arrayBuffer());
fs.writeFileSync(outputPath, buffer);
}
2. Stimme auswählen und Stimmeneinstellungen konfigurieren
Fragen zur Stimmenauswahl: Geschlecht, Altersgruppe, Akzent, Energielevel, Wärme.
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. Erzählung pro Szene aus einem Skript generieren
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. Hintergrundmusik beschaffen
Quellen für lizenzfreie Musik:
- Pixabay Audio: https://pixabay.com/music/ (kostenlos, keine Namensnennung erforderlich)
- Freesound: https://freesound.org/ (CC0/CC-BY)
- YouTube Audio Library: Download über YouTube Studio
- Lokale Dateien: Lege sie in
public/audio/für RemotionsstaticFile()ab
5. SFX mit FFmpeg generieren
# Klickgeräusch - kurzer Sinusburst
ffmpeg -f lavfi -i "sine=frequency=800:duration=0.05" \
-af "afade=t=out:st=0.02:d=0.03" click.wav
# Tastaturtippen - gefilterter Rauschburst
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 - Frequenzdurchlauf
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/Klingel - Glockensynthese
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 - Impuls
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
# Übergangs-Swoosh
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. Audio-Ducking in Remotion implementieren
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. 3 Audiospuren in einer Remotion-Komposition mischen
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. Alternative TTS-Anbieter verwenden
OpenAI TTS – gute Qualität, einfache API, sechs integrierte Stimmen:
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 – kostenlos, viele Stimmen, verwendet den TTS-Dienst von Microsoft Edge:
pip install edge-tts
edge-tts --voice de-DE-KatjaNeural --text "Hallo Welt" --write-media output.mp3
edge-tts --list-voices
Anti-Patterns / häufige Fehler
| Fehler | Warum es falsch ist | Was stattdessen zu tun ist |
|---|---|---|
| Musik in gleicher Lautstärke während der Erzählung | Sprache wird unverständlich | Audio-Ducking implementieren – Musik während der Sprache um 50-60% absenken |
| ElevenLabs API-Schlüssel fest codieren | Schlüssel gelangt in die Versionskontrolle | Umgebungsvariablen verwenden: process.env.ELEVEN_LABS_API_KEY |
| TTS ohne Messung der Dauer verwenden | Szenen-Timing falsch, Erzählung abgeschnitten | Audiodauer mit ffprobe nach der Generierung messen |
| SFX lauter als die Erzählung | Lenkt vom Inhalt ab | SFX bei 0,3-0,5, Erzählung bei 0,8-1,0 |
| Kein Ein-/Ausblenden am Start/Ende der Musik | Abrupter Start/Stopp wirkt wie ein Fehler | Füge am Anfang ein Einblenden von 0,5-1s und am Ende ein Ausblenden hinzu |
| Verwendung eines minderwertigen TTS-Modells | Roboterhafte Stimme beeinträchtigt die Qualität | Verwende eleven_multilingual_v2 oder tts-1-hd |
| Audio-Dateiformat ignorieren | Manche Formate fügen Stille-Padding hinzu | Verwende MP3 für Erzählungen, WAV für SFX |
Fallstricke
-
ElevenLabs Ratenbegrenzungen und Zeichenkontingente – Der kostenlose Tarif hat ein monatliches Zeichenlimit. Generiertes Audio aggressiv cachen und nur neu generieren, wenn sich der Text ändert. Verwende einen Hash des Textes als Cache-Schlüssel.
-
MP3-Encoder-Padding fügt Stille hinzu – MP3-Dateien haben oft 20-50 ms Stille am Anfang. Schneide sie mit
ffmpeg -af silenceremove=1:0:-50dBoder berücksichtige den Offset im Frame-Timing. -
Remotion Audio-Lautstärke ist pro Komponente, nicht global – Zwei
<Audio>-Komponenten mit Lautstärke 1.0 können übersteuern. Halte die Gesamtlautstärke über gleichzeitige Spuren unter 1.0. -
FFmpeg SFX klingen auf verschiedenen Systemen unterschiedlich – Gib immer
-ar 44100 -sample_fmt s16für konsistente Ausgabe auf verschiedenen Rechnern an. -
Stimmkonsistenz über Szenen hinweg – ElevenLabs kann bei denselben Einstellungen mit unterschiedlichem Text verschiedene Töne erzeugen. Verwende stability >= 0.5 für szenenübergreifende Erzählungen.
Referenzen
Ausführliche Muster zu spezifischen Audio-Teilbereichen findest du in den entsprechenden Dateien
im Ordner references/:
references/elevenlabs-api.md– Fortgeschrittene ElevenLabs API-Muster inklusive Stimmklonen, Streaming-TTS, WebSocket-API, Aussprachewörterbüchern und Kontingentverwaltungreferences/audio-mixing-patterns.md– Fortgeschrittene Mischmuster inklusive Multi-Segment-Ducking, Überblendungen zwischen Szenen, Lautstärke-Automatisierungskurven und Abmischen des endgültigen Mixesreferences/sfx-generation.md– Umfassende SFX-Generierung mit FFmpeg inklusive komplexer Synthese, Überlagerung mehrerer Generatoren und Aufbau einer wiederverwendbaren SFX-Bibliothek
Lade eine Referenzdatei nur dann, wenn die aktuelle Aufgabe sie erfordert – sie sind lang und verbrauchen Kontext.
Companion-Prüfung
Bei der ersten Aktivierung von ...
[gekürzt]