🎥 Make videos programmatically with React
var __commonJS = (cb, mod) => () => (
mod || cb((mod = {exports: {}}).exports, mod), mod.exports
);
// ../renderer/dist/codec.js
var require_codec = __commonJS((exports) => {
Object.defineProperty(exports, '__esModule', {value: true});
exports.DEFAULT_CODEC = exports.validCodecs = undefined;
exports.validCodecs = [
'h264',
'h265',
'vp8',
'vp9',
'mp3',
'aac',
'wav',
'prores',
'h264-mkv',
'h264-ts',
'gif',
];
exports.DEFAULT_CODEC = 'h264';
});
// ../renderer/dist/file-extensions.js
var require_file_extensions = __commonJS((exports) => {
Object.defineProperty(exports, '__esModule', {value: true});
exports.defaultFileExtensionMap = undefined;
exports.defaultFileExtensionMap = {
'h264-mkv': {
default: 'mkv',
forAudioCodec: {
'pcm-16': {possible: ['mkv'], default: 'mkv'},
mp3: {possible: ['mkv'], default: 'mkv'},
},
},
'h264-ts': {
default: 'ts',
forAudioCodec: {
'pcm-16': {possible: ['ts'], default: 'ts'},
aac: {possible: ['ts'], default: 'ts'},
},
},
aac: {
default: 'aac',
forAudioCodec: {
aac: {
possible: ['aac', '3gp', 'm4a', 'm4b', 'mpg', 'mpeg'],
default: 'aac',
},
'pcm-16': {
possible: ['wav'],
default: 'wav',
},
},
},
gif: {
default: 'gif',
forAudioCodec: {},
},
h264: {
default: 'mp4',
forAudioCodec: {
'pcm-16': {possible: ['mkv', 'mov'], default: 'mkv'},
aac: {possible: ['mp4', 'mkv', 'mov'], default: 'mp4'},
mp3: {possible: ['mp4', 'mkv', 'mov'], default: 'mp4'},
},
},
h265: {
default: 'mp4',
forAudioCodec: {
aac: {possible: ['mp4', 'mkv', 'hevc'], default: 'mp4'},
'pcm-16': {possible: ['mkv'], default: 'mkv'},
},
},
mp3: {
default: 'mp3',
forAudioCodec: {
mp3: {possible: ['mp3'], default: 'mp3'},
'pcm-16': {possible: ['wav'], default: 'wav'},
},
},
prores: {
default: 'mov',
forAudioCodec: {
aac: {possible: ['mov', 'mkv', 'mxf'], default: 'mov'},
'pcm-16': {possible: ['mov', 'mkv', 'mxf'], default: 'mov'},
},
},
vp8: {
default: 'webm',
forAudioCodec: {
'pcm-16': {possible: ['mkv'], default: 'mkv'},
opus: {possible: ['webm'], default: 'webm'},
},
},
vp9: {
default: 'webm',
forAudioCodec: {
'pcm-16': {possible: ['mkv'], default: 'mkv'},
opus: {possible: ['webm'], default: 'webm'},
},
},
wav: {
default: 'wav',
forAudioCodec: {
'pcm-16': {possible: ['wav'], default: 'wav'},
},
},
};
});
// ../renderer/dist/get-extension-from-codec.js
var require_get_extension_from_codec = __commonJS((exports) => {
Object.defineProperty(exports, '__esModule', {value: true});
exports.defaultCodecsForFileExtension =
exports.makeFileExtensionMap =
exports.getFileExtensionFromCodec =
undefined;
var codec_1 = require_codec();
var file_extensions_1 = require_file_extensions();
var getFileExtensionFromCodec = (codec, audioCodec) => {
if (!codec_1.validCodecs.includes(codec)) {
throw new Error(
`Codec must be one of the following: ${codec_1.validCodecs.join(', ')}, but got ${codec}`,
);
}
const map = file_extensions_1.defaultFileExtensionMap[codec];
if (audioCodec === null) {
return map.default;
}
const typedAudioCodec = audioCodec;
if (!(typedAudioCodec in map.forAudioCodec)) {
throw new Error(
`Audio codec ${typedAudioCodec} is not supported for codec ${codec}`,
);
}
return map.forAudioCodec[audioCodec].default;
};
exports.getFileExtensionFromCodec = getFileExtensionFromCodec;
var makeFileExtensionMap = () => {
const map = {};
Object.keys(file_extensions_1.defaultFileExtensionMap).forEach((_codec) => {
const codec = _codec;
const fileExtMap = file_extensions_1.defaultFileExtensionMap[codec];
const audioCodecs = Object.keys(fileExtMap.forAudioCodec);
const possibleExtensionsForAudioCodec = audioCodecs.map(
(audioCodec) => fileExtMap.forAudioCodec[audioCodec].possible,
);
const allPossibleExtensions = [
fileExtMap.default,
...possibleExtensionsForAudioCodec.flat(1),
];
for (const extension of allPossibleExtensions) {
if (!map[extension]) {
map[extension] = [];
}
if (!map[extension].includes(codec)) {
map[extension].push(codec);
}
}
});
return map;
};
exports.makeFileExtensionMap = makeFileExtensionMap;
exports.defaultCodecsForFileExtension = {
'3gp': 'aac',
aac: 'aac',
gif: 'gif',
hevc: 'h265',
m4a: 'aac',
m4b: 'aac',
mkv: 'h264-mkv',
mov: 'prores',
mp3: 'mp3',
mp4: 'h264',
mpeg: 'aac',
mpg: 'aac',
mxf: 'prores',
wav: 'wav',
webm: 'vp8',
ts: 'h264-ts',
};
});
// ../renderer/dist/path-normalize.js
var require_path_normalize = __commonJS((exports) => {
Object.defineProperty(exports, '__esModule', {value: true});
exports.pathNormalize = undefined;
var SLASH = 47;
var DOT = 46;
var assertPath = (path) => {
const t = typeof path;
if (t !== 'string') {
throw new TypeError(`Expected a string, got a ${t}`);
}
};
var posixNormalize = (path, allowAboveRoot) => {
let res = '';
let lastSegmentLength = 0;
let lastSlash = -1;
let dots = 0;
let code;
for (let i = 0; i <= path.length; ++i) {
if (i < path.length) {
code = path.charCodeAt(i);
} else if (code === SLASH) {
break;
} else {
code = SLASH;
}
if (code === SLASH) {
if (lastSlash === i - 1 || dots === 1) {
} else if (lastSlash !== i - 1 && dots === 2) {
if (
res.length < 2 ||
lastSegmentLength !== 2 ||
res.charCodeAt(res.length - 1) !== DOT ||
res.charCodeAt(res.length - 2) !== DOT
) {
if (res.length > 2) {
const lastSlashIndex = res.lastIndexOf('/');
if (lastSlashIndex !== res.length - 1) {
if (lastSlashIndex === -1) {
res = '';
lastSegmentLength = 0;
} else {
res = res.slice(0, lastSlashIndex);
lastSegmentLength = res.length - 1 - res.lastIndexOf('/');
}
lastSlash = i;
dots = 0;
continue;
}
} else if (res.length === 2 || res.length === 1) {
res = '';
lastSegmentLength = 0;
lastSlash = i;
dots = 0;
continue;
}
}
if (allowAboveRoot) {
if (res.length > 0) {
res += '/..';
} else {
res = '..';
}
lastSegmentLength = 2;
}
} else {
if (res.length > 0) {
res += '/' + path.slice(lastSlash + 1, i);
} else {
res = path.slice(lastSlash + 1, i);
}
lastSegmentLength = i - lastSlash - 1;
}
lastSlash = i;
dots = 0;
} else if (code === DOT && dots !== -1) {
++dots;
} else {
dots = -1;
}
}
return res;
};
var decode = (s) => {
try {
return decodeURIComponent(s);
} catch (_a) {
return s;
}
};
var pathNormalize = (p) => {
assertPath(p);
let path = p;
if (path.length === 0) {
return '.';
}
const isAbsolute = path.charCodeAt(0) === SLASH;
const trailingSeparator = path.charCodeAt(path.length - 1) === SLASH;
path = decode(path);
path = posixNormalize(path, !isAbsolute);
if (path.length === 0 && !isAbsolute) {
path = '.';
}
if (path.length > 0 && trailingSeparator) {
path += '/';
}
if (isAbsolute) {
return '/' + path;
}
return path;
};
exports.pathNormalize = pathNormalize;
});
// ../renderer/dist/get-extension-of-filename.js
var require_get_extension_of_filename = __commonJS((exports) => {
Object.defineProperty(exports, '__esModule', {value: true});
exports.getExtensionOfFilename = undefined;
var path_normalize_1 = require_path_normalize();
var getExtensionOfFilename = (filename) => {
if (filename === null) {
return null;
}
const filenameArr = (0, path_normalize_1.pathNormalize)(filename).split(
'.',
);
const hasExtension = filenameArr.length >= 2;
const filenameArrLength = filenameArr.length;
const extension = hasExtension ? filenameArr[filenameArrLength - 1] : null;
return extension;
};
exports.getExtensionOfFilename = getExtensionOfFilename;
});
// ../renderer/dist/options/separate-audio.js
var require_separate_audio = __commonJS((exports) => {
Object.defineProperty(exports, '__esModule', {value: true});
exports.separateAudioOption = undefined;
var DEFAULT = null;
var cliFlag = 'separate-audio-to';
exports.separateAudioOption = {
cliFlag,
description: () =>
`If set, the audio will not be included in the main output but rendered as a separate file at the location you pass. It is recommended to use an absolute path. If a relative path is passed, it is relative to the Remotion Root.`,
docLink: 'https://remotion.dev/docs/renderer/render-media',
getValue: ({commandLine}) => {
if (commandLine[cliFlag]) {
return {
source: 'cli',
value: commandLine[cliFlag],
};
}
return {
source: 'default',
value: DEFAULT,
};
},
name: 'Separate audio to',
setConfig: () => {
throw new Error('Not implemented');
},
ssrName: 'separateAudioTo',
type: 'string',
};
});
// ../renderer/dist/options/audio-codec.js
var require_audio_codec = __commonJS((exports) => {
Object.defineProperty(exports, '__esModule', {value: true});
exports.audioCodecOption =
exports.getDefaultAudioCodec =
exports.resolveAudioCodec =
exports.getExtensionFromAudioCodec =
exports.defaultAudioCodecs =
exports.mapAudioCodecToFfmpegAudioCodecName =
exports.supportedAudioCodecs =
exports.isAudioCodec =
exports.validAudioCodecs =
undefined;
var separate_audio_1 = require_separate_audio();
exports.validAudioCodecs = ['pcm-16', 'aac', 'mp3', 'opus'];
var isAudioCodec = (codec) => {
return codec === 'mp3' || codec === 'aac' || codec === 'wav';
};
exports.isAudioCodec = isAudioCodec;
exports.supportedAudioCodecs = {
h264: ['aac', 'pcm-16', 'mp3'],
'h264-mkv': ['pcm-16', 'mp3'],
'h264-ts': ['pcm-16', 'aac'],
aac: ['aac', 'pcm-16'],
avi: [],
gif: [],
h265: ['aac', 'pcm-16'],
mp3: ['mp3', 'pcm-16'],
prores: ['aac', 'pcm-16'],
vp8: ['opus', 'pcm-16'],
vp9: ['opus', 'pcm-16'],
wav: ['pcm-16'],
};
var _satisfies = exports.supportedAudioCodecs;
if (_satisfies) {
}
var mapAudioCodecToFfmpegAudioCodecName = (audioCodec) => {
if (audioCodec === 'aac') {
return 'libfdk_aac';
}
if (audioCodec === 'mp3') {
return 'libmp3lame';
}
if (audioCodec === 'opus') {
return 'libopus';
}
if (audioCodec === 'pcm-16') {
return 'pcm_s16le';
}
throw new Error('unknown audio codec: ' + audioCodec);
};
exports.mapAudioCodecToFfmpegAudioCodecName =
mapAudioCodecToFfmpegAudioCodecName;
var cliFlag = 'audio-codec';
var ssrName = 'audioCodec';
exports.defaultAudioCodecs = {
'h264-mkv': {
lossless: 'pcm-16',
compressed: 'pcm-16',
},
'h264-ts': {
lossless: 'pcm-16',
compressed: 'aac',
},
aac: {
lossless: 'pcm-16',
compressed: 'aac',
},
gif: {
lossless: null,
compressed: null,
},
h264: {
lossless: 'pcm-16',
compressed: 'aac',
},
h265: {
lossless: 'pcm-16',
compressed: 'aac',
},
mp3: {
lossless: 'pcm-16',
compressed: 'mp3',
},
prores: {
lossless: 'pcm-16',
compressed: 'pcm-16',
},
vp8: {
lossless: 'pcm-16',
compressed: 'opus',
},
vp9: {
lossless: 'pcm-16',
compressed: 'opus',
},
wav: {
lossless: 'pcm-16',
compressed: 'pcm-16',
},
};
var extensionMap = {
aac: 'aac',
mp3: 'mp3',
opus: 'opus',
'pcm-16': 'wav',
};
var getExtensionFromAudioCodec = (audioCodec) => {
if (extensionMap[audioCodec]) {
return extensionMap[audioCodec];
}
throw new Error(`Unsupported audio codec: ${audioCodec}`);
};
exports.getExtensionFromAudioCodec = getExtensionFromAudioCodec;
var resolveAudioCodec = ({
codec,
setting,
preferLossless,
separateAudioTo,
}) => {
let derivedFromSeparateAudioToExtension = null;
if (separateAudioTo) {
const extension = separateAudioTo.split('.').pop();
for (const [key, value] of Object.entries(extensionMap)) {
if (value === extension) {
derivedFromSeparateAudioToExtension = key;
if (
!exports.supportedAudioCodecs[codec].includes(
derivedFromSeparateAudioToExtension,
) &&
derivedFromSeparateAudioToExtension
) {
throw new Error(
`The codec is ${codec} but the audio codec derived from --${separate_audio_1.separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}. The only supported codecs are: ${exports.supportedAudioCodecs[codec].join(', ')}`,
);
}
}
}
}
if (preferLossless) {
const selected = (0, exports.getDefaultAudioCodec)({
codec,
preferLossless,
});
if (
derivedFromSeparateAudioToExtension &&
selected !== derivedFromSeparateAudioToExtension
) {
throw new Error(
`The audio codec derived from --${separate_audio_1.separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}, but does not match the audio codec derived from the "Prefer lossless" option (${selected}). Remove any conflicting options.`,
);
}
return selected;
}
if (setting === null) {
if (derivedFromSeparateAudioToExtension) {
return derivedFromSeparateAudioToExtension;
}
return (0, exports.getDefaultAudioCodec)({codec, preferLossless});
}
if (
derivedFromSeparateAudioToExtension !== setting &&
derivedFromSeparateAudioToExtension
) {
throw new Error(
`The audio codec derived from --${separate_audio_1.separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}, but does not match the audio codec derived from your ${exports.audioCodecOption.name} setting (${setting}). Remove any conflicting options.`,
);
}
return setting;
};
exports.resolveAudioCodec = resolveAudioCodec;
var getDefaultAudioCodec = ({codec, preferLossless}) => {
return exports.defaultAudioCodecs[codec][
preferLossless ? 'lossless' : 'compressed'
];
};
exports.getDefaultAudioCodec = getDefaultAudioCodec;
var _audioCodec = null;
exports.audioCodecOption = {
cliFlag,
setConfig: (audioCodec) => {
if (audioCodec === null) {
_audioCodec = null;
return;
}
if (!exports.validAudioCodecs.includes(audioCodec)) {
throw new Error(
`Audio codec must be one of the following: ${exports.validAudioCodecs.join(', ')}, but got ${audioCodec}`,
);
}
_audioCodec = audioCodec;
},
getValue: ({commandLine}) => {
if (commandLine[cliFlag]) {
const codec = commandLine[cliFlag];
if (!exports.validAudioCodecs.includes(commandLine[cliFlag])) {
throw new Error(
`Audio codec must be one of the following: ${exports.validAudioCodecs.join(', ')}, but got ${codec}`,
);
}
return {
source: 'cli',
value: commandLine[cliFlag],
};
}
if (_audioCodec !== null) {
return {
source: 'config',
value: _audioCodec,
};
}
return {
source: 'default',
value: null,
};
},
description: () =>
`Set the format of the audio that is embedded in the video. Not all codec and audio codec combinations are supported and certain combinations require a certain file extension and container format. See the table in the docs to see possible combinations.`,
docLink: 'https://www.remotion.dev/docs/encoding/#audio-codec',
name: 'Audio Codec',
ssrName,
type: 'aac',
};
});
// ../renderer/dist/validate-output-filename.js
var require_validate_output_filename = __commonJS((exports) => {
Object.defineProperty(exports, '__esModule', {value: true});
exports.validateOutputFilename = undefined;
var file_extensions_1 = require_file_extensions();
var audio_codec_1 = require_audio_codec();
var validateOutputFilename = ({
codec,
audioCodecSetting,
extension,
preferLossless,
separateAudioTo,
}) => {
if (!file_extensions_1.defaultFileExtensionMap[codec]) {
throw new TypeError(
`The codec "${codec}" is not supported. Supported codecs are: ${Object.keys(file_extensions_1.defaultFileExtensionMap).join(', ')}`,
);
}
const map = file_extensions_1.defaultFileExtensionMap[codec];
const resolvedAudioCodec = (0, audio_codec_1.resolveAudioCodec)({
codec,
preferLossless,
setting: audioCodecSetting,
separateAudioTo,
});
if (resolvedAudioCodec === null) {
if (extension !== map.default) {
throw new TypeError(
`When using the ${codec} codec, the output filename must end in .${map.default}.`,
);
}
return;
}
if (!(resolvedAudioCodec in map.forAudioCodec)) {
throw new Error(
`Audio codec ${resolvedAudioCodec} is not supported for codec ${codec}`,
);
}
const acceptableExtensions = map.forAudioCodec[resolvedAudioCodec].possible;
if (!acceptableExtensions.includes(extension) && !separateAudioTo) {
throw new TypeError(
`When using the ${codec} codec with the ${resolvedAudioCodec} audio codec, the output filename must end in one of the following: ${acceptableExtensions.join(', ')}.`,
);
}
};
exports.validateOutputFilename = validateOutputFilename;
});
// ../renderer/dist/pure.js
var require_pure = __commonJS((exports) => {
Object.defineProperty(exports, '__esModule', {value: true});
exports.NoReactAPIs = undefined;
var get_extension_from_codec_1 = require_get_extension_from_codec();
var get_extension_of_filename_1 = require_get_extension_of_filename();
var validate_output_filename_1 = require_validate_output_filename();
exports.NoReactAPIs = {
getExtensionOfFilename: get_extension_of_filename_1.getExtensionOfFilename,
getFileExtensionFromCodec:
get_extension_from_codec_1.getFileExtensionFromCodec,
validateOutputFilename: validate_output_filename_1.validateOutputFilename,
};
});
export default require_pure();