Remotion -- Criação de Vídeos em React
Use esta habilidade ao trabalhar com código Remotion. O Remotion permite criar vídeos programaticamente usando componentes React.
Configuração do Projeto
npx create-video@latest meu-video
cd meu-video
npm start # Visualizar no navegador
npm run render # Renderizar para MP4
Composições
Um <Composition> define um vídeo renderizável com dimensões, fps e duração.
import { Composition } from "remotion";
import { MyVideo } from "./MyVideo";
export const RemotionRoot = () => (
<Composition
id="MyVideo"
component={MyVideo}
durationInFrames={300}
fps={30}
width={1920}
height={1080}
defaultProps={{ title: "Olá Mundo" } satisfies MeuVideoProps}
/>
);
Use declarações type para props (não interface) para segurança de tipo com defaultProps.
Use <Folder> para organizar composições na barra lateral. Use <Still> para saídas de quadro único (miniaturas, imagens OG).
Animações
Todas as animações DEVEM usar useCurrentFrame(). Transições CSS e classes de animação do Tailwind são PROIBIDAS -- elas não serão renderizadas corretamente.
import { useCurrentFrame, useVideoConfig, interpolate } from "remotion";
export const FadeIn = () => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const opacity = interpolate(frame, [0, 2 * fps], [0, 1], {
extrapolateRight: "clamp",
});
return <div style={{ opacity }}>Olá Mundo!</div>;
};
Animações com Spring
Springs fornecem movimento natural. Elas animam de 0 a 1.
import { spring, useCurrentFrame, useVideoConfig } from "remotion";
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const scale = spring({ frame, fps });
// Com configuração:
const smooth = spring({ frame, fps, config: { damping: 200 } }); // Sem salto
const snappy = spring({ frame, fps, config: { damping: 20, stiffness: 200 } });
const bouncy = spring({ frame, fps, config: { damping: 8 } });
const heavy = spring({ frame, fps, config: { damping: 15, stiffness: 80, mass: 2 } });
Use o parâmetro delay para atrasar o início do spring:
const entrance = spring({ frame, fps, delay: 20 });
Interpolação
// Interpolação linear com clamp
const opacity = interpolate(frame, [0, 100], [0, 1], {
extrapolateRight: "clamp",
extrapolateLeft: "clamp",
});
// Interpolação de múltiplas etapas
const y = interpolate(frame, [0, 30, 60, 90], [100, 0, 0, -100]);
Sequenciamento
Sequence
Use <Sequence> para atrasar quando os elementos aparecem. Sempre use premountFor para pré-carregar componentes.
import { Sequence } from "remotion";
const { fps } = useVideoConfig();
<Sequence from={1 * fps} durationInFrames={2 * fps} premountFor={1 * fps}>
<Title />
</Sequence>
<Sequence from={2 * fps} durationInFrames={2 * fps} premountFor={1 * fps}>
<Subtitle />
</Sequence>
Use layout="none" para evitar o wrapper de posicionamento absoluto.
Series
Use <Series> para reprodução sequencial sem sobreposição:
import { Series } from "remotion";
<Series>
<Series.Sequence durationInFrames={45}><Intro /></Series.Sequence>
<Series.Sequence durationInFrames={60}><ConteudoPrincipal /></Series.Sequence>
<Series.Sequence durationInFrames={30}><Outro /></Series.Sequence>
</Series>
offset negativo cria transições sobrepostas:
<Series.Sequence offset={-15} durationInFrames={60}>
<CenaB />
</Series.Sequence>
Transições
npx remotion add @remotion/transitions
import { TransitionSeries, linearTiming } from "@remotion/transitions";
import { fade } from "@remotion/transitions/fade";
import { slide } from "@remotion/transitions/slide";
import { wipe } from "@remotion/transitions/wipe";
<TransitionSeries>
<TransitionSeries.Sequence durationInFrames={60}>
<CenaA />
</TransitionSeries.Sequence>
<TransitionSeries.Transition
presentation={fade()}
timing={linearTiming({ durationInFrames: 15 })}
/>
<TransitionSeries.Sequence durationInFrames={60}>
<CenaB />
</TransitionSeries.Sequence>
</TransitionSeries>
Sobreposições de Vazamento de Luz
import { LightLeak } from "@remotion/light-leaks";
<TransitionSeries>
<TransitionSeries.Sequence durationInFrames={60}>
<CenaA />
</TransitionSeries.Sequence>
<TransitionSeries.Overlay durationInFrames={20}>
<LightLeak />
</TransitionSeries.Overlay>
<TransitionSeries.Sequence durationInFrames={60}>
<CenaB />
</TransitionSeries.Sequence>
</TransitionSeries>
Uma sobreposição não pode ser adjacente a uma transição ou a outra sobreposição.
Áudio
npx remotion add @remotion/media
import { Audio } from "@remotion/media";
import { staticFile } from "remotion";
// Áudio básico
<Audio src={staticFile("audio.mp3")} />
// Com corte (valores em frames)
<Audio src={staticFile("audio.mp3")} trimBefore={2 * fps} trimAfter={10 * fps} />
// Controle de volume
<Audio src={staticFile("audio.mp3")} volume={0.5} />
// Volume dinâmico (callback recebe o frame)
<Audio src={staticFile("audio.mp3")} volume={(f) =>
interpolate(f, [0, 30], [0, 1], { extrapolateRight: "clamp" })
} />
// Mudança de velocidade
<Audio src={staticFile("audio.mp3")} playbackRate={1.5} />
// Atraso no início do áudio
<Sequence from={1 * fps}>
<Audio src={staticFile("audio.mp3")} />
</Sequence>
Múltiplos componentes <Audio> são sobrepostos automaticamente.
Incorporação de Vídeo
import { Video } from "@remotion/media";
// Vídeo básico
<Video src={staticFile("video.mp4")} />
// Com corte
<Video src={staticFile("video.mp4")} trimBefore={2 * fps} trimAfter={10 * fps} />
// Velocidade, volume, loop
<Video src={staticFile("video.mp4")} playbackRate={2} volume={0.5} loop />
// Para desempenho de renderização, use OffthreadVideo
import { OffthreadVideo } from "remotion";
<OffthreadVideo src={staticFile("video.mp4")} />
SEMPRE use <OffthreadVideo> para melhor desempenho de renderização. Use <Video> apenas durante a pré-visualização.
Locução com ElevenLabs TTS
Gere áudio por cena e use calculateMetadata para dimensionar a composição dinamicamente.
Gerar Áudio
const response = await fetch(
`https://api.elevenlabs.io/v1/text-to-speech/${voiceId}`,
{
method: "POST",
headers: {
"xi-api-key": process.env.ELEVENLABS_API_KEY!,
"Content-Type": "application/json",
Accept: "audio/mpeg",
},
body: JSON.stringify({
text: "Bem-vindo ao show.",
model_id: "eleven_multilingual_v2",
voice_settings: { stability: 0.5, similarity_boost: 0.75, style: 0.3 },
}),
},
);
const audioBuffer = Buffer.from(await response.arrayBuffer());
writeFileSync(`public/locucao/cena-01.mp3`, audioBuffer);
Duração Dinâmica
import { CalculateMetadataFunction, staticFile } from "remotion";
const FPS = 30;
const CENAS = ["locucao/cena-01.mp3", "locucao/cena-02.mp3"];
export const calculateMetadata: CalculateMetadataFunction<Props> = async () => {
const durations = await Promise.all(
CENAS.map((file) => getAudioDuration(staticFile(file)))
);
const totalFrames = durations.reduce((sum, d) => sum + Math.ceil(d * FPS), 0);
return { durationInFrames: totalFrames };
};
Ativos
Coloque os arquivos em public/ e faça referência com staticFile():
import { staticFile, Img } from "remotion";
<Img src={staticFile("logo.png")} />
NUNCA use require() ou import para arquivos de mídia. Sempre use staticFile().
Fontes
import { loadFont } from "@remotion/google-fonts/Inter";
const { fontFamily } = loadFont();
// Ou fontes locais
const { fontFamily } = loadFont({
url: staticFile("fonts/MinhaFonte.woff2"),
display: "swap",
});
FFmpeg no Remotion
FFmpeg já está incluído -- não é necessário instalar:
bunx remotion ffmpeg -i input.mp4 output.mp3
bunx remotion ffprobe input.mp4
Para cortar, prefira as props trimBefore/trimAfter em vez do FFmpeg. Use FFmpeg para conversão de formatos ou operações que o Remotion não pode fazer nativamente.
Ao usar FFmpeg para cortar, é NECESSÁRIO recodificar para evitar quadros congelados:
bunx remotion ffmpeg -ss 00:00:05 -i public/input.mp4 -to 00:00:10 -c:v libx264 -c:a aac public/output.mp4
Renderização
# Renderizar composição específica
npx remotion render MyVideo output.mp4
# Renderizar um quadro estático
npx remotion still MyVideo --frame=100 thumbnail.png
# Com props personalizadas
npx remotion render MyVideo output.mp4 --props='{"title": "Personalizado"}'
# Codec específico
npx remotion render MyVideo output.webm --codec=vp8
Padrões Comuns
Vídeo Baseado em Cenas
const CENAS = [
{ component: CenaTitulo, duration: 90 },
{ component: CenaProblema, duration: 150 },
{ component: CenaSolucao, duration: 120 },
{ component: CenaCTA, duration: 90 },
];
export const MyVideo = () => {
let offset = 0;
return (
<>
{CENAS.map(({ component: Component, duration }, i) => {
const from = offset;
offset += duration;
return (
<Sequence key={i} from={from} durationInFrames={duration}>
<Component />
</Sequence>
);
})}
</>
);
};
Música de Fundo + Locução
<>
{/* Música de fundo em volume baixo */}
<Audio src={staticFile("musica/bg.mp3")} volume={0.12} loop />
{/* Locuções das cenas em volume total */}
<Sequence from={0} durationInFrames={framesCena1}>
<Audio src={staticFile("locucao/cena-01.mp3")} volume={1} />
</Sequence>
<Sequence from={framesCena1} durationInFrames={framesCena2}>
<Audio src={staticFile("locucao/cena-02.mp3")} volume={1} />
</Sequence>
</>
Regras Principais
- Sem animações CSS -- todo movimento via
useCurrentFrame()+interpolate()/spring() - Sem classes de animação do Tailwind -- elas não renderizam corretamente
- Sempre
staticFile()para ativos, nuncarequire() - Sempre pré-monte Sequences com
premountFor - Use
<OffthreadVideo>em vez de<video>para renderização - Escreva durações em segundos e multiplique por
fps - Use a palavra-chave
satisfiespara segurança de tipo comdefaultProps
Fonte: remotion-dev/skills, remotion.dev