Skip to content

🎥 Make videos programmatically with React

24.0 KB
Raw Blame
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>
	);
};