🎥 Make videos programmatically with React
import {afterEach, expect, test} from 'bun:test';
import React, {createRef, useRef} from 'react';
import {Html5Audio, Internals, useCurrentFrame} from 'remotion';
import {NoReactInternals} from 'remotion/no-react';
import type {PlayerRef} from '../player-methods.js';
import {Player} from '../Player.js';
import {Thumbnail} from '../Thumbnail.js';
import type {UsePlayerMethods} from '../use-player-methods.js';
import {usePlayerMethods} from '../use-player-methods.js';
import {act, cleanup, fireEvent, render} from './test-utils.js';
afterEach(() => {
cleanup();
});
test('It should throw an error if not being used inside a RemotionRoot', () => {
expect(() => {
usePlayerMethods();
}).toThrow();
});
const ThumbnailPlayingProbe = () => {
const playing = Internals.usePlaying();
return React.createElement('div', null, playing ? 'playing' : 'paused');
};
test('Thumbnail supports usePlaying in its composition', () => {
const view = render(
React.createElement(Thumbnail, {
component: ThumbnailPlayingProbe,
durationInFrames: 100,
compositionWidth: 1920,
compositionHeight: 1080,
fps: 30,
frameToDisplay: 0,
}),
);
expect(view.getByText('paused')).toBeTruthy();
});
test('Player uses the version-specific default number of shared audio tags', () => {
const view = render(
React.createElement(Player, {
component: () => null,
durationInFrames: 100,
compositionWidth: 1920,
compositionHeight: 1080,
fps: 30,
}),
);
expect(view.container.querySelectorAll('audio')).toHaveLength(
NoReactInternals.ENABLE_V5_BREAKING_CHANGES ? 0 : 5,
);
});
test('Seeking to the current frame does not rerender the composition', () => {
let compositionRenders = 0;
const playerRef = createRef<PlayerRef>();
const Composition = () => {
compositionRenders++;
const frame = useCurrentFrame();
return React.createElement('div', null, `Frame ${frame}`);
};
const view = render(
React.createElement(Player, {
ref: playerRef,
component: Composition,
durationInFrames: 100,
compositionWidth: 1920,
compositionHeight: 1080,
fps: 30,
}),
);
const rendersAfterMount = compositionRenders;
expect(view.getByText('Frame 0')).toBeTruthy();
act(() => {
playerRef.current?.seekTo(0);
});
expect(playerRef.current?.getCurrentFrame()).toBe(0);
expect(compositionRenders).toBe(rendersAfterMount);
});
const PlayerMethodsProbe = React.memo(
({onRender}: {readonly onRender: (methods: UsePlayerMethods) => void}) => {
const methods = usePlayerMethods();
onRender(methods);
return null;
},
);
test('Imperative player methods do not rerender when the frame changes', () => {
const playerRef = createRef<PlayerRef>();
const methodsRef: {current: UsePlayerMethods | null} = {current: null};
let methodRenders = 0;
const onRender = (methods: UsePlayerMethods) => {
methodsRef.current = methods;
methodRenders++;
};
const renderCustomControls = () =>
React.createElement(PlayerMethodsProbe, {onRender});
const Composition = () => null;
render(
React.createElement(Player, {
ref: playerRef,
component: Composition,
durationInFrames: 100,
compositionWidth: 1920,
compositionHeight: 1080,
fps: 30,
initialFrame: 12,
controls: true,
renderCustomControls,
}),
);
expect(methodsRef.current?.getCurrentFrame()).toBe(12);
const rendersAfterMount = methodRenders;
act(() => {
methodsRef.current?.seek(30);
});
expect(playerRef.current?.getCurrentFrame()).toBe(30);
expect(methodsRef.current?.getCurrentFrame()).toBe(30);
expect(methodRenders).toBe(rendersAfterMount);
act(() => {
methodsRef.current?.frameForward(5);
expect(methodsRef.current?.getCurrentFrame()).toBe(35);
methodsRef.current?.frameBack(2);
expect(methodsRef.current?.getCurrentFrame()).toBe(33);
});
expect(playerRef.current?.getCurrentFrame()).toBe(33);
expect(methodRenders).toBe(rendersAfterMount);
});
test('Playing from the last frame resets playback and dismisses the unplayed poster', () => {
const playerRef = createRef<PlayerRef>();
const Composition = () => null;
const view = render(
React.createElement(Player, {
ref: playerRef,
component: Composition,
durationInFrames: 10,
compositionWidth: 1920,
compositionHeight: 1080,
fps: 30,
initialFrame: 9,
controls: true,
showPosterWhenUnplayed: true,
renderPoster: () => React.createElement('div', null, 'Unplayed poster'),
}),
);
expect(view.getByText('Unplayed poster')).toBeTruthy();
fireEvent.click(view.getByLabelText('Play video'));
expect(playerRef.current?.getCurrentFrame()).toBe(0);
expect(playerRef.current?.isPlaying()).toBe(true);
expect(view.queryByText('Unplayed poster')).toBeNull();
fireEvent.click(view.getByLabelText('Pause video'));
expect(playerRef.current?.isPlaying()).toBe(false);
expect(view.queryByText('Unplayed poster')).toBeNull();
});
let createdAudioContexts = 0;
class MockAudioContext {
public state = 'suspended' as AudioContextState;
public baseLatency = 0;
public outputLatency = 0;
public currentTime = 0;
public destination = {};
constructor() {
createdAudioContexts++;
}
addEventListener() {
return undefined;
}
removeEventListener() {
return undefined;
}
createGain() {
return {
connect: () => undefined,
gain: {
cancelScheduledValues: () => undefined,
linearRampToValueAtTime: () => undefined,
setValueAtTime: () => undefined,
},
};
}
suspend() {
this.state = 'suspended';
return Promise.resolve();
}
resume() {
this.state = 'running';
return Promise.resolve();
}
createMediaElementSource() {
return {
connect: () => undefined,
disconnect: () => undefined,
};
}
}
const AudioComposition = () => {
return React.createElement(
Internals.SequenceManagerProvider,
null,
React.createElement(Html5Audio, {src: 'audio.mp3'}),
);
};
test('Player.pause() pauses mounted HTML5 media synchronously', () => {
const originalPlay = HTMLMediaElement.prototype.play;
const originalPause = HTMLMediaElement.prototype.pause;
const originalPaused = Object.getOwnPropertyDescriptor(
HTMLMediaElement.prototype,
'paused',
);
const playerRef = createRef<PlayerRef>();
let pauseCalls = 0;
let paused = true;
Object.defineProperty(HTMLMediaElement.prototype, 'paused', {
configurable: true,
get: () => paused,
});
HTMLMediaElement.prototype.play = () => {
paused = false;
return Promise.resolve();
};
HTMLMediaElement.prototype.pause = () => {
paused = true;
pauseCalls++;
};
try {
render(
React.createElement(Player, {
ref: playerRef,
component: AudioComposition,
durationInFrames: 300,
compositionWidth: 1920,
compositionHeight: 1080,
fps: 30,
}),
);
act(() => playerRef.current?.play());
pauseCalls = 0;
act(() => {
playerRef.current?.pause();
expect(pauseCalls).toBe(1);
});
expect(pauseCalls).toBe(1);
} finally {
HTMLMediaElement.prototype.play = originalPlay;
HTMLMediaElement.prototype.pause = originalPause;
if (originalPaused) {
Object.defineProperty(
HTMLMediaElement.prototype,
'paused',
originalPaused,
);
} else {
delete (HTMLMediaElement.prototype as {paused?: boolean}).paused;
}
}
});
const PlayerWithMuteButton = ({
onError,
initiallyMuted = false,
}: {
readonly onError: (error: Error) => void;
readonly initiallyMuted?: boolean;
}) => {
const playerRef = useRef<PlayerRef>(null);
return React.createElement(
React.Fragment,
null,
React.createElement(Player, {
ref: playerRef,
component: AudioComposition,
durationInFrames: 300,
compositionWidth: 1920,
compositionHeight: 1080,
fps: 30,
initiallyMuted,
errorFallback: ({error}) => {
onError(error);
return null;
},
}),
React.createElement(
'button',
{
type: 'button',
onClick: () =>
initiallyMuted
? playerRef.current?.unmute()
: playerRef.current?.mute(),
},
initiallyMuted ? 'Unmute' : 'Mute',
),
);
};
test('It does not crash when muting a Player with a mounted Html5Audio tag', () => {
const originalAudioContext = globalThis.AudioContext;
globalThis.AudioContext = MockAudioContext as unknown as typeof AudioContext;
const errors: Error[] = [];
try {
const {getByText} = render(
React.createElement(PlayerWithMuteButton, {
onError: (error) => errors.push(error),
}),
);
act(() => {
getByText('Mute').click();
});
expect(errors).toEqual([]);
} finally {
globalThis.AudioContext = originalAudioContext;
}
});
test('It does not crash when unmuting a Player with a mounted Html5Audio tag', () => {
const originalAudioContext = globalThis.AudioContext;
globalThis.AudioContext = MockAudioContext as unknown as typeof AudioContext;
const errors: Error[] = [];
createdAudioContexts = 0;
try {
const {getByText} = render(
React.createElement(PlayerWithMuteButton, {
initiallyMuted: true,
onError: (error) => errors.push(error),
}),
);
expect(createdAudioContexts).toBe(0);
act(() => {
getByText('Unmute').click();
});
expect(createdAudioContexts).toBe(1);
expect(errors).toEqual([]);
} finally {
globalThis.AudioContext = originalAudioContext;
}
});