🎥 Make videos programmatically with React
import {expect, test} from 'bun:test';
import type {InputAudioTrack, InputTrack} from 'mediabunny';
import {Mp3OutputFormat, Mp4OutputFormat} from 'mediabunny';
import {getSupportedConfigs} from '../app/components/get-supported-configs';
import {getAudioTranscodingOptions} from '../app/lib/can-transcode-or-copy';
const makeAudioTrack = (sampleRate: number) =>
({
codec: 'pcm-s16',
getCodec: () => Promise.resolve('pcm-s16'),
canDecode: () => Promise.resolve(true),
getSampleRate: () => Promise.resolve(sampleRate),
}) as unknown as InputAudioTrack;
test('allows MP3 encoding when Mediabunny can resample to default encoder params', async () => {
const options = await getAudioTranscodingOptions({
inputTrack: makeAudioTrack(96000),
outputContainer: new Mp3OutputFormat(),
sampleRate: null,
});
expect(options).toEqual([
{
type: 'reencode',
audioCodec: 'mp3',
sampleRate: null,
},
]);
});
test('does not use fallback encoder params for an explicit sample rate', async () => {
const options = await getAudioTranscodingOptions({
inputTrack: makeAudioTrack(96000),
outputContainer: new Mp3OutputFormat(),
sampleRate: 96000,
});
expect(options).toEqual([]);
});
test('registers extension-backed audio encoders for supported containers', async () => {
const options = await getAudioTranscodingOptions({
inputTrack: makeAudioTrack(48000),
outputContainer: new Mp4OutputFormat(),
sampleRate: null,
});
const codecs = options.map((option) => {
if (option.type !== 'reencode') {
throw new Error('Expected only re-encoding options');
}
return option.audioCodec;
});
expect(codecs).toContain('mp3');
expect(codecs).toContain('aac');
expect(codecs).toContain('flac');
expect(codecs).toContain('ac3');
expect(codecs).toContain('eac3');
expect(codecs).toContain('dts');
});
test('offers only drop for audio tracks with unknown codecs', async () => {
const configs = await getSupportedConfigs({
tracks: [
{
id: 0,
codec: null,
getCodec: () => Promise.resolve(null),
isAudioTrack: () => true,
isVideoTrack: () => false,
} as unknown as InputTrack,
],
container: new Mp4OutputFormat(),
action: {type: 'generic-convert'},
userRotation: 0,
resizeOperation: null,
sampleRate: null,
disableVideoCopy: false,
});
expect(configs.audioTrackOptions).toEqual([
{
trackId: 0,
audioCodec: null,
operations: [{type: 'drop'}],
},
]);
});
test('uses async codec resolution for audio copy checks', async () => {
const configs = await getSupportedConfigs({
tracks: [
{
id: 0,
get codec(): never {
throw new Error('Use getCodec() instead');
},
getCodec: () => Promise.resolve('aac'),
getSampleRate: () => Promise.resolve(48000),
canDecode: () => Promise.resolve(false),
isAudioTrack: () => true,
isVideoTrack: () => false,
} as unknown as InputTrack,
],
container: new Mp4OutputFormat(),
action: {type: 'generic-convert'},
userRotation: 0,
resizeOperation: null,
sampleRate: null,
disableVideoCopy: false,
});
expect(configs.audioTrackOptions).toEqual([
{
trackId: 0,
audioCodec: 'aac',
operations: [{type: 'copy'}, {type: 'drop'}],
},
]);
});