🎥 Make videos programmatically with React
import type {CancelSignal, LogLevel} from '@remotion/renderer';
import {RenderInternals} from '@remotion/renderer';
import {NoReactAPIs} from '@remotion/renderer/pure';
import type {
AggregateRenderProgress,
BundlingState,
CopyingState,
RenderingProgressInput,
StitchingProgressInput,
} from '@remotion/studio-server';
import {StudioServerInternals} from '@remotion/studio-server';
import type {BrowserProgressLog} from '@remotion/studio-shared';
import {formatBytes, type ArtifactProgress} from '@remotion/studio-shared';
import {chalk} from './chalk';
import {
getFileSizeDownloadBar,
makeMultiDownloadProgress,
} from './download-progress';
import {formatEtaString} from './eta-string';
import {makeHyperlink} from './hyperlinks/make-link';
import {Log} from './log';
import {makeProgressBar} from './make-progress-bar';
import {truthy} from './truthy';
export type OverwriteableCliOutput = {
update: (up: string, newline: boolean) => boolean;
};
export const LABEL_WIDTH = 20;
const shouldSuppressCliProgressOutput = (options: {
quiet: boolean;
logLevel: LogLevel;
}): boolean => {
// When --log=error, only error lines may be printed; progress is not an error.
return options.quiet || options.logLevel === 'error';
};
export const createOverwriteableCliOutput = (options: {
quiet: boolean;
cancelSignal: CancelSignal | null;
updatesDontOverwrite: boolean;
indent: boolean;
logLevel: LogLevel;
}): OverwriteableCliOutput => {
if (shouldSuppressCliProgressOutput(options)) {
return {
update: () => false,
};
}
if (options.updatesDontOverwrite) {
return {
update: (up: string) => {
if (options.indent) {
process.stdout.write(
up
.split('\n')
.filter((a) => a.trim())
.map((l) => {
return `${RenderInternals.INDENT_TOKEN} ${l}`;
})
.join('\n') + '\n',
);
} else {
process.stdout.write(up + '\n');
}
return true;
},
};
}
const diff = new StudioServerInternals.AnsiDiff();
options.cancelSignal?.(() => {
process.stdout.write(diff.finish() as never as Uint8Array);
});
return {
update: (up: string, newline: boolean): boolean => {
if (options.indent) {
return process.stdout.write(
diff.update(
up
.split('\n')
.filter((a) => a.trim())
.map((l) => `${RenderInternals.INDENT_TOKEN} ${l}`)
.join('\n') + (newline ? '\n' : ''),
) as never as Uint8Array,
);
}
return process.stdout.write(
diff.update(up + (newline ? '\n' : '')) as never as Uint8Array,
);
},
};
};
const makeBundlingProgress = ({
bundlingState,
}: {
bundlingState: BundlingState;
}) => {
const {doneIn, progress} = bundlingState;
return [
`${doneIn ? 'Bundled' : 'Bundling'} code`.padEnd(LABEL_WIDTH, ' '),
makeProgressBar(progress, false),
doneIn === null
? (progress * 100).toFixed(0) + '%'
: chalk.gray(`${doneIn}ms`),
]
.filter(truthy)
.join(' ');
};
const makeCopyingProgress = (options: CopyingState) => {
// Don't show copy progress lower than 200MB
if (options.bytes < 1000 * 1000 * 200) {
return null;
}
return [
'Copying public dir'.padEnd(LABEL_WIDTH, ' '),
options.doneIn
? makeProgressBar(1, false)
: getFileSizeDownloadBar(options.bytes),
options.doneIn === null ? null : chalk.gray(`${options.doneIn}ms`),
]
.filter(truthy)
.join(' ');
};
const makeSymlinkProgress = (options: SymbolicLinksState) => {
if (options.symlinks.length === 0) {
return null;
}
if (options.symlinks.length === 1) {
return [
chalk.gray(` Found a symbolic link in the public folder:`),
chalk.gray(' ' + options.symlinks[0]),
chalk.gray(' The symlink will be forwarded in to the bundle.'),
].join('\n');
}
return [
chalk.gray(
` Found ${options.symlinks.length} symbolic links in the public folder.`,
),
chalk.gray(' The symlinks will be forwarded in to the bundle.'),
].join('\n');
};
export type SymbolicLinksState = {symlinks: string[]};
export const makeBundlingAndCopyProgress = ({
bundling,
copying,
symLinks,
}: {
bundling: BundlingState;
copying: CopyingState;
symLinks: SymbolicLinksState;
}) => {
return [
makeBundlingProgress({
bundlingState: bundling,
}),
makeCopyingProgress(copying),
makeSymlinkProgress(symLinks),
]
.filter(truthy)
.join('\n');
};
const makeRenderingProgress = ({
frames,
totalFrames,
doneIn,
timeRemainingInMilliseconds,
}: RenderingProgressInput) => {
const progress = frames / totalFrames;
return [
[doneIn ? 'Rendered' : 'Rendering', totalFrames === 1 ? 'still' : 'frames']
.filter(truthy)
.join(' ')
.padEnd(LABEL_WIDTH, ' '),
makeProgressBar(progress, false),
doneIn === null
? [
`${frames}/${totalFrames}`.padStart(getRightLabelWidth(totalFrames)),
timeRemainingInMilliseconds
? chalk.gray(
`${formatEtaString(timeRemainingInMilliseconds)} remaining`,
)
: null,
]
.filter(truthy)
.join(' ')
: chalk.gray(`${doneIn}ms`),
]
.filter(truthy)
.join(' ');
};
const ARTIFACTS_SHOWN = 5;
const makeArtifactProgress = (artifactState: ArtifactProgress) => {
const {received} = artifactState;
if (received.length === 0) {
return null;
}
const artifacts = received
.slice(0, ARTIFACTS_SHOWN)
.map((artifact) => {
return [
chalk.blue((artifact.alreadyExisted ? 'â—‹' : '+').padEnd(LABEL_WIDTH)),
chalk.blue(
makeHyperlink({
url: 'file://' + artifact.absoluteOutputDestination,
fallback: artifact.relativeOutputDestination,
text: artifact.relativeOutputDestination,
}),
),
chalk.gray(`${formatBytes(artifact.sizeInBytes)}`),
].join(' ');
})
.filter(truthy)
.join('\n');
const moreSizeCombined = received
.slice(ARTIFACTS_SHOWN)
.reduce((acc, artifact) => acc + artifact.sizeInBytes, 0);
const more =
received.length > ARTIFACTS_SHOWN
? chalk.gray(
`${' '.repeat(LABEL_WIDTH)} ${received.length - ARTIFACTS_SHOWN} more artifact${received.length - ARTIFACTS_SHOWN === 1 ? '' : 's'} ${formatBytes(moreSizeCombined)}`,
)
: null;
return [artifacts, more].filter(truthy).join('\n');
};
export const getRightLabelWidth = (totalFrames: number) => {
return `${totalFrames}/${totalFrames}`.length;
};
const makeLogsProgress = (logs: BrowserProgressLog[]) => {
if (logs.length === 0) {
return null;
}
return logs
.map((log) => {
return RenderInternals.Log.formatLogs(
log.logLevel,
{
indent: false,
// It the log makes it this far, it should be logged
// Bypass log level filter
logLevel: 'trace',
tag: log.tag ?? undefined,
},
[log.previewString],
).join(' ');
})
.join('\n');
};
const makeStitchingProgress = ({
stitchingProgress,
isUsingParallelEncoding,
}: {
stitchingProgress: StitchingProgressInput;
isUsingParallelEncoding: boolean;
}) => {
const {frames, totalFrames, doneIn, stage, codec} = stitchingProgress;
const progress = frames / totalFrames;
const mediaType =
codec === 'gif'
? 'GIF'
: NoReactAPIs.isAudioCodec(codec)
? 'audio'
: 'video';
return [
(stage === 'muxing' && isUsingParallelEncoding
? `${doneIn ? 'Muxed' : 'Muxing'} ${mediaType}`
: `${doneIn ? 'Encoded' : 'Encoding'} ${mediaType}`
).padEnd(LABEL_WIDTH, ' '),
makeProgressBar(progress, false),
doneIn === null
? `${String(frames).padStart(String(totalFrames).length, ' ')}/${totalFrames}`
: chalk.gray(`${doneIn}ms`),
]
.filter(truthy)
.join(' ');
};
export const makeRenderingAndStitchingProgress = ({
prog,
isUsingParallelEncoding,
}: {
prog: AggregateRenderProgress;
isUsingParallelEncoding: boolean;
}): {
output: string;
progress: number;
message: string;
} => {
const {rendering, stitching, downloads, bundling, artifactState, logs} = prog;
const output = [
rendering ? makeRenderingProgress(rendering) : null,
makeLogsProgress(logs),
makeMultiDownloadProgress(downloads, rendering?.totalFrames ?? 0),
stitching === null
? null
: makeStitchingProgress({
stitchingProgress: stitching,
isUsingParallelEncoding,
}),
makeArtifactProgress(artifactState),
]
.filter(truthy)
.join('\n');
const renderProgress = rendering
? rendering.frames / rendering.totalFrames
: 0;
const stitchingProgress = stitching
? stitching.frames / stitching.totalFrames
: 0;
const progress =
(bundling?.progress ?? 0) * 0.3 +
renderProgress * 0.6 +
stitchingProgress * 0.1;
return {output, progress, message: getGuiProgressSubtitle(prog)};
};
export const getGuiProgressSubtitle = (
progress: AggregateRenderProgress,
): string => {
if (progress.browser.error) {
return 'Failed to download browser';
}
if (!progress.browser.alreadyAvailable && progress.browser.doneIn === null) {
return `Downloading browser ${Math.round(progress.browser.progress * 100)}%`;
}
// Handle floating point inaccuracies
const bundlingProgress = progress.bundling?.progress || 0;
if (bundlingProgress < 0.99999) {
return `Bundling ${Math.round(bundlingProgress * 100)}%`;
}
if (
bundlingProgress === 1 &&
progress.bundling?.doneIn === null &&
progress.copyingState.bytes === 0
) {
return `Bundling ${Math.round(bundlingProgress * 100)}%`;
}
if (progress.copyingState.doneIn === null) {
return `Copying public dir ${StudioServerInternals.formatBytes(
progress.copyingState.bytes,
)}`;
}
if (!progress.rendering) {
return `Getting composition`;
}
// Get render estimated time value and extract hours, minutes, and seconds
const {timeRemainingInMilliseconds} = progress.rendering;
// Create estimated time string by concatenating them with colons
const estimatedTimeString =
timeRemainingInMilliseconds === null
? null
: formatEtaString(timeRemainingInMilliseconds);
const allRendered =
progress.rendering.frames === progress.rendering.totalFrames;
if (!allRendered || !progress.stitching || progress.stitching.frames === 0) {
const etaString =
timeRemainingInMilliseconds && timeRemainingInMilliseconds > 0
? `, time remaining: ${estimatedTimeString}`
: '';
return `Rendered ${progress.rendering.frames}/${progress.rendering.totalFrames}${etaString}`;
}
return `Encoded ${progress.stitching.frames}/${progress.stitching.totalFrames}`;
};
export const printFact =
(printLevel: LogLevel) =>
({
indent,
logLevel,
left,
right,
color,
link,
}: {
indent: boolean;
logLevel: LogLevel;
left: string;
right: string;
link?: string;
color: 'blue' | 'blueBright' | 'gray' | undefined;
}) => {
const fn = (str: string) => {
if (color === 'gray') {
return chalk.gray(str);
}
if (color === 'blue') {
return chalk.blue(str);
}
if (color === 'blueBright') {
return chalk.blueBright(str);
}
return str;
};
if (RenderInternals.isEqualOrBelowLogLevel(logLevel, 'verbose')) {
Log[printLevel]({indent, logLevel}, fn(`${left} = ${right}`));
return;
}
let leftPadded = left.padEnd(LABEL_WIDTH, ' ');
if (link) {
const endPadding = LABEL_WIDTH - left.length;
leftPadded =
makeHyperlink({
text: left,
fallback: left,
url: link,
}) + ' '.repeat(endPadding);
}
Log[printLevel]({indent, logLevel}, fn(`${leftPadded} ${right}`));
};