Skip to content

🎥 Make videos programmatically with React

7.6 KB
Raw Blame
import {afterAll, beforeAll, describe, expect, it} from 'bun:test';
import {availableParallelism} from 'node:os';
import path from 'node:path';
import {
	openBrowser,
	renderFrames,
	renderStill,
	selectComposition,
	type HeadlessBrowser,
} from '@remotion/renderer';
import execa from 'execa';
import pixelmatch from 'pixelmatch';
import {PNG} from 'pngjs';

const SHOWCASE_ID = 'gsap-showcase';
const FPS_24_FIXTURE_ID = 'gsap-fps-24';
const FPS_30_FIXTURE_ID = 'gsap-fps-30';
const FPS_60_FIXTURE_ID = 'gsap-fps-60';
const SEQUENCE_FIXTURE_ID = 'gsap-sequence';
const NESTED_SEQUENCE_FIXTURE_ID = 'gsap-nested-sequence';
const PARITY_FIXTURE_ID = 'gsap-parity';

const exampleDir = path.resolve(__dirname, '..', '..', '..', 'example');
const serveUrl = path.join(exampleDir, 'build');
const shuffledFrames = [105, 0, 195, 45, 150, 15, 75];
const rendererConcurrency = Math.min(8, availableParallelism());

// pixelmatch's types do not accept Buffer directly
const asUint8Array = (data: Buffer) =>
	new Uint8Array(data.buffer, data.byteOffset, data.byteLength);

const pixelDifference = (leftBuffer: Buffer, rightBuffer: Buffer) => {
	const left = PNG.sync.read(leftBuffer);
	const right = PNG.sync.read(rightBuffer);

	expect(right.width).toBe(left.width);
	expect(right.height).toBe(left.height);

	return pixelmatch(
		asUint8Array(left.data),
		asUint8Array(right.data),
		undefined,
		left.width,
		left.height,
		{threshold: 0},
	);
};

const pixelAt = (buffer: Buffer, x: number, y: number) => {
	const png = PNG.sync.read(buffer);
	const offset = (y * png.width + x) * 4;
	return [...png.data.subarray(offset, offset + 4)];
};

