🎥 Make videos programmatically with React
import type {LogLevel} from '@remotion/renderer';
import {getDefaultOutLocation} from '@remotion/studio-shared';
import type {
RenderStillOnWebImageFormat,
WebRendererAudioCodec,
WebRendererContainer,
WebRendererHardwareAcceleration,
WebRendererPageResponsiveness,
WebRendererQuality,
WebRendererVideoCodec,
} from '@remotion/web-renderer';
import {
getDefaultAudioCodecForContainer,
getDefaultContainerForCodec,
getDefaultVideoCodecForContainer,
isAudioOnlyContainer,
} from '@remotion/web-renderer';
import {useCallback, useContext, useMemo, useState} from 'react';
import {ShortcutHint} from '../../error-overlay/remotion-overlay/ShortcutHint';
import {getBrowserStudioOperations} from '../../helpers/browser-studio-operations';
import {StudioServerConnectionCtx} from '../../helpers/client-id';
import {canEditStudioConfig} from '../../helpers/settings-tab-availability';
import {AudioIcon} from '../../icons/audio';
import {CertificateIcon} from '../../icons/certificate';
import {FileIcon} from '../../icons/file';
import {PicIcon} from '../../icons/frame';
import {GearIcon} from '../../icons/gear';
import {InputPropsIcon} from '../../icons/input-props';
import type {WebRenderModalState} from '../../state/modals';
import {SetSelectedModalContext} from '../../state/modals';
import {SidebarContext} from '../../state/sidebar';
import {Button} from '../Button';
import {VERTICAL_SCROLLBAR_CLASSNAME} from '../Menu/is-menu-item';
import {ModalHeader} from '../ModalHeader';
import {DismissableModal} from '../NewComposition/DismissableModal';
import {optionsSidebarTabs} from '../options-sidebar-tabs';
import {persistSelectedOptionsSidebarPanel} from '../OptionsPanel';
import {RenderQueueContext} from '../RenderQueue/context';
import type {SegmentedControlItem} from '../SegmentedControl';
import {SegmentedControl} from '../SegmentedControl';
import {VerticalTab} from '../Tabs/vertical';
import {DataEditor} from './DataEditor';
import {getStringBeforeSuffix} from './get-string-before-suffix';
import {
buttonStyle,
container as containerStyle,
flexer,
horizontalLayout,
horizontalTab,
icon,
iconContainer,
leftSidebar,
optionsPanel,
outerModalStyle,
} from './render-modals';
import {
ResolveCompositionBeforeModal,
ResolvedCompositionContext,
} from './ResolveCompositionBeforeModal';
import type {UpdaterFunction} from './SchemaEditor/ZodSwitch';
import {useEncodableAudioCodecs} from './use-encodable-audio-codecs';
import {useEncodableVideoCodecs} from './use-encodable-video-codecs';
import {WebRenderModalAdvanced} from './WebRenderModalAdvanced';
import {WebRenderModalAudio} from './WebRenderModalAudio';
import {WebRenderModalBasic} from './WebRenderModalBasic';
import {WebRenderModalPicture} from './WebRenderModalPicture';
type WebRenderModalProps = {
readonly compositionId: string;
readonly initialFrame: number;
readonly initialLogLevel: LogLevel;
readonly defaultProps: Record<string, unknown>;
readonly inFrameMark: number | null;
readonly outFrameMark: number | null;
readonly initialStillImageFormat: RenderStillOnWebImageFormat;
readonly initialScale: number;
readonly initialDelayRenderTimeout: number;
readonly initialDefaultOutName: string | null;
readonly initialContainer: WebRendererContainer | null;
readonly initialVideoCodec: WebRendererVideoCodec | null;
readonly initialAudioCodec: WebRendererAudioCodec | null;
readonly initialAudioBitrate: WebRendererQuality | null;
readonly initialVideoBitrate: WebRendererQuality | null;
readonly initialHardwareAcceleration: WebRendererHardwareAcceleration | null;
readonly initialKeyframeIntervalInSeconds: number | null;
readonly initialTransparent: boolean | null;
readonly initialMuted: boolean | null;
readonly initialMediaCacheSizeInBytes: number | null;
readonly initialAllowHtmlInCanvas: boolean;
readonly initialPageResponsiveness: WebRendererPageResponsiveness;
};
export type RenderType = 'still' | 'video' | 'audio';
type TabType = 'general' | 'data' | 'picture' | 'audio' | 'advanced';
const invalidCharacters = ['?', '*', '+', ':', '%'];
const isValidStillExtension = (
extension: string,
stillImageFormat: RenderStillOnWebImageFormat,
): boolean => {
if (stillImageFormat === 'jpeg' && extension === 'jpg') {
return true;
}
return extension === stillImageFormat;
};
const validateOutnameForStill = ({
outName,
stillImageFormat,
}: {
outName: string;
stillImageFormat: RenderStillOnWebImageFormat;
}): {valid: true} | {valid: false; error: Error} => {
try {
const extension = outName.substring(outName.lastIndexOf('.') + 1);
const prefix = outName.substring(0, outName.lastIndexOf('.'));
const hasDotAfterSlash = () => {
const substrings = prefix.split('/');
for (const str of substrings) {
if (str[0] === '.') {
return true;
}
}
return false;
};
const hasInvalidChar = () => {
return prefix.split('').some((char) => invalidCharacters.includes(char));
};
if (prefix.length < 1) {
throw new Error('The prefix must be at least 1 character long');
}
if (prefix[0] === '.' || hasDotAfterSlash()) {
throw new Error('The output name must not start with a dot');
}
if (hasInvalidChar()) {
throw new Error(
"Filename can't contain the following characters: ?, *, +, %, :",
);
}
if (!isValidStillExtension(extension, stillImageFormat)) {
throw new Error(
`The extension ${extension} is not supported for still image format ${stillImageFormat}`,
);
}
return {valid: true};
} catch (err) {
return {valid: false, error: err as Error};
}
};
// TODO: Switch to server-side rendering
// TODO: Filter out codecs that are not supported for the container
// TODO: Shortcut: Shift + R
// TODO: Apply defaultCodec
// TODO: Apply defaultOutName
const WebRenderModal: React.FC<WebRenderModalProps> = ({
initialFrame,
defaultProps,
inFrameMark,
outFrameMark,
initialLogLevel,
initialStillImageFormat,
initialDefaultOutName,
initialScale,
initialDelayRenderTimeout,
initialMediaCacheSizeInBytes,
initialContainer,
initialVideoCodec,
initialAudioCodec,
initialAudioBitrate,
initialVideoBitrate,
initialHardwareAcceleration,
initialKeyframeIntervalInSeconds,
initialTransparent,
initialMuted,
initialAllowHtmlInCanvas,
initialPageResponsiveness,
}) => {
const context = useContext(ResolvedCompositionContext);
const {setSelectedModal} = useContext(SetSelectedModalContext);
const {setSidebarCollapsedState} = useContext(SidebarContext);
const {addClientStillJob, addClientVideoJob} = useContext(RenderQueueContext);
const {previewServerState} = useContext(StudioServerConnectionCtx);
if (!context) {
throw new Error(
'Should not be able to render without resolving comp first',
);
}
const renderDefaults = window.remotion_renderDefaults;
if (!renderDefaults) {
throw new Error('Render defaults are not available');
}
const {publicLicenseKey} = renderDefaults;
const {
resolved: {result: resolvedComposition},
unresolved: unresolvedComposition,
} = context;
const [isVideo] = useState(() => {
return typeof resolvedComposition.durationInFrames === 'undefined'
? true
: resolvedComposition.durationInFrames > 1;
});
const [renderMode, setRenderMode] = useState<RenderType>(
initialContainer && isAudioOnlyContainer(initialContainer)
? 'audio'
: isVideo
? 'video'
: 'still',
);
const [tab, setTab] = useState<TabType>('general');
const isBrowserStudio = getBrowserStudioOperations() !== null;
const canEditConfig = canEditStudioConfig({
isBrowserStudio,
previewServerConnected: previewServerState.type === 'connected',
readOnlyStudio: window.remotion_isReadOnlyStudio,
});
const [imageFormat, setImageFormat] = useState<RenderStillOnWebImageFormat>(
() => initialStillImageFormat ?? 'png',
);
const [frame, setFrame] = useState(() => initialFrame);
const [logLevel, setLogLevel] = useState(() => initialLogLevel);
const [inputProps, _setInputProps] = useState(() => defaultProps);
const setInputProps: UpdaterFunction<Record<string, unknown>> = useCallback(
(updater) => {
_setInputProps(updater);
},
[],
);
const [delayRenderTimeout, setDelayRenderTimeout] = useState(
initialDelayRenderTimeout ?? 30000,
);
const [mediaCacheSizeInBytes, setMediaCacheSizeInBytes] = useState<
number | null
>(initialMediaCacheSizeInBytes);
// Video-specific state
const [codec, setCodec] = useState<WebRendererVideoCodec>(
initialVideoCodec ?? 'h264',
);
const [container, setContainer] = useState<WebRendererContainer>(
initialContainer ?? 'mp4',
);
const [audioCodec, setAudioCodec] = useState<WebRendererAudioCodec>(
initialAudioCodec ?? 'aac',
);
const [audioBitrate, setAudioBitrate] = useState<WebRendererQuality>(
initialAudioBitrate ?? 'medium',
);
const [videoBitrate, setVideoBitrate] = useState<WebRendererQuality>(
initialVideoBitrate ?? 'high',
);
const [hardwareAcceleration, setHardwareAcceleration] =
useState<WebRendererHardwareAcceleration>(
(initialHardwareAcceleration as
| 'no-preference'
| 'prefer-hardware'
| 'prefer-software') ?? 'no-preference',
);
const [keyframeIntervalInSeconds, setKeyframeIntervalInSeconds] = useState(
initialKeyframeIntervalInSeconds ?? 5,
);
const [startFrame, setStartFrame] = useState<number | null>(
() => inFrameMark,
);
const [endFrame, setEndFrame] = useState<number | null>(() => outFrameMark);
const [transparent, setTransparent] = useState(initialTransparent ?? false);
const [muted, setMuted] = useState(initialMuted ?? false);
const [scale, setScale] = useState(initialScale ?? 1);
const [allowHtmlInCanvas, setAllowHtmlInCanvas] = useState(
initialAllowHtmlInCanvas ?? false,
);
const [pageResponsiveness, setPageResponsiveness] =
useState<WebRendererPageResponsiveness>(
initialPageResponsiveness ?? 'medium',
);
const encodableAudioCodecs = useEncodableAudioCodecs(container);
const encodableVideoCodecs = useEncodableVideoCodecs(container);
const effectiveAudioCodec = useMemo((): WebRendererAudioCodec => {
if (encodableAudioCodecs.includes(audioCodec)) {
return audioCodec;
}
return encodableAudioCodecs[0] ?? audioCodec;
}, [audioCodec, encodableAudioCodecs]);
const effectiveVideoCodec = useMemo((): WebRendererVideoCodec => {
if (encodableVideoCodecs.includes(codec)) {
return codec;
}
return encodableVideoCodecs[0] ?? codec;
}, [codec, encodableVideoCodecs]);
const finalEndFrame = useMemo(() => {
if (endFrame === null) {
return resolvedComposition.durationInFrames - 1;
}
return Math.max(
0,
Math.min(resolvedComposition.durationInFrames - 1, endFrame),
);
}, [endFrame, resolvedComposition.durationInFrames]);
const finalStartFrame = useMemo(() => {
if (startFrame === null) {
return 0;
}
return Math.max(0, Math.min(finalEndFrame, startFrame));
}, [finalEndFrame, startFrame]);
const [initialOutNameState] = useState(() => {
if (initialDefaultOutName) {
return initialDefaultOutName;
}
const defaultOut = getDefaultOutLocation({
compositionName: resolvedComposition.id,
defaultExtension:
renderMode === 'still'
? imageFormat
: isVideo
? container
: imageFormat,
type: 'asset',
compositionDefaultOutName: resolvedComposition.defaultOutName,
outputLocation: window.remotion_renderDefaults?.outputLocation ?? null,
});
if (window.remotion_isReadOnlyStudio) {
return defaultOut.replace(/^out\//, '');
}
return defaultOut;
});
const [outName, setOutName] = useState(() => initialOutNameState);
const updateOutNameExtension = useCallback((extension: string) => {
setOutName((prev) => getStringBeforeSuffix(prev) + '.' + extension);
}, []);
const setStillFormat = useCallback(
(format: RenderStillOnWebImageFormat) => {
setImageFormat(format);
updateOutNameExtension(format);
},
[updateOutNameExtension],
);
const setContainerFormat = useCallback(
(newContainer: WebRendererContainer) => {
setContainer(newContainer);
const defaultVideoCodec = getDefaultVideoCodecForContainer(newContainer);
if (defaultVideoCodec) {
setCodec(defaultVideoCodec);
}
setAudioCodec(getDefaultAudioCodecForContainer(newContainer));
updateOutNameExtension(newContainer);
},
[updateOutNameExtension],
);
const setCodecWithContainer = useCallback(
(newCodec: WebRendererVideoCodec) => {
setCodec(newCodec);
const newContainer = getDefaultContainerForCodec(newCodec);
setContainer(newContainer);
setAudioCodec(getDefaultAudioCodecForContainer(newContainer));
updateOutNameExtension(newContainer);
},
[updateOutNameExtension],
);
const onRenderModeChange = useCallback(
(newMode: RenderType) => {
setRenderMode(newMode);
if (newMode === 'video') {
const newContainer = isAudioOnlyContainer(container)
? 'mp4'
: container;
setContainer(newContainer);
setAudioCodec(getDefaultAudioCodecForContainer(newContainer));
updateOutNameExtension(newContainer);
} else if (newMode === 'audio') {
const newContainer: WebRendererContainer = 'wav';
setContainer(newContainer);
setMuted(false);
setAudioCodec(getDefaultAudioCodecForContainer(newContainer));
updateOutNameExtension(newContainer);
setTab((prev) => (prev === 'picture' ? 'general' : prev));
} else if (newMode === 'still') {
updateOutNameExtension(imageFormat);
setTab((prev) => (prev === 'audio' ? 'general' : prev));
}
},
[container, imageFormat, updateOutNameExtension],
);
const renderTabOptions = useMemo((): SegmentedControlItem[] => {
const options: SegmentedControlItem[] = [
{
label: 'Still',
onClick: () => {
onRenderModeChange('still');
},
key: 'still',
selected: renderMode === 'still',
},
];
// Only show video/audio options if composition has more than 1 frame
if (resolvedComposition.durationInFrames > 1) {
options.push({
label: 'Video',
onClick: () => {
onRenderModeChange('video');
},
key: 'video',
selected: renderMode === 'video',
});
options.push({
label: 'Audio',
onClick: () => {
onRenderModeChange('audio');
},
key: 'audio',
selected: renderMode === 'audio',
});
}
return options;
}, [renderMode, resolvedComposition.durationInFrames, onRenderModeChange]);
const onFrameSetDirectly = useCallback(
(newFrame: number) => {
setFrame(newFrame);
},
[setFrame],
);
const onFrameChanged = useCallback(
(e: string) => {
setFrame((q) => {
const newFrame = parseFloat(e);
if (Number.isNaN(newFrame)) {
return q;
}
return newFrame;
});
},
[setFrame],
);
const onOutNameChange: React.ChangeEventHandler<HTMLInputElement> =
useCallback((e) => {
setOutName(e.target.value);
}, []);
const outnameValidation = useMemo(() => {
if (renderMode === 'still') {
return validateOutnameForStill({
outName,
stillImageFormat: imageFormat,
});
}
// Validate for video
try {
const extension = outName.substring(outName.lastIndexOf('.') + 1);
const prefix = outName.substring(0, outName.lastIndexOf('.'));
const hasDotAfterSlash = () => {
const substrings = prefix.split('/');
for (const str of substrings) {
if (str[0] === '.') {
return true;
}
}
return false;
};
const hasInvalidChar = () => {
return prefix
.split('')
.some((char) => invalidCharacters.includes(char));
};
if (prefix.length < 1) {
throw new Error('The prefix must be at least 1 character long');
}
if (prefix[0] === '.' || hasDotAfterSlash()) {
throw new Error('The output name must not start with a dot');
}
if (hasInvalidChar()) {
throw new Error(
"Filename can't contain the following characters: ?, *, +, %, :",
);
}
if (extension !== container) {
throw new Error(
`The extension ${extension} is not supported for container format ${container}`,
);
}
return {valid: true as const};
} catch (err) {
return {valid: false as const, error: err as Error};
}
}, [outName, imageFormat, renderMode, container]);
const onAddToQueue = useCallback(() => {
const compositionRef = {
component: unresolvedComposition.component,
calculateMetadata: unresolvedComposition.calculateMetadata ?? null,
width: resolvedComposition.width,
height: resolvedComposition.height,
fps: resolvedComposition.fps,
durationInFrames: resolvedComposition.durationInFrames,
defaultProps: resolvedComposition.defaultProps,
};
if (renderMode === 'still') {
addClientStillJob(
{
type: 'client-still',
compositionId: resolvedComposition.id,
outName,
imageFormat,
frame,
inputProps,
delayRenderTimeout,
mediaCacheSizeInBytes,
logLevel,
licenseKey: publicLicenseKey,
scale,
allowHtmlInCanvas,
},
compositionRef,
);
} else {
addClientVideoJob(
{
type: 'client-video',
compositionId: resolvedComposition.id,
outName,
container,
videoCodec: isAudioOnlyContainer(container)
? null
: effectiveVideoCodec,
audioCodec: effectiveAudioCodec,
startFrame: finalStartFrame,
endFrame: finalEndFrame,
audioBitrate,
videoBitrate,
hardwareAcceleration,
keyframeIntervalInSeconds,
transparent,
muted,
inputProps,
delayRenderTimeout,
mediaCacheSizeInBytes,
logLevel,
licenseKey: publicLicenseKey,
scale,
allowHtmlInCanvas,
pageResponsiveness,
},
compositionRef,
);
}
setSidebarCollapsedState({left: null, right: 'expanded'});
persistSelectedOptionsSidebarPanel('renders');
optionsSidebarTabs.current?.selectRendersPanel();
setSelectedModal(null);
}, [
renderMode,
unresolvedComposition.component,
unresolvedComposition.calculateMetadata,
resolvedComposition.width,
resolvedComposition.height,
resolvedComposition.fps,
resolvedComposition.durationInFrames,
resolvedComposition.defaultProps,
resolvedComposition.id,
setSidebarCollapsedState,
outName,
imageFormat,
frame,
inputProps,
delayRenderTimeout,
mediaCacheSizeInBytes,
logLevel,
publicLicenseKey,
container,
effectiveVideoCodec,
effectiveAudioCodec,
finalStartFrame,
finalEndFrame,
audioBitrate,
videoBitrate,
hardwareAcceleration,
keyframeIntervalInSeconds,
transparent,
muted,
setSelectedModal,
addClientStillJob,
addClientVideoJob,
scale,
allowHtmlInCanvas,
pageResponsiveness,
]);
return (
<div style={outerModalStyle}>
<ModalHeader title={`Render ${resolvedComposition.id} in the browser`} />
<div style={containerStyle}>
<SegmentedControl items={renderTabOptions} needsWrapping={false} />
<div style={flexer} />
<Button
autoFocus
onClick={onAddToQueue}
style={buttonStyle}
disabled={!outnameValidation.valid}
>
Render {renderMode}
<ShortcutHint keyToPress="↵" cmdOrCtrl />
</Button>
</div>
<div style={horizontalLayout}>
<div style={leftSidebar}>
<VerticalTab
style={horizontalTab}
selected={tab === 'general'}
onClick={() => setTab('general')}
renderIcon={(color) => (
<div style={iconContainer}>
<FileIcon color={color} style={icon} />
</div>
)}
>
General
</VerticalTab>
<VerticalTab
style={horizontalTab}
selected={tab === 'data'}
onClick={() => setTab('data')}
renderIcon={(color) => (
<div style={iconContainer}>
<InputPropsIcon color={color} style={icon} />
</div>
)}
>
Input Props
</VerticalTab>
{renderMode !== 'audio' ? (
<VerticalTab
style={horizontalTab}
selected={tab === 'picture'}
onClick={() => setTab('picture')}
renderIcon={(color) => (
<div style={iconContainer}>
<PicIcon color={color} style={icon} />
</div>
)}
>
Picture
</VerticalTab>
) : null}
{renderMode === 'video' || renderMode === 'audio' ? (
<VerticalTab
style={horizontalTab}
selected={tab === 'audio'}
onClick={() => setTab('audio')}
renderIcon={(color) => (
<div style={iconContainer}>
<AudioIcon color={color} style={icon} />
</div>
)}
>
Audio
</VerticalTab>
) : null}
<VerticalTab
style={horizontalTab}
selected={tab === 'advanced'}
onClick={() => setTab('advanced')}
renderIcon={(color) => (
<div style={iconContainer}>
<GearIcon color={color} style={icon} />
</div>
)}
>
Other
</VerticalTab>
{canEditConfig ? (
<VerticalTab
style={horizontalTab}
selected={false}
onClick={() =>
setSelectedModal({
type: 'settings',
initialStudioPane: null,
initialTab: 'license',
initialPublicLicenseKey: publicLicenseKey,
})
}
renderIcon={(color) => (
<div style={iconContainer}>
<CertificateIcon color={color} style={icon} />
</div>
)}
>
License
</VerticalTab>
) : null}
</div>
<div style={optionsPanel} className={VERTICAL_SCROLLBAR_CLASSNAME}>
{tab === 'general' ? (
<WebRenderModalBasic
renderMode={renderMode}
resolvedComposition={resolvedComposition}
imageFormat={imageFormat}
setStillFormat={setStillFormat}
frame={frame}
onFrameChanged={onFrameChanged}
onFrameSetDirectly={onFrameSetDirectly}
container={container}
setContainerFormat={setContainerFormat}
setCodec={setCodecWithContainer}
encodableVideoCodecs={encodableVideoCodecs}
effectiveVideoCodec={effectiveVideoCodec}
startFrame={finalStartFrame}
setStartFrame={setStartFrame}
endFrame={finalEndFrame}
setEndFrame={setEndFrame}
outName={outName}
onOutNameChange={onOutNameChange}
validationMessage={
outnameValidation.valid ? null : outnameValidation.error.message
}
logLevel={logLevel}
setLogLevel={setLogLevel}
/>
) : tab === 'data' ? (
<DataEditor
defaultProps={inputProps}
setDefaultProps={setInputProps}
unresolvedComposition={unresolvedComposition}
propsEditType="input-props"
canSaveDefaultProps={{
canUpdate: false,
reason: 'render dialogue',
determined: false,
}}
/>
) : tab === 'picture' ? (
<WebRenderModalPicture
renderMode={renderMode}
videoBitrate={videoBitrate}
setVideoBitrate={setVideoBitrate}
keyframeIntervalInSeconds={keyframeIntervalInSeconds}
setKeyframeIntervalInSeconds={setKeyframeIntervalInSeconds}
transparent={transparent}
setTransparent={setTransparent}
scale={scale}
setScale={setScale}
compositionWidth={resolvedComposition.width}
compositionHeight={resolvedComposition.height}
/>
) : tab === 'audio' ? (
<WebRenderModalAudio
renderMode={renderMode}
muted={muted}
setMuted={setMuted}
audioCodec={audioCodec}
setAudioCodec={setAudioCodec}
audioBitrate={audioBitrate}
setAudioBitrate={setAudioBitrate}
container={container}
encodableCodecs={encodableAudioCodecs}
effectiveAudioCodec={effectiveAudioCodec}
/>
) : tab === 'advanced' ? (
<WebRenderModalAdvanced
renderMode={renderMode}
delayRenderTimeout={delayRenderTimeout}
setDelayRenderTimeout={setDelayRenderTimeout}
mediaCacheSizeInBytes={mediaCacheSizeInBytes}
setMediaCacheSizeInBytes={setMediaCacheSizeInBytes}
hardwareAcceleration={hardwareAcceleration}
setHardwareAcceleration={setHardwareAcceleration}
allowHtmlInCanvas={allowHtmlInCanvas}
setAllowHtmlInCanvas={setAllowHtmlInCanvas}
pageResponsiveness={pageResponsiveness}
setPageResponsiveness={setPageResponsiveness}
/>
) : null}
</div>
</div>
</div>
);
};
export const WebRenderModalWithLoader: React.FC<WebRenderModalState> = (
props,
) => {
return (
<DismissableModal>
<ResolveCompositionBeforeModal compositionId={props.compositionId}>
<WebRenderModal {...props} />
</ResolveCompositionBeforeModal>
</DismissableModal>
);
};