🎥 Make videos programmatically with React
import React, {useContext, useEffect, useMemo, useRef} from 'react';
import {BufferingProvider} from '../buffering.js';
import {CanUseRemotionHooksProvider} from '../CanUseRemotionHooks.js';
import type {TSequence} from '../CompositionManager.js';
import type {CompositionManagerContext} from '../CompositionManagerContext.js';
import {CompositionManager} from '../CompositionManagerContext.js';
import type {LoggingContextValue} from '../log-level-context.js';
import {LogLevelContext} from '../log-level-context.js';
import {createRuntimeValueStore} from '../runtime-value-store.js';
import {
SequenceManagerProvider,
SequenceRegistryContext,
} from '../SequenceManager.js';
import type {
PlaybackRateContextValue,
SetTimelineContextValue,
TimelineContextValue,
} from '../TimelineContext.js';
import {
AbsoluteTimeContext,
PlaybackRateContext,
SetTimelineContext,
TimelineContext,
} from '../TimelineContext.js';
import {VideoProvider} from '../use-video.js';
const Comp: React.FC = () => null;
export const ObserveSequenceRegistrations: React.FC<{
readonly onRegisterSequence: (sequence: TSequence) => void;
}> = ({onRegisterSequence}) => {
const registry = useContext(SequenceRegistryContext);
const previous = useRef(new Map<string, TSequence>());
useEffect(() => {
if (registry === null) {
throw new Error('Sequence registry has not mounted');
}
const observe = () => {
const sequences = registry.getSnapshot();
const changed = sequences.filter(
(sequence) => previous.current.get(sequence.id) !== sequence,
);
previous.current = new Map(
sequences.map((sequence) => [sequence.id, sequence]),
);
changed.forEach(onRegisterSequence);
};
const unsubscribe = registry.subscribe(observe);
observe();
return unsubscribe;
}, [onRegisterSequence, registry]);
return null;
};
const makeMockCompositionContext = (
durationInFrames: number,
): CompositionManagerContext => ({
compositions: [
{
id: 'my-comp',
durationInFrames,
component: Comp,
defaultProps: {},
folderName: null,
fps: 30,
height: 1080,
width: 1080,
parentFolderName: null,
order: null,
calculateMetadata: null,
schema: null,
stack: null,
},
],
folders: [],
currentAssetMetadata: null,
canvasContent: {type: 'composition', compositionId: 'my-comp'},
currentCompositionMetadata: {
defaultCodec: null,
defaultOutName: null,
defaultPixelFormat: null,
defaultProResProfile: null,
defaultSampleRate: null,
defaultVideoImageFormat: null,
durationInFrames,
fps: 30,
height: 1080,
width: 1080,
props: {},
},
});
const logContext: LoggingContextValue = {
logLevel: 'info',
mountTime: 0,
};
const mockPlaybackRateContext: PlaybackRateContextValue = {
playbackRate: 1,
setPlaybackRate: () => {
throw new Error('not implemented');
},
};
const MaybeTimelineProvider: React.FC<{
readonly children: React.ReactNode;
readonly timelineContext: TimelineContextValue;
}> = ({children, timelineContext}) => {
const existing = useContext(TimelineContext);
if (existing !== null) {
// eslint-disable-next-line react/jsx-no-useless-fragment
return <>{children}</>;
}
return (
<AbsoluteTimeContext.Provider value={timelineContext}>
<TimelineContext.Provider value={timelineContext}>
{children}
</TimelineContext.Provider>
</AbsoluteTimeContext.Provider>
);
};
const MaybePlaybackRateProvider: React.FC<{
readonly children: React.ReactNode;
}> = ({children}) => {
const existing = useContext(PlaybackRateContext);
if (existing !== null) {
// eslint-disable-next-line react/jsx-no-useless-fragment
return <>{children}</>;
}
return (
<PlaybackRateContext.Provider value={mockPlaybackRateContext}>
{children}
</PlaybackRateContext.Provider>
);
};
export const WrapSequenceContext: React.FC<{
readonly children: React.ReactNode;
readonly compositionDurationInFrames?: number;
readonly currentFrame?: number;
}> = ({children, compositionDurationInFrames = 1000000, currentFrame = 0}) => {
const compositionContext = useMemo(
() => makeMockCompositionContext(compositionDurationInFrames),
[compositionDurationInFrames],
);
const timelineContext = useMemo<TimelineContextValue>(
() => ({
frame: {'my-comp': currentFrame},
isPlaying: () => false,
isInsideFreeze: false,
audioAndVideoTags: {current: []},
}),
[currentFrame],
);
const bufferingStore = useMemo(
() => createRuntimeValueStore({buffering: false}),
[],
);
const setTimelineContext = useMemo<SetTimelineContextValue>(
() => ({
setFrameWithoutSeek: () => undefined,
seek: null,
setPlaying: () => undefined,
setBuffering: (buffering) => {
if (bufferingStore.store.getSnapshot().buffering !== buffering) {
bufferingStore.setSnapshot({buffering});
}
},
subscribePlaying: () => () => undefined,
subscribeBuffering: bufferingStore.store.subscribe,
isPlaying: () => false,
isBuffering: () => bufferingStore.store.getSnapshot().buffering,
frameRef: {current: {}},
audioAndVideoTags: {current: []},
}),
[bufferingStore],
);
return (
<LogLevelContext.Provider value={logContext}>
<SetTimelineContext.Provider value={setTimelineContext}>
<BufferingProvider>
<CanUseRemotionHooksProvider>
<MaybeTimelineProvider timelineContext={timelineContext}>
<MaybePlaybackRateProvider>
<SequenceManagerProvider>
<CompositionManager.Provider value={compositionContext}>
<VideoProvider>{children}</VideoProvider>
</CompositionManager.Provider>
</SequenceManagerProvider>
</MaybePlaybackRateProvider>
</MaybeTimelineProvider>
</CanUseRemotionHooksProvider>
</BufferingProvider>
</SetTimelineContext.Provider>
</LogLevelContext.Provider>
);
};