🎥 Make videos programmatically with React
import {expect, test} from 'bun:test';
import {exampleVideos} from '@remotion/example-videos';
import {WAVE_SAMPLES_PER_SECOND} from '../containers/wav/get-seeking-byte';
import {parseMedia} from '../parse-media';
import {nodeReader} from '../readers/from-node';
import {WEBCODECS_TIMESCALE} from '../webcodecs-timescale';
test('parse full wav', async () => {
const {
tracks,
audioCodec,
container,
dimensions,
durationInSeconds,
fps,
images,
internalStats,
isHdr,
keyframes,
location,
metadata,
mimeType,
name,
rotation,
size,
slowDurationInSeconds,
slowFps,
slowKeyframes,
slowNumberOfFrames,
slowStructure,
unrotatedDimensions,
videoCodec,
numberOfAudioChannels,
sampleRate,
} = await parseMedia({
src: exampleVideos.chirp,
reader: nodeReader,
acknowledgeRemotionLicense: true,
fields: {
tracks: true,
audioCodec: true,
container: true,
dimensions: true,
durationInSeconds: true,
fps: true,
images: true,
internalStats: true,
isHdr: true,
keyframes: true,
rotation: true,
location: true,
metadata: true,
mimeType: true,
name: true,
size: true,
slowDurationInSeconds: true,
slowFps: true,
slowKeyframes: true,
slowNumberOfFrames: true,
slowStructure: true,
unrotatedDimensions: true,
videoCodec: true,
sampleRate: true,
numberOfAudioChannels: true,
},
});
expect(dimensions).toBe(null);
expect(container).toBe('wav');
expect(audioCodec).toBe('pcm-s16');
expect(tracks).toEqual([
{
startInSeconds: 0,
codec: 'pcm-s16',
codecData: null,
codecEnum: 'pcm-s16',
description: undefined,
numberOfChannels: 1,
sampleRate: 44100,
originalTimescale: 1000000,
trackId: 0,
type: 'audio',
timescale: WEBCODECS_TIMESCALE,
trackMediaTimeOffsetInTrackTimescale: 0,
},
]);
expect(durationInSeconds).toBe(30);
expect(fps).toBe(null);
expect(images).toEqual([]);
expect(internalStats).toEqual({
finalCursorOffset: 2646150,
skippedBytes: 0,
});
expect(isHdr).toBe(false);
expect(keyframes).toEqual(null);
expect(location).toBe(null);
expect(metadata).toEqual([
{
key: 'ISFT',
trackId: null,
value: 'Lavf60.16.100 (libsndfile-1.0.31)',
},
]);
expect(mimeType).toBe(null);
expect(name).toBe('chirp.wav');
expect(rotation).toBe(0);
expect(size).toBe(2646150);
expect(slowDurationInSeconds).toBe(30);
expect(slowFps).toBe(0);
expect(slowKeyframes).toEqual([]);
expect(slowNumberOfFrames).toBe(0);
expect(slowStructure).toEqual({
boxes: [
{
fileSize: 2646142,
type: 'wav-header',
},
{
bitsPerSample: 16,
blockAlign: 2,
byteRate: 88200,
numberOfChannels: 1,
sampleRate: 44100,
type: 'wav-fmt',
},
{
dataSize: 2646000,
type: 'wav-data',
},
{
metadata: [
{
key: 'ISFT',
trackId: null,
value: 'Lavf60.16.100 (libsndfile-1.0.31)',
},
],
type: 'wav-list',
},
{
type: 'wav-id3',
},
],
type: 'wav',
});
expect(unrotatedDimensions).toBe(null);
expect(videoCodec).toBe(null);
expect(numberOfAudioChannels).toBe(1);
expect(sampleRate).toBe(44100);
});
test('should be fast to only get duration', async () => {
const {internalStats} = await parseMedia({
src: exampleVideos.chirp,
reader: nodeReader,
acknowledgeRemotionLicense: true,
fields: {
durationInSeconds: true,
internalStats: true,
container: true,
size: true,
name: true,
},
});
expect(internalStats).toEqual({
skippedBytes: 2646106,
finalCursorOffset: 2646044,
});
});
test('should get all samples', async () => {
let samples = 0;
const {internalStats} = await parseMedia({
src: exampleVideos.chirp,
reader: nodeReader,
acknowledgeRemotionLicense: true,
fields: {
internalStats: true,
container: true,
size: true,
name: true,
slowDurationInSeconds: true,
},
onAudioTrack: () => {
return (sample) => {
expect(
sample.decodingTimestamp % (1_000_000 / WAVE_SAMPLES_PER_SECOND),
).toBe(0);
expect(sample.timestamp % (1_000_000 / WAVE_SAMPLES_PER_SECOND)).toBe(
0,
);
samples++;
};
},
});
expect(samples).toBe(750);
expect(internalStats).toEqual({
skippedBytes: 0,
finalCursorOffset: 2646150,
});
});