🎥 Make videos programmatically with React
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();
});