Skip to content

🎥 Make videos programmatically with React

7.5 KB
Raw Blame
import {PlayerInternals} from '@remotion/player';
import React, {useCallback, useContext, useMemo, useRef, useState} from 'react';
import {Internals} from 'remotion';
import {checkFullscreenSupport} from '../helpers/check-fullscreen-support';
import {BACKGROUND, BLACK_ALPHA_50} from '../helpers/colors';
import {getPreviewFileType} from '../helpers/get-preview-file-type';
import {
	useIsStill,
	useIsVideoComposition,
} from '../helpers/is-current-selected-still';
import {useMobileLayout} from '../helpers/mobile-layout';
import {TIMELINE_PADDING} from '../helpers/timeline-layout';
import {loadLoopOption} from '../state/loop';
import {CheckboardToggle} from './CheckboardToggle';
import {FpsCounter} from './FpsCounter';
import {FullScreenToggle} from './FullscreenToggle';
import {Flex, Spacing} from './layout';
import {LoopToggle} from './LoopToggle';
import {MuteToggle} from './MuteToggle';
import {PlaybackKeyboardShortcutsManager} from './PlaybackKeyboardShortcutsManager';
import {PlaybackRatePersistor} from './PlaybackRatePersistor';
import {PlaybackRateSelector} from './PlaybackRateSelector';
import {PlayPause} from './PlayPause';
import {PreviewToolbarOverflowButton} from './PreviewToolbarOverflowButton';
import {PreviewViewOptionsDropdown} from './PreviewViewOptionsDropdown';
import {RenderButton} from './RenderButton';
import {SizeSelector} from './SizeSelector';
import {SnappingToggle} from './SnappingToggle';
import {TimelineInOutPointToggle} from './TimelineInOutToggle';

const TOOLBAR_HEIGHT = 40;

const container: React.CSSProperties = {
	display: 'flex',
	position: 'relative',
	justifyContent: 'center',
	boxShadow: `inset 0 1px ${BLACK_ALPHA_50}`,
	alignItems: 'center',
	flexDirection: 'row',
	background: BACKGROUND,
	height: TOOLBAR_HEIGHT,
};

const centeredPlayButton: React.CSSProperties = {
	position: 'absolute',
	left: '50%',
	top: 0,
	height: TOOLBAR_HEIGHT,
	display: 'flex',
	alignItems: 'center',
	transform: 'translateX(-50%)',
};

const sideContainer: React.CSSProperties = {
	width: 300,
	height: 30,
	display: 'flex',
	flexDirection: 'row',
	alignItems: 'center',
};

const padding: React.CSSProperties = {
	width: TIMELINE_PADDING,
};

const toolbarControl: React.CSSProperties = {
	display: 'flex',
	flexShrink: 0,
};

const PreviewToolbarControl: React.FC<{
	readonly children: React.ReactNode;
}> = ({children}) => {
	const onPointerDown = useCallback((e: React.PointerEvent<HTMLDivElement>) => {
		// Prevent deselection of currently selected items
		e.stopPropagation();
	}, []);

	return (
		<div style={toolbarControl} onPointerDown={onPointerDown}>
			{children}
		</div>
	);
};

