Quando esta habilidade for ativada, sempre comece sua primeira resposta com o emoji :speaker:.
Design de Áudio para Vídeo
O design de áudio para vídeo é a prática de sobrepor narração, efeitos sonoros e música de fundo em composições de vídeo programáticas. Um bom áudio transforma um vídeo de apresentação de slides em uma produção polida - a narração guia o espectador, a música define o tom emocional e os efeitos sonoros pontuam momentos-chave. Esta habilidade cobre a geração de fala com ElevenLabs e provedores TTS alternativos, a criação de efeitos sonoros sintéticos com FFmpeg, a obtenção de música de fundo livre de direitos autorais, a implementação de duck de áudio para manter a fala inteligível e a mixagem de todas as camadas em composições Remotion com sincronismo preciso de quadros.
Quando usar esta habilidade
Ative esta habilidade quando o usuário:
- Quiser adicionar narração ou locução a um vídeo programático
- Precisar gerar fala com ElevenLabs, OpenAI TTS ou Edge TTS
- Perguntar sobre seleção de voz, configurações de voz ou clonagem de voz
- Quiser adicionar música de fundo ou precisar de fontes de música livre de direitos
- Perguntar sobre criação programática de efeitos sonoros
- Quiser implementar duck de áudio (reduzir a música durante a fala)
- Precisar mixar múltiplas camadas de áudio no Remotion
- Perguntar sobre sincronismo de áudio, níveis de volume ou sincronia baseada em quadros
NÃO ative esta habilidade para:
- Roteirização de vídeo ou storyboard - use a habilidade de video-scriptwriting
- Arquitetura de componentes Remotion ou renderização - use a habilidade remotion-video
- Produção de áudio profissional em uma DAW (Ableton, Logic, Pro Tools)
- Composição musical ou programação MIDI
Princípios-chave
-
Arquitetura de áudio em camadas - Cada vídeo tem três camadas de áudio: narração no topo (mais alta), SFX no meio (volume de acento) e música de fundo na base (mais baixa).
-
A narração define o tempo - Gere a narração primeiro, meça sua duração e depois ajuste o tempo das cenas para corresponder. Nunca force a narração a se encaixar em durações de cena arbitrárias.
-
Faça duck da música durante a fala - A música de fundo deve cair 50-60% quando a narração toca. Use rampas suaves (10-15 quadros) para evitar mudanças bruscas.
-
SFX como acentos, não distrações - Mantenha os SFX curtos (menos de 0,5s), sutis em volume e relevantes para a ação na tela.
-
Teste o áudio em contexto - Sempre pré-visualize a mixagem completa com todas as camadas juntas. Ouça por fala turva, picos de volume ou silêncio absoluto.
Conceitos centrais
Arquitetura de áudio em 3 camadas
| Camada | Função | Volume Base | Durante a Narração |
|---|---|---|---|
| Narração | Transmite informações, define o ritmo | 0,8-1,0 | N/A (camada superior) |
| SFX | Acentua transições e ações | 0,3-0,5 | 0,3-0,5 (inalterado) |
| Música de Fundo | Define o tom emocional, preenche o silêncio | 0,3-0,5 | 0,15-0,25 (com duck) |
Modelo da API ElevenLabs
ElevenLabs fornece TTS neural via uma API REST. O fluxo principal:
- Escolha uma voz (pré-criada ou clonada) - cada uma tem um
voice_id - Envie texto + configurações de voz para
/v1/text-to-speech/{voice_id} - Receba os bytes de áudio brutos (mp3 por padrão)
- Escreva em um arquivo e meça a duração para o tempo da cena
Configurações de voz:
| Configuração | Faixa | Baixo | Alto | Recomendado |
|---|---|---|---|---|
| stability | 0-1 | Mais expressivo, variável | Mais consistente, monótono | 0,4-0,6 |
| similarity_boost | 0-1 | Mais criativo | Mais próximo da voz original | 0,6-0,8 |
| style | 0-1 | Entrega neutra | Estilo exagerado | 0,3-0,6 |
Conceito de duck de áudio
O duck de áudio reduz o volume da música de fundo quando a narração começa e o restaura quando a narração termina. No Remotion, use interpolate():
Volume da música: 0.4 ---\ /--- 0.4
\ /
0.15 \__________/
início da narração → fim
As rampas devem levar 10-15 quadros (~0,3-0,5s a 30fps).
Sincronismo de áudio baseado em quadros no Remotion
useCurrentFrame()retorna o número do quadro atualinterpolate()mapeia intervalos de quadros para intervalos de valores (por exemplo, volume)<Sequence from={frame}>posiciona o áudio em um quadro específico<Audio volume={fn}>aceita um número estático ou uma função por quadro
Converta segundos em quadros: quadros = segundos * fps.
Tarefas comuns
1. Configurar a chave da API ElevenLabs e gerar narração
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. Selecionar e configurar configurações de voz
Perguntas para seleção de voz: gênero, faixa etária, sotaque, nível de energia, calor.
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. Gerar narração por cena a partir de um roteiro
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. Encontrar música de fundo
Fontes de música livre de direitos:
- Pixabay Audio: https://pixabay.com/music/ (gratuito, sem atribuição)
- Freesound: https://freesound.org/ (CC0/CC-BY)
- YouTube Audio Library: baixe do YouTube Studio
- Arquivos locais: coloque em
public/audio/parastaticFile()do Remotion
5. Gerar SFX com FFmpeg
# Som de clique - curta explosão senoidal
ffmpeg -f lavfi -i "sine=frequency=800:duration=0.05" \
-af "afade=t=out:st=0.02:d=0.03" click.wav
# Som de digitação - explosão de ruído filtrado
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 - varredura de frequência
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/timbre - síntese de sino
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 - impulso
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 transição
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. Implementar duck de áudio no 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. Mixar 3 camadas de áudio em uma composição 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. Usar provedores TTS alternativos
OpenAI TTS - boa qualidade, API simples, seis vozes integradas:
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 - gratuito, muitas vozes, usa o serviço TTS do Microsoft Edge:
pip install edge-tts
edge-tts --voice en-US-AriaNeural --text "Hello world" --write-media output.mp3
edge-tts --list-voices
Antipadrões / erros comuns
| Erro | Por que está errado | O que fazer em vez disso |
|---|---|---|
| Música no mesmo volume durante a narração | A fala se torna ininteligível | Implemente duck de áudio - reduza a música em 50-60% durante a fala |
| Codificar a chave da API ElevenLabs | A chave vaza no controle de versão | Use variáveis de ambiente: process.env.ELEVEN_LABS_API_KEY |
| Usar TTS sem medir a duração | O tempo da cena fica errado, a narração é cortada | Meça a duração do áudio com ffprobe após a geração |
| SFX mais alto que a narração | Distrai do conteúdo | SFX a 0,3-0,5, narração a 0,8-1,0 |
| Sem fade no início/fim da música | Início/parada abruptos soam como um bug | Adicione 0,5-1s de fade-in no início e fade-out no final |
| Usar modelo TTS de baixa qualidade | Voz robótica prejudica a qualidade | Use eleven_multilingual_v2 ou tts-1-hd |
| Ignorar o formato do arquivo de áudio | Alguns formatos adicionam silêncio | Use MP3 para narração, WAV para SFX |
Armadilhas
-
Limites de taxa e cotas de caracteres do ElevenLabs - O plano gratuito tem um limite mensal de caracteres. Armazene em cache o áudio gerado agressivamente e só regenere quando o texto mudar. Use um hash do texto como chave de cache.
-
O padding do codificador MP3 adiciona silêncio - Arquivos MP3 geralmente têm 20-50ms de silêncio no início. Apare com
ffmpeg -af silenceremove=1:0:-50dBou considere o deslocamento no tempo dos quadros. -
O volume do áudio no Remotion é por componente, não global - Dois componentes
<Audio>no volume 1.0 podem distorcer. Mantenha o volume total entre camadas simultâneas abaixo de 1.0. -
SFX do FFmpeg soam diferentes entre sistemas - Sempre especifique
-ar 44100 -sample_fmt s16para uma saída consistente entre máquinas. -
Consistência de voz entre cenas - O ElevenLabs pode produzir tons diferentes para as mesmas configurações com texto variado. Use stability >= 0,5 para narração em várias cenas.
Referências
Para padrões detalhados em subdomínios específicos de áudio, leia o arquivo relevante da pasta references/:
references/elevenlabs-api.md- padrões avançados da API ElevenLabs, incluindo clonagem de voz, TTS streaming, API websocket, dicionários de pronúncia e gerenciamento de cotasreferences/audio-mixing-patterns.md- padrões de mixagem avançados, incluindo duck multi-segmento, crossfades entre cenas, curvas de automação de volume e masterização da mixagem finalreferences/sfx-generation.md- geração abrangente de SFX com FFmpeg, incluindo síntese complexa, sobreposição de múltiplos geradores e construção de uma biblioteca SFX reutilizável
Carregue um arquivo de referência apenas se a tarefa atual o exigir - eles são longos e consumirão contexto.
Verificação complementar
Na primeira ativação de...