🎥 Make videos programmatically with React
import {formatBytes} from '@remotion/studio-shared';
import {
canUseVideoMatting,
getAvailableModels,
isVideoMattingModelCached,
type VideoMattingBitrate,
type VideoMattingModel,
} from '@remotion/video-matting';
import React, {
useCallback,
useContext,
useEffect,
useMemo,
useState,
} from 'react';
import {BLUE_DISABLED} from '../../helpers/colors';
import {Checkmark} from '../../icons/Checkmark';
import {GearIcon} from '../../icons/gear';
import {ModelsIcon} from '../../icons/models';
import type {VideoMattingModalState} 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 type {ComboboxValue} from '../NewComposition/ComboBox';
import {Combobox} from '../NewComposition/ComboBox';
import {DismissableModal} from '../NewComposition/DismissableModal';
import {ValidationMessage} from '../NewComposition/ValidationMessage';
import {optionsSidebarTabs} from '../options-sidebar-tabs';
import {persistSelectedOptionsSidebarPanel} from '../OptionsPanel';
import {
getDefaultOutputBaseName,
validatePublicOutputName,
} from '../public-output-name';
import {input, label, optionRow, rightRow} from '../RenderModal/layout';
import {
buttonStyle,
container,
flexer,
horizontalLayout,
horizontalTab,
icon,
iconContainer,
leftSidebar,
optionsPanel,
outerModalStyle,
} from '../RenderModal/render-modals';
import {RenderModalHr} from '../RenderModal/RenderModalHr';
import {RenderModalOutputName} from '../RenderModal/RenderModalOutputName';
import {RenderQueueContext} from '../RenderQueue/context';
import {VerticalTab} from '../Tabs/vertical';
import {useModelCacheStatus} from '../use-model-cache-status';
import {useStaticFiles} from '../use-static-files';
import {Models} from './Models';
const MODELS = getAvailableModels();
const controlStyle: React.CSSProperties = {width: 330, maxWidth: '100%'};
const panelStyle: React.CSSProperties = {
...optionsPanel,
flexDirection: 'column',
paddingTop: 16,
};
const modalStyle: React.CSSProperties = {
...outerModalStyle,
height: 'auto',
maxHeight: 'calc(100vh - 40px)',
minHeight: outerModalStyle.height,
outline: 'none',
};
const modalLayout: React.CSSProperties = {
...horizontalLayout,
flex: '1 1 auto',
};
const hiddenPanel: React.CSSProperties = {display: 'none'};
const validationStyle: React.CSSProperties = {padding: '0 16px 8px'};
type SupportState =
| {type: 'checking'}
| {type: 'supported'}
| {type: 'unsupported'; message: string};
type Tab = 'remove' | 'models';
const makeOptions = <Value extends string>({
items,
selected,
setSelected,
}: {
items: readonly {id: Value; label: React.ReactNode}[];
selected: Value;
setSelected: (value: Value) => void;
}): ComboboxValue[] =>
items.map(({id, label: optionLabel}) => ({
type: 'item',
id,
value: id,
label: optionLabel,
leftItem: id === selected ? <Checkmark /> : null,
keyHint: null,
quickSwitcherLabel: null,
subMenu: null,
disabled: false,
onClick: () => setSelected(id),
}));
export const VideoMattingModal: React.FC<VideoMattingModalState> = ({
displayName,
src,
target,
}) => {
const [tab, setTab] = useState<Tab>('remove');
const isModelCached = useCallback(
(selectedModel: VideoMattingModel) =>
isVideoMattingModelCached({model: selectedModel}),
[],
);
const cachedModels = useModelCacheStatus({
isModelCached,
models: MODELS,
refreshKey: tab,
});
const baseName = useMemo(
() => getDefaultOutputBaseName(src, displayName, 'video'),
[displayName, src],
);
const [outName, setOutName] = useState(`${baseName}-no-background.webm`);
const [model, setModel] = useState<VideoMattingModel>('modnet');
const [audio, setAudio] = useState<'keep' | 'none'>('keep');
const [videoBitrate, setVideoBitrate] =
useState<VideoMattingBitrate>('very-high');
const [support, setSupport] = useState<SupportState>({type: 'checking'});
const staticFiles = useStaticFiles();
const {addVideoMattingJob, videoMattingJobs} = useContext(RenderQueueContext);
const {setSelectedModal} = useContext(SetSelectedModalContext);
const {setSidebarCollapsedState} = useContext(SidebarContext);
useEffect(() => {
let cancelled = false;
setSupport({type: 'checking'});
canUseVideoMatting({model}).then((result) => {
if (!cancelled) {
setSupport(
result.supported
? {type: 'supported'}
: {type: 'unsupported', message: result.detailedReason},
);
}
});
return () => {
cancelled = true;
};
}, [model]);
const normalizedOutput = outName.normalize('NFC').toLowerCase();
const queuedOutputs = new Set(
videoMattingJobs
.filter(
(job) =>
job.status === 'idle' ||
job.status === 'running' ||
job.status === 'saving',
)
.map((job) => job.outName)
.map((name) => name.normalize('NFC').toLowerCase()),
);
const outputError =
validatePublicOutputName({extension: '.webm', outName}) ??
(queuedOutputs.has(normalizedOutput)
? 'Another background removal job is using this output file'
: null);
const outputExists = staticFiles.some(
(file) => file.name.normalize('NFC').toLowerCase() === normalizedOutput,
);
const canSubmit = support.type === 'supported' && outputError === null;
const modelOptions = useMemo(
() =>
makeOptions({
items: MODELS.map((item) => ({
id: item.name,
label: `${item.name} · ${formatBytes(item.webGpuDownloadSize)}${cachedModels.has(item.name) ? ' · Downloaded' : ''}`,
})),
selected: model,
setSelected: setModel,
}),
[cachedModels, model],
);
const audioOptions = useMemo(
() =>
makeOptions({
items: [
{id: 'keep' as const, label: 'Keep original audio'},
{id: 'none' as const, label: 'No audio'},
],
selected: audio,
setSelected: setAudio,
}),
[audio],
);
const qualityOptions = useMemo(
() =>
makeOptions({
items: ['very-low', 'low', 'medium', 'high', 'very-high'].map((id) => ({
id: id as VideoMattingBitrate & string,
label: id
.split('-')
.map((part) => part[0]!.toUpperCase() + part.slice(1))
.join(' '),
})),
selected: videoBitrate as VideoMattingBitrate & string,
setSelected: setVideoBitrate,
}),
[videoBitrate],
);
const submit = useCallback(() => {
if (!canSubmit) return;
addVideoMattingJob({
src,
displayName,
outName,
model,
audio,
videoBitrate,
target,
});
setSidebarCollapsedState({left: null, right: 'expanded'});
persistSelectedOptionsSidebarPanel('renders');
optionsSidebarTabs.current?.selectRendersPanel();
setSelectedModal(null);
}, [
addVideoMattingJob,
audio,
canSubmit,
displayName,
outName,
model,
setSelectedModal,
setSidebarCollapsedState,
src,
target,
videoBitrate,
]);
const title = `Remove background from ${displayName}`;
return (
<DismissableModal ariaLabel={title}>
<div style={modalStyle}>
<ModalHeader title={title} />
<div style={container}>
<div style={flexer} />
<Button
disabled={!canSubmit}
onClick={submit}
aria-label={
support.type === 'unsupported' ? support.message : undefined
}
style={{
...buttonStyle,
backgroundColor: canSubmit
? buttonStyle.backgroundColor
: BLUE_DISABLED,
}}
>
Remove background
</Button>
</div>
<div style={modalLayout}>
<div style={leftSidebar}>
<VerticalTab
autoFocus
onClick={() => setTab('remove')}
renderIcon={(color) => (
<div style={iconContainer}>
<GearIcon color={color} style={icon} />
</div>
)}
selected={tab === 'remove'}
style={horizontalTab}
>
General
</VerticalTab>
<VerticalTab
onClick={() => setTab('models')}
renderIcon={(color) => (
<div style={iconContainer}>
<ModelsIcon color={color} style={icon} />
</div>
)}
selected={tab === 'models'}
style={horizontalTab}
>
Models
</VerticalTab>
</div>
<div
style={tab === 'remove' ? panelStyle : hiddenPanel}
className={VERTICAL_SCROLLBAR_CLASSNAME}
>
<RenderModalOutputName
ariaLabel="Video output file"
existingOutputPath={
window.remotion_publicFolderExists
? `${window.remotion_publicFolderExists}/${outName}`
: null
}
existence={outputExists}
inputStyle={input}
label="Output in public/"
onValueChange={(event) => setOutName(event.target.value)}
outName={outName}
validationMessage={outputError}
/>
<RenderModalHr />
<div style={optionRow}>
<div style={label}>Model</div>
<div style={rightRow}>
<Combobox
values={modelOptions}
selectedId={model}
aria-label="Model"
style={controlStyle}
/>
</div>
</div>
{support.type === 'unsupported' ? (
<div style={validationStyle}>
<ValidationMessage
align="flex-end"
message={support.message}
type="error"
/>
</div>
) : null}
<div style={optionRow}>
<div style={label}>Audio</div>
<div style={rightRow}>
<Combobox
values={audioOptions}
selectedId={audio}
aria-label="Audio"
style={controlStyle}
/>
</div>
</div>
<div style={optionRow}>
<div style={label}>Video quality</div>
<div style={rightRow}>
<Combobox
values={qualityOptions}
selectedId={String(videoBitrate)}
aria-label="Video quality"
style={controlStyle}
/>
</div>
</div>
</div>
<Models
description={
'Models are downloaded automatically when needed.\nYou can also manage the browser cache here.'
}
indent
visible={tab === 'models'}
/>
</div>
</div>
</DismissableModal>
);
};