🎥 Make videos programmatically with React
/* eslint-disable @typescript-eslint/no-explicit-any */
import {
CallbackListener,
ErrorFallback,
Player,
PlayerRef,
RenderLoading,
RenderPoster,
} from '@remotion/player';
import React, {
ComponentType,
ReactNode,
useCallback,
useEffect,
useMemo,
useRef,
useState,
} from 'react';
import {AbsoluteFill} from 'remotion';
import {playerExampleComp} from './CarSlideshow';
import {Loading} from './Loading';
import {TimeDisplay} from './TimeDisplay';
const fps = 30;
type AnyComponent<T> = ComponentType<T> | ((props: T) => ReactNode);
type CompProps<T> =
| {
lazyComponent: () => Promise<{default: AnyComponent<T>}>;
}
| {
component: AnyComponent<T>;
};
const ControlsOnly: React.FC<{
readonly playerRef: React.RefObject<PlayerRef | null>;
readonly color: string;
readonly setColor: React.Dispatch<React.SetStateAction<string>>;
readonly title: string;
readonly setTitle: React.Dispatch<React.SetStateAction<string>>;
readonly bgColor: string;
readonly setBgColor: React.Dispatch<React.SetStateAction<string>>;
readonly setPlaybackRate: React.Dispatch<React.SetStateAction<number>>;
readonly loop: boolean;
readonly setLoop: React.Dispatch<React.SetStateAction<boolean>>;
readonly clickToPlay: boolean;
readonly setClickToPlay: React.Dispatch<React.SetStateAction<boolean>>;
readonly doubleClickToFullscreen: boolean;
readonly setDoubleClickToFullscreen: React.Dispatch<
React.SetStateAction<boolean>
>;
readonly spaceKeyToPlayOrPause: boolean;
readonly setSpaceKeyToPlayOrPause: React.Dispatch<
React.SetStateAction<boolean>
>;
readonly moveToBeginningWhenEnded: boolean;
readonly setMoveToBeginningWhenEnded: React.Dispatch<
React.SetStateAction<boolean>
>;
readonly showPosterWhenUnplayed: boolean;
readonly setshowPosterWhenUnplayed: React.Dispatch<
React.SetStateAction<boolean>
>;
readonly showPosterWhenEnded: boolean;
readonly setShowPosterWhenEnded: React.Dispatch<
React.SetStateAction<boolean>
>;
readonly showPosterWhenPaused: boolean;
readonly setShowPosterWhenPaused: React.Dispatch<
React.SetStateAction<boolean>
>;
readonly inFrame: number | null;
readonly setInFrame: React.Dispatch<React.SetStateAction<number | null>>;
readonly outFrame: number | null;
readonly setOutFrame: React.Dispatch<React.SetStateAction<number | null>>;
readonly alwaysShowControls: boolean;
readonly setAlwaysShowControls: React.Dispatch<React.SetStateAction<boolean>>;
readonly showVolumeControls: boolean;
readonly setShowVolumeControls: React.Dispatch<React.SetStateAction<boolean>>;
readonly durationInFrames: number;
readonly showPlaybackrateControl: boolean;
readonly setShowPlaybackRateControl: React.Dispatch<
React.SetStateAction<boolean>
>;
readonly showPosterWhenBuffering: boolean;
readonly setShowPosterWhenBuffering: React.Dispatch<
React.SetStateAction<boolean>
>;
readonly showPosterWhenBufferingAndPaused: boolean;
readonly setShowPosterWhenBufferingAndPaused: React.Dispatch<
React.SetStateAction<boolean>
>;
readonly hideControlsWhenPointerDoesntMove: boolean;
readonly setHideControlsWhenPointerDoesntMove: React.Dispatch<
React.SetStateAction<boolean>
>;
}> = ({
playerRef: ref,
color,
title,
setTitle,
setColor,
bgColor,
setBgColor,
setPlaybackRate,
loop,
setLoop,
clickToPlay,
setClickToPlay,
doubleClickToFullscreen,
setDoubleClickToFullscreen,
setSpaceKeyToPlayOrPause,
spaceKeyToPlayOrPause,
moveToBeginningWhenEnded,
setMoveToBeginningWhenEnded,
setshowPosterWhenUnplayed,
setShowPosterWhenEnded,
setShowPosterWhenPaused,
showPosterWhenUnplayed,
showPosterWhenEnded,
showPosterWhenPaused,
setShowPosterWhenBuffering,
showPosterWhenBuffering,
setShowPosterWhenBufferingAndPaused,
showPosterWhenBufferingAndPaused,
inFrame,
outFrame,
setInFrame,
setOutFrame,
alwaysShowControls,
setAlwaysShowControls,
durationInFrames,
setShowVolumeControls,
showVolumeControls,
showPlaybackrateControl: showPlaybackControl,
setShowPlaybackRateControl: setShowPlaybackControl,
hideControlsWhenPointerDoesntMove,
setHideControlsWhenPointerDoesntMove,
}) => {
const [logs, setLogs] = useState<string[]>(() => []);
useEffect(() => {
const playCallbackListener: CallbackListener<'play'> = () => {
setLogs((l) => [...l, 'playing ' + Date.now()]);
};
const pausedCallbackLitener: CallbackListener<'pause'> = () => {
setLogs((l) => [...l, 'pausing ' + Date.now()]);
};
const seekedCallbackListener: CallbackListener<'seeked'> = (e) => {
setLogs((l) => [...l, 'seeked to ' + e.detail.frame + ' ' + Date.now()]);
};
const endedCallbackListener: CallbackListener<'ended'> = () => {
setLogs((l) => [...l, 'ended ' + Date.now()]);
};
const errorCallbackListener: CallbackListener<'error'> = () => {
setLogs((l) => [...l, 'error ' + Date.now()]);
};
const timeupdateCallbackListener: CallbackListener<'timeupdate'> = (e) => {
setLogs((l) => [...l, 'timeupdate ' + e.detail.frame]);
};
const frameupdateCallbackListener: CallbackListener<'frameupdate'> = (
e,
) => {
setLogs((l) => [...l, 'frameupdate ' + e.detail.frame]);
};
const ratechangeCallbackListener: CallbackListener<'ratechange'> = (e) => {
setLogs((l) => [
...l,
'ratechange ' + e.detail.playbackRate + ' ' + Date.now(),
]);
};
const scalechangeCallbackListener: CallbackListener<'scalechange'> = (
e,
) => {
setLogs((l) => [...l, 'scalechange ' + e.detail.scale]);
};
const fullscreenChangeCallbackListener: CallbackListener<
'fullscreenchange'
> = (e) => {
setLogs((l) => [
...l,
'fullscreenchange ' + e.detail.isFullscreen + ' ' + Date.now(),
]);
};
const volumechangeCallbackListener: CallbackListener<'volumechange'> = (
e,
) => {
setLogs((l) => [
...l,
'volumechange ' + e.detail.volume + ' ' + Date.now(),
]);
};
const mutechangeCallbackListener: CallbackListener<'mutechange'> = (e) => {
setLogs((l) => [
...l,
'mutechange ' + e.detail.isMuted + ' ' + Date.now(),
]);
};
const waitingCallbackListener: CallbackListener<'waiting'> = () => {
setLogs((l) => [...l, 'waiting ' + Date.now()]);
};
const resumeCallbackListener: CallbackListener<'resume'> = () => {
setLogs((l) => [...l, 'resume ' + Date.now()]);
};
const {current} = ref;
if (!current) {
return;
}
current.addEventListener('play', playCallbackListener);
current.addEventListener('pause', pausedCallbackLitener);
current.addEventListener('seeked', seekedCallbackListener);
current.addEventListener('ended', endedCallbackListener);
current.addEventListener('error', errorCallbackListener);
current.addEventListener('timeupdate', timeupdateCallbackListener);
current.addEventListener('frameupdate', frameupdateCallbackListener);
current.addEventListener('ratechange', ratechangeCallbackListener);
current.addEventListener('scalechange', scalechangeCallbackListener);
current.addEventListener('volumechange', volumechangeCallbackListener);
current.addEventListener('mutechange', mutechangeCallbackListener);
current.addEventListener(
'fullscreenchange',
fullscreenChangeCallbackListener,
);
current.addEventListener('waiting', waitingCallbackListener);
current.addEventListener('resume', resumeCallbackListener);
return () => {
current.removeEventListener('play', playCallbackListener);
current.removeEventListener('pause', pausedCallbackLitener);
current.removeEventListener('seeked', seekedCallbackListener);
current.removeEventListener('ended', endedCallbackListener);
current.removeEventListener('error', errorCallbackListener);
current.removeEventListener('timeupdate', timeupdateCallbackListener);
current.removeEventListener('frameupdate', frameupdateCallbackListener);
current.removeEventListener('ratechange', ratechangeCallbackListener);
current.removeEventListener('scalechange', scalechangeCallbackListener);
current.removeEventListener('volumechange', volumechangeCallbackListener);
current.removeEventListener('mutechange', mutechangeCallbackListener);
current.removeEventListener(
'fullscreenchange',
fullscreenChangeCallbackListener,
);
current.removeEventListener('waiting', waitingCallbackListener);
current.removeEventListener('resume', resumeCallbackListener);
};
}, [ref]);
return (
<div>
<div style={{paddingTop: '0.5rem'}}>
Enter Text{' '}
<input
value={title}
onChange={(e) => {
setTitle(e.target.value);
}}
/>
</div>
<div>
<TimeDisplay playerRef={ref} />
</div>
<div style={{paddingTop: '0.5rem'}}>
<div>
Select Text Color{' '}
<input
type="color"
value={color}
onChange={(e) => setColor(e.target.value)}
/>
</div>
<div>
Select Background Color{' '}
<input
type="color"
value={bgColor}
onChange={(e) => setBgColor(e.target.value)}
/>
</div>
</div>
<br />
<button type="button" onClick={(e) => ref.current?.play(e)}>
▶️ Play
</button>
<button type="button" onClick={() => ref.current?.pause()}>
⏸️ Pause
</button>
<button type="button" onClick={() => ref.current?.toggle()}>
⏯️ Toggle
</button>
<button
type="button"
onClick={() => {
ref.current?.seekTo(10);
ref.current?.pause();
}}
>
seekTo 10 and pause
</button>
<button type="button" onClick={() => ref.current?.seekTo(50)}>
seekTo 50
</button>
<button
type="button"
onClick={() => {
ref.current?.seekTo(ref.current.getCurrentFrame() + fps * 5);
}}
>
5 seconds forward
</button>
<br />
<button
type="button"
onClick={() => {
ref.current?.seekTo(10000);
}}
>
seek outside
</button>
<button
type="button"
onClick={() => {
ref.current?.seekTo(-10000);
}}
>
seek outside negative
</button>
<button
type="button"
onClick={() => {
ref.current?.pause();
ref.current?.seekTo(50);
}}
>
pause and seek
</button>
<br />
<button
type="button"
onClick={() => {
setPlaybackRate(0.5);
}}
>
0.5x speed
</button>
<button
type="button"
onClick={() => {
setPlaybackRate(1);
}}
>
1x speed
</button>
<button
type="button"
onClick={() => {
setPlaybackRate(2);
}}
>
2x speed
</button>
<button
type="button"
onClick={() => {
setPlaybackRate(-1);
}}
>
-1x speed
</button>
<button
type="button"
onClick={() => {
setShowPlaybackControl(!showPlaybackControl);
}}
>
showPlaybackRateControl = {String(showPlaybackControl)}
</button>
<br />
<button type="button" onClick={() => ref.current?.mute()}>
🔇 Mute
</button>
<button type="button" onClick={() => ref.current?.unmute()}>
🔉 Unmute
</button>
<button type="button" onClick={() => ref.current?.setVolume(0)}>
set volume to 0
</button>
<button type="button" onClick={() => ref.current?.setVolume(0.5)}>
set volume to 0.5
</button>
<button type="button" onClick={() => ref.current?.setVolume(1)}>
set volume to 1
</button>
<br />
<button type="button" onClick={() => setLoop((l) => !l)}>
loop = {String(loop)}
</button>
<button type="button" onClick={() => setClickToPlay((l) => !l)}>
clickToPlay = {String(clickToPlay)}
</button>
<button
type="button"
onClick={() => setDoubleClickToFullscreen((l) => !l)}
>
doubleClickToFullscreen = {String(doubleClickToFullscreen)}
</button>
<button type="button" onClick={() => setSpaceKeyToPlayOrPause((l) => !l)}>
spaceKeyToPlayOrPause = {String(spaceKeyToPlayOrPause)}
</button>
<br />
<button
type="button"
onClick={() => setshowPosterWhenUnplayed((l) => !l)}
>
showPosterWhenUnplayed = {String(showPosterWhenUnplayed)}
</button>
<button type="button" onClick={() => setShowPosterWhenEnded((l) => !l)}>
showPosterWhenEnded = {String(showPosterWhenEnded)}
</button>
<button type="button" onClick={() => setShowPosterWhenPaused((l) => !l)}>
showPosterWhenPaused = {String(showPosterWhenPaused)}
</button>
<button
type="button"
onClick={() => setShowPosterWhenBuffering((l) => !l)}
>
showPosterWhenBuffering = {String(showPosterWhenBuffering)}
</button>
<button
type="button"
onClick={() => setShowPosterWhenBufferingAndPaused((l) => !l)}
>
showPosterWhenBufferingAndPaused ={' '}
{String(showPosterWhenBufferingAndPaused)}
</button>
<br />
<button
type="button"
onClick={() => setMoveToBeginningWhenEnded((l) => !l)}
>
moveToBeginningWhenEnded = {String(moveToBeginningWhenEnded)}
</button>
<button type="button" onClick={() => setShowVolumeControls((l) => !l)}>
showVolumeControls = {String(showVolumeControls)}
</button>
<button type="button" onClick={() => setAlwaysShowControls((l) => !l)}>
alwaysShowControls = {String(alwaysShowControls)}
</button>
<button
type="button"
onClick={() => setHideControlsWhenPointerDoesntMove((l) => !l)}
>
hideControlsWhenPointerDoesntMove ={' '}
{String(hideControlsWhenPointerDoesntMove)}
</button>
<br />
<button
type="button"
onClick={() =>
setLogs((l) => [
...l,
`currentFrame = ${ref.current?.getCurrentFrame()}`,
])
}
>
log currentFrame
</button>
<button
type="button"
onClick={() =>
setLogs((l) => [...l, `muted = ${ref.current?.isMuted()}`])
}
>
log muted
</button>
<button
type="button"
onClick={() =>
setLogs((l) => [...l, `volume = ${ref.current?.getVolume()}`])
}
>
log volume
</button>
<button
type="button"
onClick={() => {
playerExampleComp.current?.triggerError();
}}
>
trigger error
</button>
<br />
<label>
<input
type="checkbox"
onChange={(e) => {
setInFrame(e.target.checked ? 0 : null);
}}
/>
Enable inFrame
</label>{' '}
{inFrame === null ? null : (
<input
type="range"
min={0}
max={durationInFrames}
step={1}
onChange={(e) => {
setInFrame(Number(e.target.value));
}}
/>
)}
<br />
<label>
<input
type="checkbox"
onChange={(e) => {
setOutFrame(e.target.checked ? 0 : null);
}}
/>
Enable outFrame
</label>{' '}
{outFrame === null ? null : (
<input
type="range"
min={0}
max={durationInFrames}
step={1}
onChange={(e) => {
setOutFrame(Number(e.target.value));
}}
/>
)}
<br />
<br />
{logs
.slice(0)
.reverse()
.slice(0, 10)
.reverse()
.map((l, i) => {
return <div key={`${l}-${i}`}>{l}</div>;
})}
</div>
);
};
const PlayerOnly: React.FC<
{
readonly playerRef: React.RefObject<PlayerRef | null>;
readonly inputProps: Record<string, unknown>;
readonly clickToPlay: boolean;
readonly loop: boolean;
readonly durationInFrames: number;
readonly doubleClickToFullscreen: boolean;
readonly playbackRate: number;
readonly spaceKeyToPlayOrPause: boolean;
readonly moveToBeginningWhenEnded: boolean;
readonly showPosterWhenPaused: boolean;
readonly showPosterWhenEnded: boolean;
readonly showPosterWhenUnplayed: boolean;
readonly showPosterWhenBuffering: boolean;
readonly showPosterWhenBufferingAndPaused: boolean;
readonly inFrame: number | null;
readonly outFrame: number | null;
readonly alwaysShowControls: boolean;
readonly showVolumeControls: boolean;
readonly showPlaybackRateControl: boolean | number[];
readonly hideControlsWhenPointerDoesntMove: boolean;
} & CompProps<any>
> = ({
playerRef,
inputProps,
clickToPlay,
loop,
durationInFrames,
doubleClickToFullscreen,
playbackRate,
spaceKeyToPlayOrPause,
moveToBeginningWhenEnded,
showPosterWhenPaused,
showPosterWhenEnded,
showPosterWhenUnplayed,
showPosterWhenBuffering,
showPosterWhenBufferingAndPaused,
inFrame,
outFrame,
alwaysShowControls,
showVolumeControls,
showPlaybackRateControl,
hideControlsWhenPointerDoesntMove,
...props
}) => {
const renderLoading: RenderLoading = useCallback(() => {
return (
<AbsoluteFill style={{backgroundColor: 'yellow'}}>
<Loading size={200} />
<div>Loading for 3 seconds...</div>
</AbsoluteFill>
);
}, []);
const renderPoster: RenderPoster = useCallback(({isBuffering}) => {
if (isBuffering) {
return (
<AbsoluteFill
style={{
justifyContent: 'center',
alignItems: 'center',
}}
>
Buffering
</AbsoluteFill>
);
}
return (
<AbsoluteFill style={{backgroundColor: 'yellow'}}>
<div>Click to play</div>
</AbsoluteFill>
);
}, []);
const errorFallback: ErrorFallback = useCallback(({error}) => {
return (
<AbsoluteFill
style={{
backgroundColor: 'yellow',
justifyContent: 'center',
alignItems: 'center',
}}
>
Sorry about this! An error occurred: {error.message}
</AbsoluteFill>
);
}, []);
return (
<Player
ref={playerRef}
controls
acknowledgeRemotionLicense
showVolumeControls={showVolumeControls}
compositionWidth={1920}
compositionHeight={1080}
fps={fps}
{...props}
durationInFrames={durationInFrames}
doubleClickToFullscreen={doubleClickToFullscreen}
loop={loop}
clickToPlay={clickToPlay}
inputProps={inputProps}
renderLoading={renderLoading}
errorFallback={errorFallback}
playbackRate={playbackRate}
spaceKeyToPlayOrPause={spaceKeyToPlayOrPause}
moveToBeginningWhenEnded={moveToBeginningWhenEnded}
renderPoster={renderPoster}
initialFrame={30}
showPosterWhenUnplayed={showPosterWhenUnplayed}
showPosterWhenEnded={showPosterWhenEnded}
showPosterWhenPaused={showPosterWhenPaused}
showPosterWhenBuffering={showPosterWhenBuffering}
showPosterWhenBufferingAndPaused={showPosterWhenBufferingAndPaused}
inFrame={inFrame}
outFrame={outFrame}
alwaysShowControls={alwaysShowControls}
showPlaybackRateControl={showPlaybackRateControl}
hideControlsWhenPointerDoesntMove={hideControlsWhenPointerDoesntMove}
style={{
height: '100%',
width: '100%',
resize: 'both',
maxWidth: 550,
maxHeight: 550,
minWidth: 300,
minHeight: 300,
display: 'block',
}}
/>
);
};
export default ({
durationInFrames,
...props
}: {
readonly durationInFrames: number;
} & CompProps<any>) => {
const [title, setTitle] = useState('Hello World');
const [color, setColor] = useState('#ffffff');
const [bgColor, setBgColor] = useState('#000000');
const [loop, setLoop] = useState(false);
const [doubleClickToFullscreen, setDoubleClickToFullscreen] = useState(true);
const [clickToPlay, setClickToPlay] = useState(true);
const [spaceKeyToPlayOrPause, setSpaceKeyToPlayOrPause] = useState(true);
const [moveToBeginningWhenEnded, setMoveToBeginningWhenEnded] =
useState(true);
const [playbackRate, setPlaybackRate] = useState(1);
const [showPosterWhenUnplayed, setshowPosterWhenUnplayed] = useState(true);
const [showPosterWhenBuffering, setShowPosterWhenBuffering] = useState(true);
const [
showPosterWhenBufferingAndPaused,
setShowPosterWhenBufferingAndPaused,
] = useState(false);
const [showPosterWhenEnded, setShowPosterWhenEnded] = useState(true);
const [showPosterWhenPaused, setShowPosterWhenPaused] = useState(true);
const [inFrame, setInFrame] = useState<number | null>(null);
const [outFrame, setOutFrame] = useState<number | null>(null);
const [alwaysShowControls, setAlwaysShowControls] = useState(false);
const [showVolumeControls, setShowVolumeControls] = useState(true);
const [showPlaybackRateControl, setPlaybackRateControl] = useState(false);
const [
hideControlsWhenPointerDoesntMove,
setHideControlsWhenPointerDoesntMove,
] = useState(true);
const ref = useRef<PlayerRef>(null);
const inputProps = useMemo(() => {
return {
title: String(title),
bgColor: String(bgColor),
color: String(color),
};
}, [bgColor, color, title]);
return (
<div style={{margin: '2rem'}}>
<PlayerOnly
hideControlsWhenPointerDoesntMove={hideControlsWhenPointerDoesntMove}
alwaysShowControls={alwaysShowControls}
clickToPlay={clickToPlay}
{...props}
doubleClickToFullscreen={doubleClickToFullscreen}
durationInFrames={durationInFrames}
inputProps={inputProps}
loop={loop}
moveToBeginningWhenEnded={moveToBeginningWhenEnded}
playbackRate={playbackRate}
spaceKeyToPlayOrPause={spaceKeyToPlayOrPause}
playerRef={ref}
showPosterWhenEnded={showPosterWhenEnded}
showPosterWhenPaused={showPosterWhenPaused}
showPosterWhenUnplayed={showPosterWhenUnplayed}
showPosterWhenBuffering={showPosterWhenBuffering}
showPosterWhenBufferingAndPaused={showPosterWhenBufferingAndPaused}
showVolumeControls={showVolumeControls}
showPlaybackRateControl={showPlaybackRateControl}
inFrame={inFrame}
outFrame={outFrame}
/>
<ControlsOnly
bgColor={bgColor}
clickToPlay={clickToPlay}
color={color}
doubleClickToFullscreen={doubleClickToFullscreen}
loop={loop}
moveToBeginningWhenEnded={moveToBeginningWhenEnded}
setBgColor={setBgColor}
setClickToPlay={setClickToPlay}
setColor={setColor}
setDoubleClickToFullscreen={setDoubleClickToFullscreen}
setLoop={setLoop}
setMoveToBeginningWhenEnded={setMoveToBeginningWhenEnded}
setPlaybackRate={setPlaybackRate}
setSpaceKeyToPlayOrPause={setSpaceKeyToPlayOrPause}
setTitle={setTitle}
spaceKeyToPlayOrPause={spaceKeyToPlayOrPause}
title={title}
playerRef={ref}
setshowPosterWhenUnplayed={setshowPosterWhenUnplayed}
setShowPosterWhenEnded={setShowPosterWhenEnded}
setShowPosterWhenPaused={setShowPosterWhenPaused}
showPosterWhenBuffering={showPosterWhenBuffering}
showPosterWhenBufferingAndPaused={showPosterWhenBufferingAndPaused}
setShowPosterWhenBuffering={setShowPosterWhenBuffering}
setShowPosterWhenBufferingAndPaused={
setShowPosterWhenBufferingAndPaused
}
setAlwaysShowControls={setAlwaysShowControls}
showPosterWhenUnplayed={showPosterWhenUnplayed}
showPosterWhenEnded={showPosterWhenEnded}
showPosterWhenPaused={showPosterWhenPaused}
alwaysShowControls={alwaysShowControls}
setShowVolumeControls={setShowVolumeControls}
showVolumeControls={showVolumeControls}
setInFrame={setInFrame}
setOutFrame={setOutFrame}
inFrame={inFrame}
outFrame={outFrame}
durationInFrames={durationInFrames}
showPlaybackrateControl={showPlaybackRateControl}
setShowPlaybackRateControl={setPlaybackRateControl}
hideControlsWhenPointerDoesntMove={hideControlsWhenPointerDoesntMove}
setHideControlsWhenPointerDoesntMove={
setHideControlsWhenPointerDoesntMove
}
/>
</div>
);
};