🎥 Make videos programmatically with React
import type {
MediaParserAudioSample,
MediaParserVideoSample,
} from '@remotion/media-parser';
import {Log} from '../../log';
import type {MediaFn, MediaFnGeneratorInput} from '../media-fn';
const numberTo32BiIntLittleEndian = (num: number) => {
return new Uint8Array([
num & 0xff,
(num >> 8) & 0xff,
(num >> 16) & 0xff,
(num >> 24) & 0xff,
]);
};
const numberTo16BitLittleEndian = (num: number) => {
return new Uint8Array([num & 0xff, (num >> 8) & 0xff]);
};
const BIT_DEPTH = 16;
const BYTES_PER_SAMPLE = BIT_DEPTH / 8;
export const createWav = async ({
filename,
logLevel,
onBytesProgress,
onMillisecondsProgress,
writer,
progressTracker,
}: MediaFnGeneratorInput): Promise<MediaFn> => {
const w = await writer.createContent({
filename,
mimeType: 'audio/wav',
logLevel,
});
await w.write(new Uint8Array([0x52, 0x49, 0x46, 0x46])); // "RIFF"
const sizePosition = w.getWrittenByteCount();
await w.write(new Uint8Array([0x00, 0x00, 0x00, 0x00])); // Remaining size
await w.write(new Uint8Array([0x57, 0x41, 0x56, 0x45])); // "WAVE"
await w.write(new Uint8Array([0x66, 0x6d, 0x74, 0x20])); // "fmt "
await w.write(new Uint8Array([0x10, 0x00, 0x00, 0x00])); // fmt chunk size = 16
await w.write(new Uint8Array([0x01, 0x00])); // Audio format (PCM) = 1, set 3 if float32 would be true
const channelNumPosition = w.getWrittenByteCount();
await w.write(new Uint8Array([0x01, 0x00])); // Number of channels = 1
const sampleRatePosition = w.getWrittenByteCount();
await w.write(new Uint8Array([0x0, 0x0, 0x00, 0x00])); // Sample rate
const byteRatePosition = w.getWrittenByteCount();
await w.write(new Uint8Array([0x0, 0x0, 0x00, 0x00])); // Byte rate
const blockAlignPosition = w.getWrittenByteCount();
await w.write(new Uint8Array([0x00, 0x00])); // Block align
await w.write(numberTo16BitLittleEndian(BIT_DEPTH)); // Bits per sample
await w.write(new Uint8Array([0x64, 0x61, 0x74, 0x61])); // "data"
const dataSizePosition = w.getWrittenByteCount();
await w.write(new Uint8Array([0x00, 0x00, 0x00, 0x00])); // Remaining size
const operationProm = {current: Promise.resolve()};
const updateSize = async () => {
const size = w.getWrittenByteCount() - sizePosition - 4;
await w.updateDataAt(sizePosition, numberTo32BiIntLittleEndian(size));
const dataSize = w.getWrittenByteCount() - dataSizePosition - 4;
await w.updateDataAt(
dataSizePosition,
numberTo32BiIntLittleEndian(dataSize),
);
};
const updateChannelNum = async (numberOfChannels: number) => {
await w.updateDataAt(
channelNumPosition,
new Uint8Array([numberOfChannels, 0x00]),
);
};
const updateSampleRate = async (sampleRate: number) => {
await w.updateDataAt(
sampleRatePosition,
numberTo32BiIntLittleEndian(sampleRate),
);
};
const updateByteRate = async ({
sampleRate,
numberOfChannels,
}: {
sampleRate: number;
numberOfChannels: number;
}) => {
await w.updateDataAt(
byteRatePosition,
numberTo32BiIntLittleEndian(
sampleRate * numberOfChannels + BYTES_PER_SAMPLE,
),
);
};
const updateBlockAlign = async (numberOfChannels: number) => {
await w.updateDataAt(
blockAlignPosition,
new Uint8Array(
numberTo16BitLittleEndian(numberOfChannels * BYTES_PER_SAMPLE),
),
);
};
const addSample = async (
chunk: MediaParserAudioSample | MediaParserVideoSample,
) => {
Log.trace(logLevel, 'Adding sample', chunk);
await w.write(chunk.data);
onMillisecondsProgress((chunk.timestamp + (chunk.duration ?? 0)) / 1000);
onBytesProgress(w.getWrittenByteCount());
};
const waitForFinishPromises: (() => Promise<void>)[] = [];
return {
getBlob: () => {
return w.getBlob();
},
remove: () => {
return w.remove();
},
addSample: ({chunk, trackNumber}) => {
if (trackNumber !== 1) {
throw new Error('Only one track supported for WAV');
}
operationProm.current = operationProm.current.then(() =>
addSample(chunk),
);
progressTracker.updateTrackProgress(trackNumber, chunk.timestamp);
return operationProm.current;
},
updateTrackSampleRate: () => {
throw new Error(
'updateTrackSampleRate() not implemented for WAV encoder',
);
},
addWaitForFinishPromise: (promise) => {
waitForFinishPromises.push(promise);
},
async waitForFinish() {
Log.verbose(
logLevel,
'All write operations queued. Waiting for finish...',
);
await Promise.all(waitForFinishPromises.map((p) => p()));
await operationProm.current;
await updateSize();
await w.finish();
},
addTrack: async (track) => {
if (track.type !== 'audio') {
throw new Error('Only audio tracks supported for WAV');
}
await updateChannelNum(track.numberOfChannels);
await updateSampleRate(track.sampleRate);
await updateByteRate({
sampleRate: track.sampleRate,
numberOfChannels: track.numberOfChannels,
});
await updateBlockAlign(track.numberOfChannels);
progressTracker.registerTrack(1);
return Promise.resolve({trackNumber: 1});
},
};
};