export const PreviewToolbar: React.FC<{
	readonly readOnlyStudio: boolean;
	readonly bufferStateDelayInMilliseconds: number;
}> = ({readOnlyStudio, bufferStateDelayInMilliseconds}) => {
	const ref = useRef<HTMLDivElement>(null);
	const size = PlayerInternals.useElementSize(ref, {
		triggerOnWindowResize: true,
		shouldApplyCssTransforms: true,
	});
	const width = Math.round(size?.width ?? 0);
	const containerStyle = useMemo((): React.CSSProperties => {
		return {
			...container,
			// Keep the two flexible gaps equal in whole pixels at odd widths.
			paddingRight: width % 2,
		};
	}, [width]);
	const playButtonStyle = useMemo((): React.CSSProperties => {
		return {
			...centeredPlayButton,
			left: size === null ? '50%' : Math.floor(width / 2),
		};
	}, [size, width]);
	const {playbackRate, setPlaybackRate} = Internals.usePlaybackRate();

	const {playerMuted} = useContext(Internals.MediaVolumeContext);
	const {setPlayerMuted} = useContext(Internals.SetMediaVolumeContext);
	const {canvasContent} = useContext(Internals.CompositionManager);
	const isVideoComposition = useIsVideoComposition();
	const showCompositionControls = canvasContent?.type === 'composition';
	const showCanvasViewControls =
		showCompositionControls ||
		(canvasContent?.type === 'asset' &&
			getPreviewFileType(canvasContent.asset) === 'video');

	const isStill = useIsStill();

	const [loop, setLoop] = useState(loadLoopOption());

	const isFullscreenSupported = checkFullscreenSupport();
	const isMobileLayout = useMobileLayout();
	const playPause = (
		<PreviewToolbarControl>
			<PlayPause
				bufferStateDelayInMilliseconds={bufferStateDelayInMilliseconds}
				loop={loop}
				playbackRate={playbackRate}
				muted={playerMuted}
				hideNavigationControls={isMobileLayout}
			/>
		</PreviewToolbarControl>
	);

	return (
		<div ref={ref} style={containerStyle} className="css-reset">
			<div style={sideContainer}>
				<div style={padding} />
				{isMobileLayout ? null : (
					<PreviewToolbarControl>
						<SizeSelector />
					</PreviewToolbarControl>
				)}
				{!isMobileLayout && (isStill || isVideoComposition) ? (
					<>
						<Spacing x={2} />
						<PreviewToolbarControl>
							<PlaybackRateSelector
								setPlaybackRate={setPlaybackRate}
								playbackRate={playbackRate}
							/>
						</PreviewToolbarControl>
					</>
				) : null}
				{isMobileLayout ? (
					<>
						<PreviewToolbarControl>
							<PreviewToolbarOverflowButton
								showFullscreen={Boolean(canvasContent && isFullscreenSupported)}
								showPlaybackRate={isVideoComposition}
								showLoop={isVideoComposition}
								showCanvasViewControls={showCanvasViewControls}
								showCompositionControls={showCompositionControls}
								playbackRate={playbackRate}
								setPlaybackRate={setPlaybackRate}
								loop={loop}
								setLoop={setLoop}
							/>
						</PreviewToolbarControl>
						<Spacing x={1.5} />
					</>
				) : null}
				{isVideoComposition && isMobileLayout ? (
					<PreviewToolbarControl>
						<MuteToggle muted={playerMuted} setMuted={setPlayerMuted} />
					</PreviewToolbarControl>
				) : null}
			</div>
			<Flex />

			{isVideoComposition && isMobileLayout ? (
				<div style={playButtonStyle}>{playPause}</div>
			) : null}
			{isVideoComposition && !isMobileLayout ? (
				<>
					<Spacing x={2} />
					<PreviewToolbarControl>
						<LoopToggle loop={loop} setLoop={setLoop} />
					</PreviewToolbarControl>
					<PreviewToolbarControl>
						<MuteToggle muted={playerMuted} setMuted={setPlayerMuted} />
					</PreviewToolbarControl>
					<Spacing x={1} />
					<PreviewToolbarControl>
						<TimelineInOutPointToggle />
					</PreviewToolbarControl>
					<Spacing x={3} />
					{playPause}
					<Spacing x={3} />
				</>
			) : null}
			{showCanvasViewControls ? (
				<>
					{isMobileLayout ? null : (
						<PreviewToolbarControl>
							<CheckboardToggle />
						</PreviewToolbarControl>
					)}
					{readOnlyStudio ||
					isMobileLayout ||
					!showCompositionControls ? null : (
						<PreviewToolbarControl>
							<SnappingToggle />
						</PreviewToolbarControl>
					)}
					{isMobileLayout ? null : (
						<PreviewToolbarControl>
							<PreviewViewOptionsDropdown
								showCompositionControls={showCompositionControls}
							/>
						</PreviewToolbarControl>
					)}
				</>
			) : null}
			<Spacing x={2} />
			{canvasContent && isFullscreenSupported ? (
				<PreviewToolbarControl>
					<FullScreenToggle hidden={isMobileLayout} />
				</PreviewToolbarControl>
			) : null}
			<Flex />
			<div style={sideContainer}>
				<Flex />
				{isMobileLayout ? null : <FpsCounter playbackSpeed={playbackRate} />}
				<Spacing x={2} />
				<PreviewToolbarControl>
					<RenderButton
						readOnlyStudio={readOnlyStudio}
						size="compact"
						narrow={isMobileLayout}
					/>
				</PreviewToolbarControl>
				<Spacing x={1.5} />
			</div>
			<PlaybackKeyboardShortcutsManager
				setPlaybackRate={setPlaybackRate}
				setMuted={setPlayerMuted}
				setLoop={setLoop}
			/>
			<PlaybackRatePersistor />
		</div>
	);
};