describe('GSAP renderer parity', () => {
	let composition: Awaited<ReturnType<typeof selectComposition>>;
	let browser: HeadlessBrowser;

	beforeAll(async () => {
		// In CI, the example project is already bundled.
		if (!process.env.CI) {
			await execa('bun', ['x', 'remotion', 'bundle'], {
				cwd: exampleDir,
			});
		}

		browser = await openBrowser('chrome', {logLevel: 'warn'});
		composition = await selectComposition({
			serveUrl,
			id: SHOWCASE_ID,
			puppeteerInstance: browser,
		});
	});

	afterAll(async () => {
		await browser?.close({silent: false});
	});

	const renderFrameMap = async (
		targetComposition: Awaited<ReturnType<typeof selectComposition>>,
		concurrency: number,
	) => {
		const frames = new Map<number, Buffer>();

		await renderFrames({
			serveUrl,
			composition: targetComposition,
			inputProps: {},
			outputDir: null,
			imageFormat: 'png',
			frameRange: [0, targetComposition.durationInFrames - 1],
			everyNthFrame: 1,
			concurrency,
			puppeteerInstance: browser,
			onStart: () => undefined,
			onFrameUpdate: () => undefined,
			onFrameBuffer: (buffer, frame) => {
				frames.set(frame, buffer);
			},
			logLevel: 'warn',
		});

		return frames;
	};

	it(
		'keeps showcase frames identical across concurrent, shuffled, and repeated renders',
		async () => {
			const sequenceFrames = new Map<number, Buffer>();

			await renderFrames({
				serveUrl,
				composition,
				inputProps: {},
				outputDir: null,
				imageFormat: 'png',
				frameRange: [0, composition.durationInFrames - 1],
				everyNthFrame: 15,
				concurrency: Math.min(4, rendererConcurrency),
				puppeteerInstance: browser,
				onStart: () => undefined,
				onFrameUpdate: () => undefined,
				onFrameBuffer: (buffer, frame) => {
					sequenceFrames.set(frame, buffer);
				},
				logLevel: 'warn',
			});

			const directFrames = new Map<number, Buffer>();
			for (const frame of [...shuffledFrames, 87]) {
				const direct = await renderStill({
					serveUrl,
					composition,
					frame,
					output: null,
					imageFormat: 'png',
					puppeteerInstance: browser,
					logLevel: 'warn',
				});

				expect(
					direct.buffer,
					`direct buffer for frame ${frame}`,
				).not.toBeNull();
				directFrames.set(frame, direct.buffer!);

				if (shuffledFrames.includes(frame)) {
					const fromSequence = sequenceFrames.get(frame);
					expect(
						fromSequence,
						`sequence buffer for frame ${frame}`,
					).toBeDefined();
					expect(
						pixelDifference(fromSequence!, direct.buffer!),
						`showcase frame ${frame}`,
					).toBe(0);
				}
			}

			const repeated = await renderStill({
				serveUrl,
				composition,
				frame: 87,
				output: null,
				puppeteerInstance: browser,
				imageFormat: 'png',
				logLevel: 'warn',
			});

			expect(pixelDifference(directFrames.get(87)!, repeated.buffer!)).toBe(0);
		},
		{timeout: 120000},
	);

	it(
		'maps timeline time and boundary states consistently across frame rates and Sequences',
		async () => {
			const fps24 = await selectComposition({
				serveUrl,
				id: FPS_24_FIXTURE_ID,
				puppeteerInstance: browser,
			});
			const fps30 = await selectComposition({
				serveUrl,
				id: FPS_30_FIXTURE_ID,
				puppeteerInstance: browser,
			});
			const fps60 = await selectComposition({
				serveUrl,
				id: FPS_60_FIXTURE_ID,
				puppeteerInstance: browser,
			});
			const sequence = await selectComposition({
				serveUrl,
				id: SEQUENCE_FIXTURE_ID,
				puppeteerInstance: browser,
			});
			const nestedSequence = await selectComposition({
				serveUrl,
				id: NESTED_SEQUENCE_FIXTURE_ID,
				puppeteerInstance: browser,
			});

			const render = (
				targetComposition: Awaited<ReturnType<typeof selectComposition>>,
				frame: number,
			) =>
				renderStill({
					serveUrl,
					composition: targetComposition,
					frame,
					output: null,
					puppeteerInstance: browser,
					imageFormat: 'png',
					logLevel: 'warn',
				});

			const [
				halfSecond24,
				halfSecond30,
				halfSecond60,
				halfSecondInSequence,
				halfSecondInNestedSequence,
				start,
				midpoint,
				postDuration,
			] = await Promise.all([
				render(fps24, 12),
				render(fps30, 15),
				render(fps60, 30),
				render(sequence, 45),
				render(nestedSequence, 45),
				render(fps30, 0),
				render(fps30, 12),
				render(fps30, 59),
			]);

			expect(pixelDifference(halfSecond24.buffer!, halfSecond30.buffer!)).toBe(
				0,
			);
			expect(pixelDifference(halfSecond30.buffer!, halfSecond60.buffer!)).toBe(
				0,
			);
			expect(
				pixelDifference(halfSecond30.buffer!, halfSecondInSequence.buffer!),
			).toBe(0);
			expect(
				pixelDifference(
					halfSecond30.buffer!,
					halfSecondInNestedSequence.buffer!,
				),
			).toBe(0);
			expect(pixelAt(start.buffer!, 50, 50)).toEqual([0, 0, 0, 255]);
			expect(pixelAt(midpoint.buffer!, 50, 50)).toEqual([102, 0, 0, 255]);
			expect(pixelAt(postDuration.buffer!, 50, 50)).toEqual([255, 0, 0, 255]);
		},
		{timeout: 120000},
	);

	it(
		'keeps complex fixtures identical across serial, concurrent, and shuffled rendering',
		async () => {
			const parity = await selectComposition({
				serveUrl,
				id: PARITY_FIXTURE_ID,
				puppeteerInstance: browser,
			});
			const serial = await renderFrameMap(parity, 1);
			const concurrent = await renderFrameMap(parity, rendererConcurrency);

			expect(serial.size).toBe(parity.durationInFrames);
			expect(concurrent.size).toBe(parity.durationInFrames);

			for (let frame = 0; frame < parity.durationInFrames; frame++) {
				expect(
					pixelDifference(serial.get(frame)!, concurrent.get(frame)!),
					`parity frame ${frame} serial vs concurrent`,
				).toBe(0);
			}

			for (const frame of [84, 30, 9, 64, 10, 45, 29, 23, 16, 44, 0, 59, 15]) {
				const direct = await renderStill({
					serveUrl,
					composition: parity,
					frame,
					output: null,
					puppeteerInstance: browser,
					imageFormat: 'png',
					logLevel: 'warn',
				});

				expect(
					pixelDifference(concurrent.get(frame)!, direct.buffer!),
					`parity frame ${frame} concurrent vs direct`,
				).toBe(0);
			}
		},
		{timeout: 240000},
	);
});