Remotion -- Création de vidéos en React
Utilisez ce skill lorsque vous travaillez avec du code Remotion. Remotion vous permet de créer des vidéos de manière programmatique en utilisant des composants React.
Configuration du projet
npx create-video@latest my-video
cd my-video
npm start # Aperçu dans le navigateur
npm run render # Rendu en MP4
Compositions
Un <Composition> définit une vidéo rendable avec ses dimensions, son FPS et sa durée.
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: "Bonjour le monde" } satisfies MyVideoProps}
/>
);
Utilisez les déclarations type pour les props (pas interface) afin d'assurer la sécurité de typage des defaultProps.
Utilisez <Folder> pour organiser les compositions dans la barre latérale. Utilisez <Still> pour les sorties mono-image (miniatures, images OG).
Animations
Toutes les animations DOIVENT utiliser useCurrentFrame(). Les transitions CSS et les classes d'animation Tailwind sont INTERDITES -- elles ne seront pas rendues correctement.
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 }}>Bonjour le monde !</div>;
};
Animations par ressort (Spring)
Les ressorts produisent un mouvement naturel. Ils animent de 0 à 1.
import { spring, useCurrentFrame, useVideoConfig } from "remotion";
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const scale = spring({ frame, fps });
// Avec configuration :
const smooth = spring({ frame, fps, config: { damping: 200 } }); // Pas de rebond
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 } });
Utilisez le paramètre delay pour retarder le démarrage du ressort :
const entrance = spring({ frame, fps, delay: 20 });
Interpolation
// Interpolation linéaire avec limitation
const opacity = interpolate(frame, [0, 100], [0, 1], {
extrapolateRight: "clamp",
extrapolateLeft: "clamp",
});
// Interpolation multi-étapes
const y = interpolate(frame, [0, 30, 60, 90], [100, 0, 0, -100]);
Séquençage
Sequence
Utilisez <Sequence> pour retarder l'apparition des éléments. Utilisez toujours premountFor pour précharger les composants.
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>
Utilisez layout="none" pour éviter le wrapper de positionnement absolu.
Series
Utilisez <Series> pour une lecture séquentielle sans chevauchement :
import { Series } from "remotion";
<Series>
<Series.Sequence durationInFrames={45}><Intro /></Series.Sequence>
<Series.Sequence durationInFrames={60}><MainContent /></Series.Sequence>
<Series.Sequence durationInFrames={30}><Outro /></Series.Sequence>
</Series>
Un offset négatif crée des transitions avec chevauchement :
<Series.Sequence offset={-15} durationInFrames={60}>
<SceneB />
</Series.Sequence>
Transitions
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}>
<SceneA />
</TransitionSeries.Sequence>
<TransitionSeries.Transition
presentation={fade()}
timing={linearTiming({ durationInFrames: 15 })}
/>
<TransitionSeries.Sequence durationInFrames={60}>
<SceneB />
</TransitionSeries.Sequence>
</TransitionSeries>
Superpositions de fuites de lumière
import { LightLeak } from "@remotion/light-leaks";
<TransitionSeries>
<TransitionSeries.Sequence durationInFrames={60}>
<SceneA />
</TransitionSeries.Sequence>
<TransitionSeries.Overlay durationInFrames={20}>
<LightLeak />
</TransitionSeries.Overlay>
<TransitionSeries.Sequence durationInFrames={60}>
<SceneB />
</TransitionSeries.Sequence>
</TransitionSeries>
Une superposition ne peut pas être adjacente à une transition ou à une autre superposition.
Audio
npx remotion add @remotion/media
import { Audio } from "@remotion/media";
import { staticFile } from "remotion";
// Audio de base
<Audio src={staticFile("audio.mp3")} />
// Avec rognage (valeurs en images)
<Audio src={staticFile("audio.mp3")} trimBefore={2 * fps} trimAfter={10 * fps} />
// Contrôle du volume
<Audio src={staticFile("audio.mp3")} volume={0.5} />
// Volume dynamique (callback reçoit l'image)
<Audio src={staticFile("audio.mp3")} volume={(f) =>
interpolate(f, [0, 30], [0, 1], { extrapolateRight: "clamp" })
} />
// Changement de vitesse
<Audio src={staticFile("audio.mp3")} playbackRate={1.5} />
// Démarrage audio différé
<Sequence from={1 * fps}>
<Audio src={staticFile("audio.mp3")} />
</Sequence>
Plusieurs composants <Audio> se superposent automatiquement.
Intégration vidéo
import { Video } from "@remotion/media";
// Vidéo de base
<Video src={staticFile("video.mp4")} />
// Avec rognage
<Video src={staticFile("video.mp4")} trimBefore={2 * fps} trimAfter={10 * fps} />
// Vitesse, volume, boucle
<Video src={staticFile("video.mp4")} playbackRate={2} volume={0.5} loop />
// Pour les performances de rendu, utilisez OffthreadVideo
import { OffthreadVideo } from "remotion";
<OffthreadVideo src={staticFile("video.mp4")} />
Utilisez TOUJOURS <OffthreadVideo> pour de meilleures performances de rendu. Utilisez <Video> uniquement pendant l'aperçu.
Voix off avec ElevenLabs TTS
Générez la parole par scène, puis utilisez calculateMetadata pour dimensionner la composition dynamiquement.
Générer l'audio
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: "Bienvenue dans le spectacle.",
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/voiceover/scene-01.mp3`, audioBuffer);
Durée dynamique
import { CalculateMetadataFunction, staticFile } from "remotion";
const FPS = 30;
const SCENES = ["voiceover/scene-01.mp3", "voiceover/scene-02.mp3"];
export const calculateMetadata: CalculateMetadataFunction<Props> = async () => {
const durations = await Promise.all(
SCENES.map((file) => getAudioDuration(staticFile(file)))
);
const totalFrames = durations.reduce((sum, d) => sum + Math.ceil(d * FPS), 0);
return { durationInFrames: totalFrames };
};
Ressources
Placez les fichiers dans public/ et référencez-les avec staticFile() :
import { staticFile, Img } from "remotion";
<Img src={staticFile("logo.png")} />
N'utilisez JAMAIS require() ou import pour les fichiers multimédia. Utilisez toujours staticFile().
Polices
import { loadFont } from "@remotion/google-fonts/Inter";
const { fontFamily } = loadFont();
// Ou polices locales
const { fontFamily } = loadFont({
url: staticFile("fonts/MyFont.woff2"),
display: "swap",
});
FFmpeg dans Remotion
FFmpeg est intégré -- aucune installation nécessaire :
bunx remotion ffmpeg -i input.mp4 output.mp3
bunx remotion ffprobe input.mp4
Pour le rognage, préférez les props trimBefore/trimAfter à FFmpeg. Utilisez FFmpeg pour la conversion de format ou les opérations que Remotion ne peut pas effectuer nativement.
Lorsque vous utilisez FFmpeg pour rogner, vous DEVEZ ré-encoder pour éviter les images figées :
bunx remotion ffmpeg -ss 00:00:05 -i public/input.mp4 -to 00:00:10 -c:v libx264 -c:a aac public/output.mp4
Rendu
# Rendre une composition spécifique
npx remotion render MyVideo output.mp4
# Rendre une image fixe
npx remotion still MyVideo --frame=100 thumbnail.png
# Avec des props personnalisées
npx remotion render MyVideo output.mp4 --props='{"title": "Personnalisé"}'
# Codec spécifique
npx remotion render MyVideo output.webm --codec=vp8
Modèles courants
Vidéo basée sur des scènes
const SCENES = [
{ component: TitleScene, duration: 90 },
{ component: ProblemScene, duration: 150 },
{ component: SolutionScene, duration: 120 },
{ component: CTAScene, duration: 90 },
];
export const MyVideo = () => {
let offset = 0;
return (
<>
{SCENES.map(({ component: Component, duration }, i) => {
const from = offset;
offset += duration;
return (
<Sequence key={i} from={from} durationInFrames={duration}>
<Component />
</Sequence>
);
})}
</>
);
};
Musique de fond + voix off
<>
{/* Musique de fond à faible volume */}
<Audio src={staticFile("music/bg.mp3")} volume={0.12} loop />
{/* Voix off des scènes à plein volume */}
<Sequence from={0} durationInFrames={scene1Frames}>
<Audio src={staticFile("voiceover/scene-01.mp3")} volume={1} />
</Sequence>
<Sequence from={scene1Frames} durationInFrames={scene2Frames}>
<Audio src={staticFile("voiceover/scene-02.mp3")} volume={1} />
</Sequence>
</>
Règles clés
- Pas d'animations CSS -- tout mouvement via
useCurrentFrame()+interpolate()/spring() - Pas de classes d'animation Tailwind -- elles ne sont pas rendues correctement
- Toujours
staticFile()pour les ressources, jamaisrequire() - Toujours prémonter les Sequences avec
premountFor - Utilisez
<OffthreadVideo>pas<video>pour le rendu - Écrivez les durées en secondes et multipliez par
fps - Utilisez le mot-clé
satisfiespour la sécurité de typage desdefaultProps
Source : remotion-dev/skills, remotion.dev