Skip to content

🎥 Make videos programmatically with React

6.1 KB
Raw Blame
import {assert, expect, test} from 'vitest';
import {
	getMaxVideoCacheSize,
	globalMediaCache,
	keyframeManager,
} from '../caches';
import {applyVolume} from '../convert-audiodata/apply-volume';
import {extractFrameAndAudio} from '../extract-frame-and-audio';

test('Should be able to extract a frame', async () => {
	keyframeManager.clearAll('info');

	const result = await extractFrameAndAudio({
		sampleRate: 48000,
		src: '/bigbuckbunny.mp4',
		timeInSeconds: 1,
		durationInSeconds: 1 / 30,
		playbackRate: 1,
		logLevel: 'info',
		includeAudio: true,
		includeVideo: true,
		loop: false,
		audioStreamIndex: 0,
		trimAfter: undefined,
		trimBefore: undefined,
		fps: 30,
		maxCacheSize: getMaxVideoCacheSize('info'),
		credentials: undefined,
		mediaCache: globalMediaCache,
	});

	if (result.type === 'cannot-decode') {
		throw new Error('Cannot decode');
	}

	if (result.type === 'cannot-decode-prores') {
		throw new Error('Cannot decode ProRes');
	}

	if (result.type === 'network-error') {
		throw new Error('Network error');
	}

	if (result.type === 'unknown-container-format') {
		throw new Error('Unknown container format');
	}

	if (result.type === 'cannot-decode-alpha') {
		throw new Error('Cannot decode alpha');
	}

	const {audio, frame} = result;
	assert(audio);
	assert(frame);

	// duration = 1 / 30
	// channels = 2
	// bits = 16
	// sampleRate = 48000
	// 1 / 30 * 2 * 2 * 48000 = 6400
	expect(audio.data.byteLength).toBe(6400);

	const cacheStats = keyframeManager.getCacheStats();
	expect(cacheStats.count).toBe(1);
	frame.close();
});

test('Should be able to extract the last frame', async () => {
	keyframeManager.clearAll('info');

	const result = await extractFrameAndAudio({
		sampleRate: 48000,
		src: '/bigbuckbunny.mp4',
		timeInSeconds: 1_000_000,
		durationInSeconds: 1 / 30,
		playbackRate: 1,
		logLevel: 'info',
		includeAudio: true,
		includeVideo: true,
		loop: false,
		audioStreamIndex: 0,
		trimAfter: undefined,
		trimBefore: undefined,
		fps: 30,
		maxCacheSize: getMaxVideoCacheSize('info'),
		credentials: undefined,
		mediaCache: globalMediaCache,
	});

	if (result.type === 'cannot-decode') {
		throw new Error('Cannot decode');
	}

	if (result.type === 'cannot-decode-prores') {
		throw new Error('Cannot decode ProRes');
	}

	if (result.type === 'network-error') {
		throw new Error('Network error');
	}

	if (result.type === 'unknown-container-format') {
		throw new Error('Unknown container format');
	}

	if (result.type === 'cannot-decode-alpha') {
		throw new Error('Cannot decode alpha');
	}

	const {audio, frame} = result;

	assert(frame);
	assert(!audio);

	const cacheStats = keyframeManager.getCacheStats();
	expect(cacheStats.count).toBe(1);
	frame.close();
});

test('Should manage the cache', async (t) => {
	if (t.task.file.projectName === 'webkit') {
		t.skip();
		return;
	}

	keyframeManager.clearAll('info');

	for (let i = 0; i < 50; i++) {
		const result = await extractFrameAndAudio({
			sampleRate: 48000,
			src: `/bigbuckbunny.mp4?i=${i}`,
			timeInSeconds: 1,
			durationInSeconds: 1 / 30,
			playbackRate: 1,
			logLevel: 'info',
			includeAudio: true,
			includeVideo: true,
			loop: false,
			audioStreamIndex: 0,
			trimAfter: undefined,
			trimBefore: undefined,
			fps: 30,
			maxCacheSize: getMaxVideoCacheSize('info'),
			credentials: undefined,
			mediaCache: globalMediaCache,
		});
		if (result.type === 'success') {
			result.frame?.close();
		}
	}

	const cacheStats = keyframeManager.getCacheStats();
	expect(cacheStats.count).toBe(50);
	if (t.task.file.projectName === 'firefox') {
		expect(cacheStats.totalSize).toBe(184320000);
	} else {
		expect(cacheStats.totalSize).toBe(69120000);
	}
});

test('Should be apply volume correctly', async () => {
	keyframeManager.clearAll('info');

	const result = await extractFrameAndAudio({
		sampleRate: 48000,
		src: '/bigbuckbunny.mp4',
		timeInSeconds: 1,
		durationInSeconds: 1 / 30,
		playbackRate: 1,
		logLevel: 'info',
		includeAudio: true,
		includeVideo: false,
		loop: false,
		audioStreamIndex: 0,
		trimAfter: undefined,
		trimBefore: undefined,
		fps: 30,
		maxCacheSize: getMaxVideoCacheSize('info'),
		credentials: undefined,
		mediaCache: globalMediaCache,
	});

	if (result.type === 'cannot-decode') {
		throw new Error('Cannot decode');
	}

	if (result.type === 'cannot-decode-prores') {
		throw new Error('Cannot decode ProRes');
	}

	if (result.type === 'network-error') {
		throw new Error('Network error');
	}

	if (result.type === 'unknown-container-format') {
		throw new Error('Unknown container format');
	}

	if (result.type === 'cannot-decode-alpha') {
		throw new Error('Cannot decode alpha');
	}

	const {audio: audioAtFullVolume, frame} = result;

	const totalAudioAtFullVolume = audioAtFullVolume?.data.reduce((acc, curr) => {
		const unrounded = curr * 0.5;
		const rounded = curr > 0 ? Math.floor(unrounded) : Math.ceil(unrounded);
		return acc + rounded;
	}, 0);
	applyVolume(audioAtFullVolume!.data, 0.5);

	assert(!frame);

	const totalAudioAtHalfVolume = audioAtFullVolume?.data.reduce(
		(acc, curr) => acc + curr,
		0,
	);
	assert(totalAudioAtFullVolume);
	expect(totalAudioAtHalfVolume).toBe(totalAudioAtFullVolume);
});

test('Should be able to loop', async () => {
	keyframeManager.clearAll('info');

	const result = await extractFrameAndAudio({
		sampleRate: 48000,
		src: `/bigbuckbunny.mp4`,
		timeInSeconds: 10000001,
		durationInSeconds: 1 / 30,
		logLevel: 'info',
		playbackRate: 1,
		includeAudio: true,
		includeVideo: true,
		loop: true,
		audioStreamIndex: 0,
		trimAfter: undefined,
		trimBefore: undefined,
		fps: 30,
		maxCacheSize: getMaxVideoCacheSize('info'),
		credentials: undefined,
		mediaCache: globalMediaCache,
	});

	if (result.type === 'cannot-decode') {
		throw new Error('Cannot decode');
	}

	if (result.type === 'cannot-decode-prores') {
		throw new Error('Cannot decode ProRes');
	}

	if (result.type === 'network-error') {
		throw new Error('Network error');
	}

	if (result.type === 'unknown-container-format') {
		throw new Error('Unknown container format');
	}

	if (result.type === 'cannot-decode-alpha') {
		throw new Error('Cannot decode alpha');
	}

	const {frame} = result;

	assert(frame);
	frame.close();
});