🎥 Make videos programmatically with React
import type {
AudioCodec,
ChromeMode,
Codec,
ColorSpace,
LogLevel,
OpenGlRenderer,
PixelFormat,
StillImageFormat,
VideoImageFormat,
X264Preset,
} from '@remotion/renderer';
import type {HardwareAccelerationOption} from '@remotion/renderer/client';
import {BrowserSafeApis} from '@remotion/renderer/client';
import type {
RenderDefaults,
RequiredChromiumOptions,
UiOpenGlOptions,
} from '@remotion/studio-shared';
import {getDefaultOutLocation} from '@remotion/studio-shared';
import React, {
useCallback,
useContext,
useEffect,
useMemo,
useReducer,
useRef,
useState,
} from 'react';
import type {_InternalTypes} from 'remotion';
import {ShortcutHint} from '../../error-overlay/remotion-overlay/ShortcutHint';
import {BLUE, BLUE_DISABLED} from '../../helpers/colors';
import {
envVariablesArrayToObject,
envVariablesObjectToArray,
} from '../../helpers/convert-env-variables';
import {copyText} from '../../helpers/copy-text';
import {makeReadOnlyStudioRenderCommand} from '../../helpers/make-render-command';
import {useRenderModalSections} from '../../helpers/render-modal-sections';
import {useKeybinding} from '../../helpers/use-keybinding';
import {AudioIcon} from '../../icons/audio';
import {Checkmark} from '../../icons/Checkmark';
import {DataIcon} from '../../icons/data';
import {FileIcon} from '../../icons/file';
import {PicIcon} from '../../icons/frame';
import {GearIcon} from '../../icons/gear';
import {GifIcon} from '../../icons/gif';
import {InputPropsIcon} from '../../icons/input-props';
import {FilmIcon} from '../../icons/video';
import {SetSelectedModalContext} from '../../state/modals';
import {SidebarContext} from '../../state/sidebar';
import {Button} from '../Button';
import {callApi} from '../call-api';
import {VERTICAL_SCROLLBAR_CLASSNAME} from '../Menu/is-menu-item';
import {ModalHeader} from '../ModalHeader';
import type {ComboboxValue} from '../NewComposition/ComboBox';
import {DismissableModal} from '../NewComposition/DismissableModal';
import {showNotification} from '../Notifications/NotificationCenter';
import {optionsSidebarTabs} from '../options-sidebar-tabs';
import {persistSelectedOptionsSidebarPanel} from '../OptionsPanel';
import {
addSequenceRenderJob,
addStillRenderJob,
addVideoRenderJob,
} from '../RenderQueue/actions';
import type {SegmentedControlItem} from '../SegmentedControl';
import {SegmentedControl} from '../SegmentedControl';
import {VerticalTab} from '../Tabs/vertical';
import {useCrfState} from './CrfSetting';
import {DataEditor} from './DataEditor';
import {getDefaultCodecs} from './get-default-codecs';
import {getStringBeforeSuffix} from './get-string-before-suffix';
import {validateOutnameGui} from './out-name-checker';
import {
buttonStyle,
container,
flexer,
horizontalLayout,
horizontalTab,
icon,
iconContainer,
leftSidebar,
optionsPanel,
outerModalStyle,
} from './render-modals';
import type {RenderType} from './RenderModalAdvanced';
import {RenderModalAdvanced} from './RenderModalAdvanced';
import {RenderModalAudio} from './RenderModalAudio';
import {RenderModalBasic} from './RenderModalBasic';
import {RenderModalEncoding, type QualityControl} from './RenderModalEncoding';
import {RenderModalEnvironmentVariables} from './RenderModalEnvironmentVariables';
import {RenderModalGif} from './RenderModalGif';
import {RenderModalPicture} from './RenderModalPicture';
import {
ResolveCompositionBeforeModal,
ResolvedCompositionContext,
} from './ResolveCompositionBeforeModal';
import type {UpdaterFunction} from './SchemaEditor/ZodSwitch';
type State =
| {
type: 'idle';
}
| {
type: 'success';
}
| {
type: 'load';
}
| {
type: 'error';
};
const initialState: State = {type: 'idle'};
type Action =
| {
type: 'start';
}
| {
type: 'succeed';
}
| {
type: 'fail';
};
const reducer = (state: State, action: Action): State => {
if (action.type === 'start') {
return {
type: 'load',
};
}
if (action.type === 'fail') {
return {
type: 'error',
};
}
if (action.type === 'succeed') {
return {
type: 'success',
};
}
return state;
};
type RenderModalProps = {
readonly readOnlyStudio: boolean;
readonly compositionId: string;
readonly initialFrame: number;
readonly initialVideoImageFormat: VideoImageFormat | null;
readonly initialStillImageFormat: StillImageFormat;
readonly initialJpegQuality: number;
readonly initialScale: number;
readonly initialLogLevel: LogLevel;
readonly initialConcurrency: number;
readonly minConcurrency: number;
readonly maxConcurrency: number;
readonly initialMuted: boolean;
readonly initialEnforceAudioTrack: boolean;
readonly initialProResProfile: _InternalTypes['ProResProfile'] | null;
readonly initialx264Preset: X264Preset;
readonly initialGopSize: number | null;
readonly initialPixelFormat: PixelFormat | null;
readonly initialVideoBitrate: string | null;
readonly initialAudioBitrate: string | null;
readonly initialEveryNthFrame: number;
readonly initialNumberOfGifLoops: number | null;
readonly initialDelayRenderTimeout: number;
readonly initialEnvVariables: Record<string, string>;
readonly initialDisableWebSecurity: boolean;
readonly initialGl: OpenGlRenderer | null;
readonly initialIgnoreCertificateErrors: boolean;
readonly initialOffthreadVideoCacheSizeInBytes: number | null;
readonly initialMediaCacheSizeInBytes: number | null;
readonly initialDarkMode: boolean;
readonly initialHeadless: boolean;
readonly initialColorSpace: ColorSpace;
readonly initialEncodingMaxRate: string | null;
readonly initialEncodingBufferSize: string | null;
readonly initialUserAgent: string | null;
readonly initialBeep: boolean;
readonly initialRepro: boolean;
readonly defaultProps: Record<string, unknown>;
readonly inFrameMark: number | null;
readonly outFrameMark: number | null;
readonly initialMultiProcessOnLinux: boolean;
readonly defaultConfigurationVideoCodec: Codec | null;
readonly defaultConfigurationAudioCodec: AudioCodec | null;
readonly initialForSeamlessAacConcatenation: boolean;
readonly initialHardwareAcceleration: HardwareAccelerationOption;
readonly initialSampleRate: number;
readonly renderTypeOfLastRender: RenderType | null;
readonly initialChromeMode: ChromeMode;
readonly initialOffthreadVideoThreads: number | null;
readonly defaultMetadata: Record<string, string> | null;
readonly renderDefaults: RenderDefaults;
};
const RenderModal: React.FC<
Omit<RenderModalProps, 'compositionId'> & {
readonly defaultConfigurationVideoCodec: Codec | null;
}
> = ({
readOnlyStudio,
initialFrame,
initialVideoImageFormat,
initialStillImageFormat,
initialJpegQuality,
initialScale,
initialLogLevel,
initialConcurrency,
maxConcurrency,
minConcurrency,
initialMuted,
initialEnforceAudioTrack,
initialProResProfile,
initialx264Preset,
initialGopSize,
initialPixelFormat,
initialVideoBitrate,
initialAudioBitrate,
initialEveryNthFrame,
initialNumberOfGifLoops,
initialDelayRenderTimeout,
initialOffthreadVideoCacheSizeInBytes,
initialEnvVariables,
initialDisableWebSecurity,
initialGl,
initialHeadless,
initialIgnoreCertificateErrors,
initialEncodingBufferSize,
initialEncodingMaxRate,
initialOffthreadVideoThreads,
initialMediaCacheSizeInBytes,
initialDarkMode,
initialUserAgent,
defaultProps,
inFrameMark,
outFrameMark,
initialColorSpace,
initialMultiProcessOnLinux,
defaultConfigurationAudioCodec,
defaultConfigurationVideoCodec,
initialBeep,
initialRepro,
initialForSeamlessAacConcatenation,
renderTypeOfLastRender,
initialHardwareAcceleration,
initialSampleRate,
defaultMetadata,
initialChromeMode,
renderDefaults,
}) => {
const {setSelectedModal} = useContext(SetSelectedModalContext);
const context = useContext(ResolvedCompositionContext);
if (!context) {
throw new Error(
'Should not be able to render without resolving comp first',
);
}
const {
resolved: {result: resolvedComposition},
unresolved: unresolvedComposition,
} = context;
const isMounted = useRef(true);
const [isVideo] = useState(() => {
return typeof resolvedComposition.durationInFrames === 'undefined'
? true
: resolvedComposition.durationInFrames > 1;
});
const [
{
initialAudioCodec,
initialRenderType,
initialVideoCodec,
initialVideoCodecForAudioTab,
initialVideoCodecForVideoTab,
},
] = useState(() => {
return getDefaultCodecs({
defaultConfigurationVideoCodec,
compositionDefaultVideoCodec: resolvedComposition.defaultCodec,
defaultConfigurationAudioCodec,
renderType: renderTypeOfLastRender ?? (isVideo ? 'video' : 'still'),
});
});
const [state, dispatch] = useReducer(reducer, initialState);
const [unclampedFrame, setFrame] = useState(() => initialFrame);
const [stillImageFormat, setStillImageFormat] = useState<StillImageFormat>(
() => initialStillImageFormat,
);
const [videoImageFormat, setVideoImageFormat] = useState<VideoImageFormat>(
() =>
initialVideoImageFormat ??
resolvedComposition.defaultVideoImageFormat ??
renderDefaults.videoImageFormat,
);
const [sequenceImageFormat, setSequenceImageFormat] =
useState<VideoImageFormat>(() =>
initialStillImageFormat === 'jpeg' ? 'jpeg' : 'png',
);
const [concurrency, setConcurrency] = useState(() => initialConcurrency);
const [videoCodecForVideoTab, setVideoCodecForVideoTab] = useState<Codec>(
() => initialVideoCodecForVideoTab,
);
const [userSelectedAudioCodec, setUserSelectedAudioCodec] =
useState<AudioCodec | null>(() => initialAudioCodec);
const [separateAudioTo, setSeparateAudioTo] = useState<string | null>(null);
const [envVariables, setEnvVariables] = useState<[string, string][]>(() =>
envVariablesObjectToArray(initialEnvVariables).filter(
([key]) => key !== 'NODE_ENV',
),
);
const [initialOutName] = useState(() => {
return getDefaultOutLocation({
compositionName: resolvedComposition.id,
defaultExtension:
initialRenderType === 'still'
? initialStillImageFormat
: isVideo
? BrowserSafeApis.getFileExtensionFromCodec(
initialVideoCodec,
initialAudioCodec,
)
: initialStillImageFormat,
type: 'asset',
compositionDefaultOutName: resolvedComposition.defaultOutName,
outputLocation: renderDefaults.outputLocation,
});
});
const [videoCodecForAudioTab, setVideoCodecForAudioTab] = useState<Codec>(
() => initialVideoCodecForAudioTab,
);
const [mutedState, setMuted] = useState(() => initialMuted);
const [repro, setRepro] = useState(() => initialRepro);
const [enforceAudioTrackState, setEnforceAudioTrackState] = useState(
() => initialEnforceAudioTrack,
);
const [forSeamlessAacConcatenation, setForSeamlessAacConcatenation] =
useState(() => initialForSeamlessAacConcatenation);
const [sampleRate, setSampleRate] = useState<number>(() => initialSampleRate);
const [renderMode, setRenderModeState] =
useState<RenderType>(initialRenderType);
const [jpegQuality, setJpegQuality] = useState<number>(
() => initialJpegQuality,
);
const [scale, setScale] = useState(() => initialScale);
const [logLevel, setLogLevel] = useState(() => initialLogLevel);
const [disallowParallelEncoding, setDisallowParallelEncoding] =
useState(false);
const [disableWebSecurity, setDisableWebSecurity] = useState<boolean>(
() => initialDisableWebSecurity,
);
const [headless, setHeadless] = useState<boolean>(() => initialHeadless);
const [beepOnFinish, setBeepOnFinish] = useState<boolean>(() => initialBeep);
const [ignoreCertificateErrors, setIgnoreCertificateErrors] =
useState<boolean>(() => initialIgnoreCertificateErrors);
const [multiProcessOnLinux, setChromiumMultiProcessOnLinux] =
useState<boolean>(() => initialMultiProcessOnLinux);
const [darkMode, setDarkMode] = useState<boolean>(() => initialDarkMode);
const [openGlOption, setOpenGlOption] = useState<UiOpenGlOptions>(
() => initialGl ?? 'default',
);
const [colorSpace, setColorSpace] = useState(() => initialColorSpace);
const [userAgent, setUserAgent] = useState<string | null>(() =>
initialUserAgent === null
? null
: initialUserAgent.trim() === ''
? null
: initialUserAgent,
);
const chromiumOptions: RequiredChromiumOptions = useMemo(() => {
return {
headless,
disableWebSecurity,
ignoreCertificateErrors,
gl: openGlOption === 'default' ? null : openGlOption,
userAgent:
userAgent === null ? null : userAgent.trim() === '' ? null : userAgent,
enableMultiProcessOnLinux: multiProcessOnLinux,
darkMode,
};
}, [
headless,
disableWebSecurity,
ignoreCertificateErrors,
openGlOption,
userAgent,
multiProcessOnLinux,
darkMode,
]);
const [outName, setOutName] = useState(() => initialOutName);
const [endFrameOrNull, setEndFrame] = useState<number | null>(
() => outFrameMark ?? null,
);
const [startFrameOrNull, setStartFrame] = useState<number | null>(
() => inFrameMark ?? null,
);
const [proResProfileSetting, setProResProfile] = useState<
_InternalTypes['ProResProfile']
>(
() =>
initialProResProfile ?? resolvedComposition.defaultProResProfile ?? 'hq',
);
const [x264PresetSetting, setx264Preset] = useState<X264Preset>(
() => initialx264Preset,
);
const [gopSize, setGopSize] = useState<number | null>(() => initialGopSize);
const [hardwareAcceleration, setHardwareAcceleration] =
useState<HardwareAccelerationOption>(() => initialHardwareAcceleration);
const [userPreferredPixelFormat, setPixelFormat] = useState<PixelFormat>(
() =>
initialPixelFormat ??
resolvedComposition.defaultPixelFormat ??
renderDefaults.pixelFormat,
);
const [preferredQualityControlType, setQualityControl] =
useState<QualityControl>(() =>
initialVideoBitrate === null ? 'crf' : 'bitrate',
);
const [
shouldHaveCustomTargetAudioBitrate,
setShouldHaveCustomTargetAudioBitrate,
] = useState(() => initialAudioBitrate !== null);
const [customTargetAudioBitrate, setCustomTargetAudioBitrateValue] = useState(
() => initialAudioBitrate ?? '320K',
);
const [customTargetVideoBitrate, setCustomTargetVideoBitrateValue] = useState(
() => initialVideoBitrate ?? '1M',
);
const [encodingMaxRate, setEncodingMaxRate] = useState<string | null>(
() => initialEncodingMaxRate ?? null,
);
const [encodingBufferSize, setEncodingBufferSize] = useState<string | null>(
() => initialEncodingBufferSize ?? null,
);
const [limitNumberOfGifLoops, setLimitNumberOfGifLoops] = useState(
() => initialNumberOfGifLoops !== null,
);
const [numberOfGifLoopsSetting, setNumberOfGifLoopsSetting] = useState(
() => initialNumberOfGifLoops ?? 0,
);
const [delayRenderTimeout, setDelayRenderTimeout] = useState(
() => initialDelayRenderTimeout,
);
const [chromeMode, setChromeMode] = useState(() => initialChromeMode);
const [offthreadVideoCacheSizeInBytes, setOffthreadVideoCacheSizeInBytes] =
useState<number | null>(initialOffthreadVideoCacheSizeInBytes);
const [mediaCacheSizeInBytes, setMediaCacheSizeInBytes] = useState<
number | null
>(initialMediaCacheSizeInBytes);
const [offthreadVideoThreads, setOffthreadVideoThreads] = useState<
number | null
>(() => initialOffthreadVideoThreads);
const codec = useMemo(() => {
if (renderMode === 'audio') {
return videoCodecForAudioTab;
}
return videoCodecForVideoTab;
}, [videoCodecForAudioTab, renderMode, videoCodecForVideoTab]);
const sharedMemoryCaptureRequest = useMemo(
() => ({
browserExecutable:
renderDefaults.sharedMemoryCapture === null
? null
: renderDefaults.sharedMemoryCapture.browserExecutable,
chromeMode,
chromiumOptions,
}),
[renderDefaults.sharedMemoryCapture, chromeMode, chromiumOptions],
);
const sharedMemoryCaptureRequestKey = JSON.stringify(
sharedMemoryCaptureRequest,
);
const [sharedMemoryCaptureSupport, setSharedMemoryCaptureSupport] = useState<{
requestKey: string;
supported: boolean;
} | null>(null);
const canUseSharedMemoryCapture =
!readOnlyStudio &&
renderDefaults.sharedMemoryCapture !== null &&
!renderDefaults.sharedMemoryCapture.disabled &&
renderMode === 'video' &&
!disallowParallelEncoding &&
BrowserSafeApis.canUseParallelEncoding(codec);
useEffect(() => {
if (!canUseSharedMemoryCapture) {
return;
}
const controller = new AbortController();
// Avoid launching a probe for every keystroke in the browser settings.
const timeout = setTimeout(() => {
callApi(
'/api/shared-memory-capture-support',
sharedMemoryCaptureRequest,
controller.signal,
)
.then(({supported}) => {
if (!controller.signal.aborted) {
setSharedMemoryCaptureSupport({
requestKey: sharedMemoryCaptureRequestKey,
supported,
});
}
})
.catch(() => {
if (!controller.signal.aborted) {
setSharedMemoryCaptureSupport({
requestKey: sharedMemoryCaptureRequestKey,
supported: false,
});
}
});
}, 300);
return () => {
clearTimeout(timeout);
controller.abort();
};
}, [
canUseSharedMemoryCapture,
sharedMemoryCaptureRequest,
sharedMemoryCaptureRequestKey,
]);
const usesSharedMemoryCapture =
canUseSharedMemoryCapture &&
sharedMemoryCaptureSupport?.requestKey === sharedMemoryCaptureRequestKey &&
sharedMemoryCaptureSupport.supported;
const numberOfGifLoops = useMemo(() => {
if (codec === 'gif' && limitNumberOfGifLoops) {
return numberOfGifLoopsSetting;
}
return null;
}, [codec, limitNumberOfGifLoops, numberOfGifLoopsSetting]);
const audioBitrate = useMemo(() => {
if (shouldHaveCustomTargetAudioBitrate) {
return customTargetAudioBitrate;
}
return null;
}, [customTargetAudioBitrate, shouldHaveCustomTargetAudioBitrate]);
const supportsCrf = BrowserSafeApis.codecSupportsCrf(codec);
const supportsVideoBitrate = BrowserSafeApis.codecSupportsVideoBitrate(codec);
const supportsBothQualityControls = useMemo(() => {
return (
supportsCrf &&
supportsVideoBitrate &&
hardwareAcceleration !== 'if-possible' &&
hardwareAcceleration !== 'required'
);
}, [hardwareAcceleration, supportsCrf, supportsVideoBitrate]);
const qualityControlType = useMemo(() => {
// When hardware acceleration is enabled, only bitrate is supported
if (
hardwareAcceleration === 'if-possible' ||
hardwareAcceleration === 'required'
) {
if (supportsVideoBitrate) {
return 'bitrate';
}
return null;
}
if (supportsBothQualityControls) {
return preferredQualityControlType;
}
if (supportsCrf) {
return 'crf';
}
if (supportsVideoBitrate) {
return 'bitrate';
}
return null;
}, [
hardwareAcceleration,
preferredQualityControlType,
supportsBothQualityControls,
supportsCrf,
supportsVideoBitrate,
]);
const videoBitrate = useMemo(() => {
if (qualityControlType === 'bitrate') {
return customTargetVideoBitrate;
}
return null;
}, [customTargetVideoBitrate, qualityControlType]);
const {crf, maxCrf, minCrf, setCrf} = useCrfState(codec);
const dispatchIfMounted: typeof dispatch = useCallback((payload) => {
if (isMounted.current === false) return;
dispatch(payload);
}, []);
const muted = useMemo(() => {
if (renderMode === 'video') {
return mutedState;
}
return false;
}, [mutedState, renderMode]);
const enforceAudioTrack = useMemo(() => {
if (renderMode === 'video') {
return enforceAudioTrackState;
}
if (renderMode === 'audio') {
return enforceAudioTrackState;
}
return false;
}, [enforceAudioTrackState, renderMode]);
const proResProfile = useMemo(() => {
if (renderMode === 'video' && codec === 'prores') {
return proResProfileSetting;
}
return null;
}, [codec, proResProfileSetting, renderMode]);
const x264Preset = useMemo(() => {
if (renderMode === 'video' && codec === 'h264') {
return x264PresetSetting;
}
return null;
}, [codec, x264PresetSetting, renderMode]);
const [inputProps, _setInputProps] = useState(() => defaultProps);
const setInputProps: UpdaterFunction<Record<string, unknown>> = useCallback(
(updater) => {
_setInputProps(updater);
},
[],
);
const [metadata] = useState(() => defaultMetadata);
const endFrame = useMemo((): number => {
if (endFrameOrNull === null) {
return resolvedComposition.durationInFrames - 1;
}
return Math.max(
0,
Math.min(resolvedComposition.durationInFrames - 1, endFrameOrNull),
);
}, [resolvedComposition.durationInFrames, endFrameOrNull]);
const startFrame = useMemo((): number => {
if (startFrameOrNull === null) {
return 0;
}
return Math.max(0, Math.min(endFrame - 1, startFrameOrNull));
}, [endFrame, startFrameOrNull]);
const frame = useMemo(() => {
const parsed = Math.floor(unclampedFrame);
return Math.max(
0,
Math.min(resolvedComposition.durationInFrames - 1, parsed),
);
}, [resolvedComposition.durationInFrames, unclampedFrame]);
const deriveFinalAudioCodec = useCallback(
(passedVideoCodec: Codec, passedAudioCodec: AudioCodec | null) => {
if (
passedAudioCodec !== null &&
(
BrowserSafeApis.supportedAudioCodecs[
passedVideoCodec
] as readonly AudioCodec[]
).includes(passedAudioCodec)
) {
return passedAudioCodec;
}
return BrowserSafeApis.defaultAudioCodecs[passedVideoCodec]
.compressed as AudioCodec;
},
[],
);
const setDefaultOutName = useCallback(
(
options:
| {type: 'sequence'}
| {type: 'still'; imageFormat: StillImageFormat}
| {
type: 'render';
codec: Codec;
audioCodec: AudioCodec;
},
) => {
if (options.type === 'still') {
setOutName((prev) => {
const newFileName =
getStringBeforeSuffix(prev) + '.' + options.imageFormat;
return newFileName;
});
} else if (options.type === 'sequence') {
setOutName((prev) => {
const folderName = getStringBeforeSuffix(prev);
return folderName;
});
} else {
setOutName((prev) => {
const codecSuffix = BrowserSafeApis.getFileExtensionFromCodec(
options.codec,
deriveFinalAudioCodec(options.codec, options.audioCodec),
);
const newFileName = getStringBeforeSuffix(prev) + '.' + codecSuffix;
return newFileName;
});
}
},
[deriveFinalAudioCodec],
);
const setAudioCodec = useCallback(
(newAudioCodec: AudioCodec) => {
setUserSelectedAudioCodec(newAudioCodec);
setDefaultOutName({
type: 'render',
codec: videoCodecForVideoTab,
audioCodec: newAudioCodec,
});
setSeparateAudioTo((prev) => {
if (prev === null) {
return null;
}
const newExtension =
BrowserSafeApis.getExtensionFromAudioCodec(newAudioCodec);
const newFileName = getStringBeforeSuffix(prev) + '.' + newExtension;
return newFileName;
});
},
[setDefaultOutName, videoCodecForVideoTab],
);
const setCodec = useCallback(
(newCodec: Codec) => {
if (renderMode === 'audio') {
setVideoCodecForAudioTab(newCodec);
} else {
setVideoCodecForVideoTab(newCodec);
}
setDefaultOutName({
type: 'render',
codec: newCodec,
audioCodec: deriveFinalAudioCodec(newCodec, userSelectedAudioCodec),
});
},
[
userSelectedAudioCodec,
deriveFinalAudioCodec,
renderMode,
setDefaultOutName,
],
);
const setStillFormat = useCallback(
(format: StillImageFormat) => {
setStillImageFormat(format);
setDefaultOutName({type: 'still', imageFormat: format});
},
[setDefaultOutName],
);
const {setSidebarCollapsedState} = useContext(SidebarContext);
const onClickStill = useCallback(() => {
setSidebarCollapsedState({left: null, right: 'expanded'});
persistSelectedOptionsSidebarPanel('renders');
optionsSidebarTabs.current?.selectRendersPanel();
dispatchIfMounted({type: 'start'});
addStillRenderJob({
compositionId: resolvedComposition.id,
outName,
imageFormat: stillImageFormat,
jpegQuality,
frame,
scale,
logLevel,
chromiumOptions,
delayRenderTimeout,
envVariables: envVariablesArrayToObject(envVariables),
inputProps,
offthreadVideoCacheSizeInBytes,
multiProcessOnLinux,
beepOnFinish,
metadata,
chromeMode,
offthreadVideoThreads,
mediaCacheSizeInBytes,
licenseKey: renderDefaults.publicLicenseKey,
})
.then(() => {
dispatchIfMounted({type: 'succeed'});
setSelectedModal(null);
})
.catch(() => {
dispatchIfMounted({type: 'fail'});
});
}, [
setSidebarCollapsedState,
dispatchIfMounted,
resolvedComposition.id,
outName,
stillImageFormat,
jpegQuality,
frame,
scale,
logLevel,
chromiumOptions,
delayRenderTimeout,
envVariables,
inputProps,
offthreadVideoCacheSizeInBytes,
multiProcessOnLinux,
beepOnFinish,
setSelectedModal,
metadata,
chromeMode,
offthreadVideoThreads,
mediaCacheSizeInBytes,
renderDefaults.publicLicenseKey,
]);
const [everyNthFrameSetting, setEveryNthFrameSetting] = useState(
() => initialEveryNthFrame,
);
const everyNthFrame = useMemo(() => {
if (codec === 'gif') {
return everyNthFrameSetting;
}
return 1;
}, [codec, everyNthFrameSetting]);
const audioCodec = deriveFinalAudioCodec(codec, userSelectedAudioCodec);
const availablePixelFormats = useMemo(() => {
return BrowserSafeApis.validPixelFormatsForCodec(codec);
}, [codec]);
const pixelFormat = useMemo(() => {
if (
(availablePixelFormats as string[]).includes(userPreferredPixelFormat)
) {
return userPreferredPixelFormat;
}
return availablePixelFormats[0];
}, [availablePixelFormats, userPreferredPixelFormat]);
const onClickVideo = useCallback(() => {
setSidebarCollapsedState({left: null, right: 'expanded'});
persistSelectedOptionsSidebarPanel('renders');
optionsSidebarTabs.current?.selectRendersPanel();
dispatchIfMounted({type: 'start'});
addVideoRenderJob({
compositionId: resolvedComposition.id,
outName,
imageFormat: videoImageFormat,
jpegQuality: stillImageFormat === 'jpeg' ? jpegQuality : null,
scale,
logLevel,
codec,
concurrency,
crf:
qualityControlType === 'crf' &&
hardwareAcceleration !== 'if-possible' &&
hardwareAcceleration !== 'required'
? crf
: null,
gopSize,
endFrame,
startFrame,
muted,
enforceAudioTrack,
proResProfile,
x264Preset,
pixelFormat,
audioBitrate,
videoBitrate,
everyNthFrame,
numberOfGifLoops,
delayRenderTimeout,
audioCodec,
disallowParallelEncoding,
chromiumOptions,
envVariables: envVariablesArrayToObject(envVariables),
inputProps,
offthreadVideoCacheSizeInBytes,
colorSpace,
multiProcessOnLinux,
encodingBufferSize,
encodingMaxRate,
beepOnFinish,
repro,
forSeamlessAacConcatenation,
separateAudioTo,
metadata,
hardwareAcceleration,
chromeMode,
offthreadVideoThreads,
mediaCacheSizeInBytes,
sampleRate,
licenseKey: renderDefaults.publicLicenseKey,
})
.then(() => {
dispatchIfMounted({type: 'succeed'});
setSelectedModal(null);
})
.catch(() => {
dispatchIfMounted({type: 'fail'});
});
}, [
setSidebarCollapsedState,
dispatchIfMounted,
resolvedComposition.id,
outName,
videoImageFormat,
stillImageFormat,
jpegQuality,
scale,
logLevel,
codec,
concurrency,
qualityControlType,
crf,
endFrame,
startFrame,
muted,
enforceAudioTrack,
proResProfile,
x264Preset,
pixelFormat,
audioBitrate,
videoBitrate,
everyNthFrame,
numberOfGifLoops,
delayRenderTimeout,
audioCodec,
disallowParallelEncoding,
chromiumOptions,
envVariables,
inputProps,
offthreadVideoCacheSizeInBytes,
colorSpace,
multiProcessOnLinux,
encodingBufferSize,
encodingMaxRate,
beepOnFinish,
repro,
forSeamlessAacConcatenation,
gopSize,
separateAudioTo,
setSelectedModal,
metadata,
hardwareAcceleration,
chromeMode,
offthreadVideoThreads,
mediaCacheSizeInBytes,
sampleRate,
renderDefaults.publicLicenseKey,
]);
const onClickSequence = useCallback(() => {
setSidebarCollapsedState({left: null, right: 'expanded'});
persistSelectedOptionsSidebarPanel('renders');
optionsSidebarTabs.current?.selectRendersPanel();
dispatchIfMounted({type: 'start'});
addSequenceRenderJob({
compositionId: resolvedComposition.id,
outName,
imageFormat: sequenceImageFormat,
scale,
logLevel,
concurrency,
endFrame,
jpegQuality,
startFrame,
delayRenderTimeout,
chromiumOptions,
envVariables: envVariablesArrayToObject(envVariables),
inputProps,
offthreadVideoCacheSizeInBytes,
disallowParallelEncoding,
multiProcessOnLinux,
beepOnFinish,
repro,
metadata,
chromeMode,
offthreadVideoThreads,
mediaCacheSizeInBytes,
})
.then(() => {
dispatchIfMounted({type: 'succeed'});
setSelectedModal(null);
})
.catch(() => {
dispatchIfMounted({type: 'fail'});
});
}, [
setSidebarCollapsedState,
dispatchIfMounted,
resolvedComposition.id,
outName,
sequenceImageFormat,
scale,
logLevel,
concurrency,
endFrame,
jpegQuality,
startFrame,
delayRenderTimeout,
chromiumOptions,
envVariables,
inputProps,
offthreadVideoCacheSizeInBytes,
disallowParallelEncoding,
multiProcessOnLinux,
beepOnFinish,
repro,
setSelectedModal,
metadata,
chromeMode,
offthreadVideoThreads,
mediaCacheSizeInBytes,
]);
useEffect(() => {
return () => {
isMounted.current = false;
};
}, []);
const imageFormatOptions = useMemo((): SegmentedControlItem[] => {
if (renderMode === 'still') {
return [
{
label: 'PNG',
onClick: () => setStillFormat('png'),
key: 'png',
selected: stillImageFormat === 'png',
},
{
label: 'JPEG',
onClick: () => setStillFormat('jpeg'),
key: 'jpeg',
selected: stillImageFormat === 'jpeg',
},
{
label: 'PDF',
onClick: () => setStillFormat('pdf'),
key: 'pdf',
selected: stillImageFormat === 'pdf',
},
{
label: 'WebP',
onClick: () => setStillFormat('webp'),
key: 'webp',
selected: stillImageFormat === 'webp',
},
];
}
if (renderMode === 'sequence') {
return [
{
label: 'PNG',
onClick: () => setSequenceImageFormat('png'),
key: 'png',
selected: sequenceImageFormat === 'png',
},
{
label: 'JPEG',
onClick: () => setSequenceImageFormat('jpeg'),
key: 'jpeg',
selected: sequenceImageFormat === 'jpeg',
},
];
}
return [
{
label: 'PNG',
onClick: () => setVideoImageFormat('png'),
key: 'png',
selected: videoImageFormat === 'png',
},
{
label: 'JPEG',
onClick: () => setVideoImageFormat('jpeg'),
key: 'jpeg',
selected: videoImageFormat === 'jpeg',
},
];
}, [
renderMode,
videoImageFormat,
stillImageFormat,
setStillFormat,
sequenceImageFormat,
]);
const setRenderMode = useCallback(
(newRenderMode: RenderType) => {
setRenderModeState(newRenderMode);
if (newRenderMode === 'audio') {
setDefaultOutName({
type: 'render',
codec: videoCodecForAudioTab,
audioCodec: deriveFinalAudioCodec(
videoCodecForAudioTab,
userSelectedAudioCodec,
),
});
}
if (newRenderMode === 'video') {
setDefaultOutName({
type: 'render',
codec: videoCodecForVideoTab,
audioCodec: deriveFinalAudioCodec(
videoCodecForVideoTab,
userSelectedAudioCodec,
),
});
}
if (newRenderMode === 'still') {
setDefaultOutName({type: 'still', imageFormat: stillImageFormat});
}
if (newRenderMode === 'sequence') {
setDefaultOutName({type: 'sequence'});
}
},
[
videoCodecForAudioTab,
userSelectedAudioCodec,
deriveFinalAudioCodec,
setDefaultOutName,
stillImageFormat,
videoCodecForVideoTab,
],
);
const renderTabOptions = useMemo((): SegmentedControlItem[] => {
if (resolvedComposition?.durationInFrames < 2) {
return [
{
label: 'Still',
onClick: () => {
setRenderMode('still');
},
key: 'still',
selected: renderMode === 'still',
},
];
}
return [
{
label: 'Still',
onClick: () => {
setRenderMode('still');
},
key: 'still',
selected: renderMode === 'still',
},
{
label: 'Video',
onClick: () => {
setRenderMode('video');
},
key: 'video',
selected: renderMode === 'video',
},
{
label: 'Audio',
onClick: () => {
setRenderMode('audio');
},
key: 'audio',
selected: renderMode === 'audio',
},
{
label: 'Image sequence',
onClick: () => {
setRenderMode('sequence');
},
key: 'sequence',
selected: renderMode === 'sequence',
},
];
}, [resolvedComposition?.durationInFrames, renderMode, setRenderMode]);
const outnameValidation = validateOutnameGui({
outName,
codec,
audioCodec,
renderMode,
stillImageFormat,
separateAudioTo,
});
const {tab, setTab, shownTabs} = useRenderModalSections(renderMode, codec);
const {registerKeybinding} = useKeybinding();
const readOnlyRenderCommand = useMemo(() => {
if (!readOnlyStudio) {
return null;
}
return makeReadOnlyStudioRenderCommand({
remotionVersion: window.remotion_version,
locationHref: window.location.href,
compositionId: resolvedComposition.id,
outName,
renderMode,
renderDefaults,
durationInFrames: resolvedComposition.durationInFrames,
concurrency,
frame,
startFrame,
endFrame,
stillImageFormat,
sequenceImageFormat,
videoImageFormat,
jpegQuality:
renderMode === 'video'
? stillImageFormat === 'jpeg'
? jpegQuality
: null
: renderMode === 'audio'
? null
: jpegQuality,
codec,
muted,
enforceAudioTrack,
proResProfile,
x264Preset,
pixelFormat,
crf:
qualityControlType === 'crf' &&
hardwareAcceleration !== 'if-possible' &&
hardwareAcceleration !== 'required'
? crf
: null,
gopSize,
videoBitrate,
audioBitrate,
audioCodec,
everyNthFrame,
numberOfGifLoops,
disallowParallelEncoding,
encodingBufferSize,
encodingMaxRate,
forSeamlessAacConcatenation,
separateAudioTo,
colorSpace,
scale,
logLevel,
delayRenderTimeout,
hardwareAcceleration,
chromeMode,
headless,
disableWebSecurity,
ignoreCertificateErrors,
gl: openGlOption === 'default' ? null : openGlOption,
userAgent,
multiProcessOnLinux,
darkMode,
offthreadVideoCacheSizeInBytes,
offthreadVideoThreads,
mediaCacheSizeInBytes,
beepOnFinish,
repro,
metadata,
sampleRate,
envVariables: envVariablesArrayToObject(envVariables),
inputProps,
});
}, [
audioBitrate,
audioCodec,
beepOnFinish,
chromeMode,
codec,
colorSpace,
concurrency,
crf,
darkMode,
delayRenderTimeout,
disableWebSecurity,
disallowParallelEncoding,
endFrame,
encodingBufferSize,
encodingMaxRate,
enforceAudioTrack,
envVariables,
everyNthFrame,
frame,
forSeamlessAacConcatenation,
gopSize,
hardwareAcceleration,
headless,
ignoreCertificateErrors,
inputProps,
jpegQuality,
logLevel,
mediaCacheSizeInBytes,
metadata,
multiProcessOnLinux,
muted,
numberOfGifLoops,
offthreadVideoCacheSizeInBytes,
offthreadVideoThreads,
openGlOption,
outName,
pixelFormat,
proResProfile,
qualityControlType,
readOnlyStudio,
renderDefaults,
renderMode,
repro,
resolvedComposition.durationInFrames,
resolvedComposition.id,
scale,
sampleRate,
separateAudioTo,
sequenceImageFormat,
startFrame,
stillImageFormat,
userAgent,
videoImageFormat,
videoBitrate,
x264Preset,
]);
const [commandCopiedAt, setCommandCopiedAt] = useState<number | null>(null);
const renderDisabled = readOnlyStudio
? false
: !outnameValidation.valid || state.type === 'load';
const trigger = useCallback(() => {
if (readOnlyStudio) {
if (!readOnlyRenderCommand) {
return;
}
copyText(readOnlyRenderCommand)
.then(() => {
setCommandCopiedAt(Date.now());
})
.catch((err) => {
showNotification(`Could not copy: ${err.message}`, 2000);
});
return;
}
if (renderMode === 'still') {
onClickStill();
} else if (renderMode === 'sequence') {
onClickSequence();
} else {
onClickVideo();
}
}, [
onClickSequence,
onClickStill,
onClickVideo,
readOnlyRenderCommand,
readOnlyStudio,
renderMode,
]);
useEffect(() => {
if (commandCopiedAt === null) {
return;
}
const timeout = setTimeout(() => {
setCommandCopiedAt(null);
}, 2000);
return () => clearTimeout(timeout);
}, [commandCopiedAt]);
useEffect(() => {
if (renderDisabled) {
return;
}
const enter = registerKeybinding({
callback() {
trigger();
},
commandCtrlKey: true,
key: 'Enter',
event: 'keydown',
preventDefault: true,
triggerIfInputFieldFocused: true,
keepRegisteredWhenNotHighestContext: false,
});
return () => {
enter.unregister();
};
}, [registerKeybinding, renderDisabled, trigger]);
const pixelFormatOptions = useMemo((): ComboboxValue[] => {
return availablePixelFormats.map((option) => {
return {
label: option,
onClick: () => setPixelFormat(option),
key: option,
id: option,
keyHint: null,
leftItem: pixelFormat === option ? <Checkmark /> : null,
quickSwitcherLabel: null,
subMenu: null,
type: 'item',
value: option,
};
});
}, [availablePixelFormats, pixelFormat]);
return (
<div style={outerModalStyle}>
<ModalHeader
title={`Render ${resolvedComposition.id} ${readOnlyStudio ? 'via CLI' : 'on the server'}`}
/>
<div style={container}>
<SegmentedControl items={renderTabOptions} needsWrapping={false} />
<div style={flexer} />
<Button
autoFocus
onClick={trigger}
disabled={renderDisabled}
style={{
...buttonStyle,
backgroundColor: outnameValidation.valid ? BLUE : BLUE_DISABLED,
}}
>
{readOnlyStudio
? commandCopiedAt
? 'Copied command!'
: 'Copy command'
: state.type === 'idle'
? `Render ${renderMode}`
: 'Rendering...'}
<ShortcutHint keyToPress="↵" cmdOrCtrl />
</Button>
</div>
<div style={horizontalLayout}>
<div style={leftSidebar}>
{shownTabs.includes('general') ? (
<VerticalTab
style={horizontalTab}
selected={tab === 'general'}
onClick={() => setTab('general')}
renderIcon={(color) => (
<div style={iconContainer}>
<FileIcon color={color} style={icon} />
</div>
)}
>
General
</VerticalTab>
) : null}
{shownTabs.includes('data') ? (
<VerticalTab
style={horizontalTab}
selected={tab === 'data'}
onClick={() => setTab('data')}
renderIcon={(color) => (
<div style={iconContainer}>
<InputPropsIcon color={color} style={icon} />
</div>
)}
>
Input Props
</VerticalTab>
) : null}
{shownTabs.includes('picture') ? (
<VerticalTab
style={horizontalTab}
selected={tab === 'picture'}
onClick={() => setTab('picture')}
renderIcon={(color) => (
<div style={iconContainer}>
<PicIcon color={color} style={icon} />
</div>
)}
>
Picture
</VerticalTab>
) : null}
{shownTabs.includes('audio') ? (
<VerticalTab
style={horizontalTab}
selected={tab === 'audio'}
onClick={() => setTab('audio')}
renderIcon={(color) => (
<div style={iconContainer}>
<AudioIcon color={color} style={icon} />
</div>
)}
>
Audio
</VerticalTab>
) : null}
{shownTabs.includes('gif') ? (
<VerticalTab
style={horizontalTab}
selected={tab === 'gif'}
onClick={() => setTab('gif')}
renderIcon={(color) => (
<div style={iconContainer}>
<GifIcon color={color} style={icon} />
</div>
)}
>
GIF
</VerticalTab>
) : null}
{shownTabs.includes('encoding') ? (
<VerticalTab
style={horizontalTab}
selected={tab === 'encoding'}
onClick={() => setTab('encoding')}
renderIcon={(color) => (
<div style={iconContainer}>
<FilmIcon color={color} style={icon} />
</div>
)}
>
Encoding
</VerticalTab>
) : null}
{shownTabs.includes('environment') ? (
<VerticalTab
style={horizontalTab}
selected={tab === 'environment'}
onClick={() => setTab('environment')}
renderIcon={(color) => (
<div style={iconContainer}>
<DataIcon color={color} style={icon} />
</div>
)}
>
Environment
</VerticalTab>
) : null}
{shownTabs.includes('advanced') ? (
<VerticalTab
style={horizontalTab}
selected={tab === 'advanced'}
onClick={() => setTab('advanced')}
renderIcon={(color) => (
<div style={iconContainer}>
<GearIcon color={color} style={icon} />
</div>
)}
>
Other
</VerticalTab>
) : null}
</div>
<div style={optionsPanel} className={VERTICAL_SCROLLBAR_CLASSNAME}>
{tab === 'general' ? (
<RenderModalBasic
codec={codec}
resolvedComposition={resolvedComposition}
frame={frame}
imageFormatOptions={imageFormatOptions}
outName={outName}
proResProfile={proResProfile}
renderMode={renderMode}
setVideoCodec={setCodec}
setFrame={setFrame}
setOutName={setOutName}
setProResProfile={setProResProfile}
endFrame={endFrame}
setEndFrame={setEndFrame}
setStartFrame={setStartFrame}
setVerboseLogging={setLogLevel}
logLevel={logLevel}
showOutputName={!readOnlyStudio}
startFrame={startFrame}
validationMessage={
outnameValidation.valid ? null : outnameValidation.error.message
}
/>
) : tab === 'picture' ? (
<RenderModalPicture
renderMode={renderMode}
scale={scale}
setScale={setScale}
imageFormatOptions={imageFormatOptions}
jpegQuality={jpegQuality}
setJpegQuality={setJpegQuality}
videoImageFormat={videoImageFormat}
usesSharedMemoryCapture={usesSharedMemoryCapture}
stillImageFormat={stillImageFormat}
compositionWidth={resolvedComposition.width}
compositionHeight={resolvedComposition.height}
/>
) : tab === 'audio' ? (
<RenderModalAudio
muted={muted}
renderMode={renderMode}
setMuted={setMuted}
codec={codec}
audioCodec={audioCodec}
setAudioCodec={setAudioCodec}
enforceAudioTrack={enforceAudioTrack}
setEnforceAudioTrackState={setEnforceAudioTrackState}
customTargetAudioBitrate={customTargetAudioBitrate}
setCustomTargetAudioBitrateValue={
setCustomTargetAudioBitrateValue
}
setShouldHaveCustomTargetAudioBitrate={
setShouldHaveCustomTargetAudioBitrate
}
shouldHaveCustomTargetAudioBitrate={
shouldHaveCustomTargetAudioBitrate
}
forSeamlessAacConcatenation={forSeamlessAacConcatenation}
setForSeamlessAacConcatenation={setForSeamlessAacConcatenation}
separateAudioTo={separateAudioTo}
setSeparateAudioTo={setSeparateAudioTo}
outName={outName}
sampleRate={sampleRate}
setSampleRate={setSampleRate}
/>
) : tab === 'gif' ? (
<RenderModalGif
everyNthFrame={everyNthFrame}
limitNumberOfGifLoops={limitNumberOfGifLoops}
numberOfGifLoopsSetting={numberOfGifLoopsSetting}
setEveryNthFrameSetting={setEveryNthFrameSetting}
setLimitNumberOfGifLoops={setLimitNumberOfGifLoops}
setNumberOfGifLoopsSetting={setNumberOfGifLoopsSetting}
/>
) : tab === 'encoding' ? (
<RenderModalEncoding
renderMode={renderMode}
codec={codec}
qualityControlType={qualityControlType}
setQualityControl={setQualityControl}
shouldDisplayQualityControlPicker={supportsBothQualityControls}
crf={crf}
setCrf={setCrf}
maxCrf={maxCrf}
minCrf={minCrf}
customTargetVideoBitrate={customTargetVideoBitrate}
setCustomTargetVideoBitrateValue={
setCustomTargetVideoBitrateValue
}
encodingBufferSize={encodingBufferSize}
setEncodingBufferSize={setEncodingBufferSize}
encodingMaxRate={encodingMaxRate}
setEncodingMaxRate={setEncodingMaxRate}
pixelFormat={pixelFormat}
pixelFormatOptions={pixelFormatOptions}
colorSpace={colorSpace}
setColorSpace={setColorSpace}
x264Preset={x264Preset}
setx264Preset={setx264Preset}
gopSize={gopSize}
setGopSize={setGopSize}
hardwareAcceleration={hardwareAcceleration}
setHardwareAcceleration={setHardwareAcceleration}
disallowParallelEncoding={disallowParallelEncoding}
setDisallowParallelEncoding={setDisallowParallelEncoding}
/>
) : tab === 'environment' ? (
<RenderModalEnvironmentVariables
envVariables={envVariables}
setEnvVariables={setEnvVariables}
/>
) : tab === 'data' ? (
<DataEditor
defaultProps={inputProps}
setDefaultProps={setInputProps}
unresolvedComposition={unresolvedComposition}
propsEditType="input-props"
canSaveDefaultProps={{
canUpdate: false,
reason: 'render dialogue',
determined: false,
}}
/>
) : (
<RenderModalAdvanced
concurrency={concurrency}
maxConcurrency={maxConcurrency}
minConcurrency={minConcurrency}
renderMode={renderMode}
setConcurrency={setConcurrency}
delayRenderTimeout={delayRenderTimeout}
setDelayRenderTimeout={setDelayRenderTimeout}
setDisableWebSecurity={setDisableWebSecurity}
setIgnoreCertificateErrors={setIgnoreCertificateErrors}
setHeadless={setHeadless}
headless={headless}
ignoreCertificateErrors={ignoreCertificateErrors}
disableWebSecurity={disableWebSecurity}
openGlOption={openGlOption}
setOpenGlOption={setOpenGlOption}
offthreadVideoCacheSizeInBytes={offthreadVideoCacheSizeInBytes}
setMediaCacheSizeInBytes={setMediaCacheSizeInBytes}
mediaCacheSizeInBytes={mediaCacheSizeInBytes}
setOffthreadVideoCacheSizeInBytes={
setOffthreadVideoCacheSizeInBytes
}
offthreadVideoThreads={offthreadVideoThreads}
setOffthreadVideoThreads={setOffthreadVideoThreads}
enableMultiProcessOnLinux={multiProcessOnLinux}
setChromiumMultiProcessOnLinux={setChromiumMultiProcessOnLinux}
userAgent={userAgent}
setUserAgent={setUserAgent}
setBeep={setBeepOnFinish}
beep={beepOnFinish}
repro={repro}
setRepro={setRepro}
chromeModeOption={chromeMode}
setChromeModeOption={setChromeMode}
darkMode={darkMode}
setDarkMode={setDarkMode}
/>
)}
</div>
</div>
</div>
);
};
export const RenderModalWithLoader: React.FC<RenderModalProps> = (props) => {
return (
<DismissableModal>
<ResolveCompositionBeforeModal compositionId={props.compositionId}>
<RenderModal {...props} />
</ResolveCompositionBeforeModal>
</DismissableModal>
);
};