@remotion/renderer 4.0.357 → 4.0.358

package/package/dist/esm/pure.mjs

@@ -0,0 +1,526 @@
+// src/is-audio-codec.ts
+var isAudioCodec = (codec) => {
+  return codec === "mp3" || codec === "aac" || codec === "wav";
+};
+
+// src/codec-supports-media.ts
+var support = {
+  "h264-mkv": {
+    audio: true,
+    video: true
+  },
+  aac: {
+    audio: true,
+    video: false
+  },
+  gif: {
+    video: true,
+    audio: false
+  },
+  h264: {
+    video: true,
+    audio: true
+  },
+  "h264-ts": {
+    video: true,
+    audio: true
+  },
+  h265: {
+    video: true,
+    audio: true
+  },
+  mp3: {
+    audio: true,
+    video: false
+  },
+  prores: {
+    audio: true,
+    video: true
+  },
+  vp8: {
+    audio: true,
+    video: true
+  },
+  vp9: {
+    audio: true,
+    video: true
+  },
+  wav: {
+    audio: true,
+    video: false
+  }
+};
+var codecSupportsMedia = (codec) => {
+  return support[codec];
+};
+
+// src/get-duration-from-frame-range.ts
+var getFramesToRender = (frameRange, everyNthFrame) => {
+  if (everyNthFrame === 0) {
+    throw new Error("everyNthFrame cannot be 0");
+  }
+  return new Array(frameRange[1] - frameRange[0] + 1).fill(true).map((_, index) => {
+    return index + frameRange[0];
+  }).filter((index) => {
+    return index % everyNthFrame === 0;
+  });
+};
+
+// src/codec.ts
+var validCodecs = [
+  "h264",
+  "h265",
+  "vp8",
+  "vp9",
+  "mp3",
+  "aac",
+  "wav",
+  "prores",
+  "h264-mkv",
+  "h264-ts",
+  "gif"
+];
+
+// src/file-extensions.ts
+var 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" }
+    }
+  }
+};
+
+// src/get-extension-from-codec.ts
+var getFileExtensionFromCodec = (codec, audioCodec) => {
+  if (!validCodecs.includes(codec)) {
+    throw new Error(`Codec must be one of the following: ${validCodecs.join(", ")}, but got ${codec}`);
+  }
+  const map = 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;
+};
+
+// src/path-normalize.ts
+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 {
+    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;
+};
+
+// src/get-extension-of-filename.ts
+var getExtensionOfFilename = (filename) => {
+  if (filename === null) {
+    return null;
+  }
+  const filenameArr = pathNormalize(filename).split(".");
+  const hasExtension = filenameArr.length >= 2;
+  const filenameArrLength = filenameArr.length;
+  const extension = hasExtension ? filenameArr[filenameArrLength - 1] : null;
+  return extension;
+};
+
+// src/options/separate-audio.tsx
+var DEFAULT = null;
+var cliFlag = "separate-audio-to";
+var 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"
+};
+
+// src/options/audio-codec.tsx
+var validAudioCodecs = ["pcm-16", "aac", "mp3", "opus"];
+var 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 = supportedAudioCodecs;
+if (_satisfies) {}
+var cliFlag2 = "audio-codec";
+var ssrName = "audioCodec";
+var 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 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 (!supportedAudioCodecs[codec].includes(derivedFromSeparateAudioToExtension) && derivedFromSeparateAudioToExtension) {
+          throw new Error(`The codec is ${codec} but the audio codec derived from --${separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}. The only supported codecs are: ${supportedAudioCodecs[codec].join(", ")}`);
+        }
+      }
+    }
+  }
+  if (preferLossless) {
+    const selected = getDefaultAudioCodec({ codec, preferLossless });
+    if (derivedFromSeparateAudioToExtension && selected !== derivedFromSeparateAudioToExtension) {
+      throw new Error(`The audio codec derived from --${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 getDefaultAudioCodec({ codec, preferLossless });
+  }
+  if (derivedFromSeparateAudioToExtension !== setting && derivedFromSeparateAudioToExtension) {
+    throw new Error(`The audio codec derived from --${separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}, but does not match the audio codec derived from your ${audioCodecOption.name} setting (${setting}). Remove any conflicting options.`);
+  }
+  return setting;
+};
+var getDefaultAudioCodec = ({
+  codec,
+  preferLossless
+}) => {
+  return defaultAudioCodecs[codec][preferLossless ? "lossless" : "compressed"];
+};
+var _audioCodec = null;
+var audioCodecOption = {
+  cliFlag: cliFlag2,
+  setConfig: (audioCodec) => {
+    if (audioCodec === null) {
+      _audioCodec = null;
+      return;
+    }
+    if (!validAudioCodecs.includes(audioCodec)) {
+      throw new Error(`Audio codec must be one of the following: ${validAudioCodecs.join(", ")}, but got ${audioCodec}`);
+    }
+    _audioCodec = audioCodec;
+  },
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag2]) {
+      const codec = commandLine[cliFlag2];
+      if (!validAudioCodecs.includes(commandLine[cliFlag2])) {
+        throw new Error(`Audio codec must be one of the following: ${validAudioCodecs.join(", ")}, but got ${codec}`);
+      }
+      return {
+        source: "cli",
+        value: commandLine[cliFlag2]
+      };
+    }
+    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"
+};
+
+// src/validate-output-filename.ts
+var validateOutputFilename = ({
+  codec,
+  audioCodecSetting,
+  extension,
+  preferLossless,
+  separateAudioTo
+}) => {
+  if (!defaultFileExtensionMap[codec]) {
+    throw new TypeError(`The codec "${codec}" is not supported. Supported codecs are: ${Object.keys(defaultFileExtensionMap).join(", ")}`);
+  }
+  const map = defaultFileExtensionMap[codec];
+  const resolvedAudioCodec = 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(", ")}.`);
+  }
+};
+
+// src/pure.ts
+var NoReactAPIs = {
+  getExtensionOfFilename,
+  getFileExtensionFromCodec,
+  validateOutputFilename,
+  getFramesToRender,
+  codecSupportsMedia,
+  isAudioCodec
+};
+export {
+  NoReactAPIs
+};

package/package/dist/extract-audio.d.ts

@@ -0,0 +1,7 @@
+import type { LogLevel } from './log-level';
+export declare const extractAudio: (options: {
+    videoSource: string;
+    audioOutput: string;
+    logLevel?: LogLevel;
+    binariesDirectory?: string | null;
+}) => Promise<void>;

package/package/dist/extract-audio.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractAudio = void 0;
+const compositor_1 = require("./compositor/compositor");
+/*
+ * @description Extracts the audio from a video source and saves it to the specified output path. It does not convert the audio to a different format.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/extract-audio)
+ */
+const extractAudio = async (options) => {
+    var _a, _b;
+    const compositor = (0, compositor_1.startLongRunningCompositor)({
+        maximumFrameCacheItemsInBytes: null,
+        logLevel: (_a = options === null || options === void 0 ? void 0 : options.logLevel) !== null && _a !== void 0 ? _a : 'info',
+        indent: false,
+        binariesDirectory: (_b = options.binariesDirectory) !== null && _b !== void 0 ? _b : null,
+        extraThreads: 0,
+    });
+    await compositor.executeCommand('ExtractAudio', {
+        input_path: options.videoSource,
+        output_path: options.audioOutput,
+    });
+    await compositor.finishCommands();
+    await compositor.waitForDone();
+};
+exports.extractAudio = extractAudio;

package/package/dist/ffmpeg-args.d.ts

@@ -0,0 +1,21 @@
+import type { HardwareAccelerationOption } from './client';
+import type { Codec } from './codec';
+import type { LogLevel } from './log-level';
+import { type ColorSpace } from './options/color-space';
+import type { X264Preset } from './options/x264-preset';
+import type { PixelFormat } from './pixel-format';
+export declare const generateFfmpegArgs: ({ hasPreencoded, proResProfileName, pixelFormat, x264Preset, codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, colorSpace, hardwareAcceleration, indent, logLevel, }: {
+    hasPreencoded: boolean;
+    proResProfileName: string | null;
+    pixelFormat: PixelFormat;
+    x264Preset: X264Preset | null;
+    crf: unknown;
+    codec: Codec;
+    videoBitrate: string | null;
+    encodingMaxRate: string | null;
+    encodingBufferSize: string | null;
+    colorSpace: ColorSpace | null;
+    hardwareAcceleration: HardwareAccelerationOption;
+    indent: boolean;
+    logLevel: LogLevel;
+}) => string[][];

package/package/dist/ffmpeg-args.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFfmpegArgs = void 0;
+const crf_1 = require("./crf");
+const get_codec_name_1 = require("./get-codec-name");
+const logger_1 = require("./logger");
+const color_space_1 = require("./options/color-space");
+const truthy_1 = require("./truthy");
+const firstEncodingStepOnly = ({ hasPreencoded, proResProfileName, pixelFormat, x264Preset, codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, hardwareAcceleration, }) => {
+    if (hasPreencoded || codec === 'gif') {
+        return [];
+    }
+    return [
+        proResProfileName ? ['-profile:v', proResProfileName] : null,
+        ['-pix_fmt', pixelFormat],
+        // Without explicitly disabling auto-alt-ref,
+        // transparent WebM generation doesn't work
+        pixelFormat === 'yuva420p' ? ['-auto-alt-ref', '0'] : null,
+        x264Preset ? ['-preset', x264Preset] : null,
+        (0, crf_1.validateQualitySettings)({
+            crf,
+            videoBitrate,
+            codec,
+            encodingMaxRate,
+            encodingBufferSize,
+            hardwareAcceleration,
+        }),
+    ].filter(truthy_1.truthy);
+};
+const generateFfmpegArgs = ({ hasPreencoded, proResProfileName, pixelFormat, x264Preset, codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, colorSpace, hardwareAcceleration, indent, logLevel, }) => {
+    const encoderSettings = (0, get_codec_name_1.getCodecName)({
+        codec,
+        encodingMaxRate,
+        encodingBufferSize,
+        crf,
+        hardwareAcceleration,
+        indent,
+        logLevel,
+    });
+    if (encoderSettings === null) {
+        throw new TypeError(`encoderSettings is null: ${JSON.stringify(codec)} (hwaccel = ${hardwareAcceleration})`);
+    }
+    const { encoderName, hardwareAccelerated } = encoderSettings;
+    if (!hardwareAccelerated && hardwareAcceleration === 'required') {
+        throw new Error(`Codec ${codec} does not support hardware acceleration on ${process.platform}, but "hardwareAcceleration" is set to "required"`);
+    }
+    logger_1.Log.verbose({ indent, logLevel, tag: 'stitchFramesToVideo()' }, `Encoder: ${encoderName}, hardware accelerated: ${hardwareAccelerated}`);
+    const resolvedColorSpace = colorSpace !== null && colorSpace !== void 0 ? colorSpace : color_space_1.DEFAULT_COLOR_SPACE;
+    const colorSpaceOptions = resolvedColorSpace === 'bt709'
+        ? [
+            ['-colorspace:v', 'bt709'],
+            ['-color_primaries:v', 'bt709'],
+            ['-color_trc:v', 'bt709'],
+            ['-color_range', 'tv'],
+            hasPreencoded
+                ? []
+                : // https://www.canva.dev/blog/engineering/a-journey-through-colour-space-with-ffmpeg/
+                    // "Color range" section
+                    ['-vf', 'zscale=matrix=709:matrixin=709:range=limited'],
+        ]
+        : resolvedColorSpace === 'bt2020-ncl'
+            ? [
+                ['-colorspace:v', 'bt2020nc'],
+                ['-color_primaries:v', 'bt2020'],
+                ['-color_trc:v', 'arib-std-b67'],
+                ['-color_range', 'tv'],
+                hasPreencoded
+                    ? []
+                    : [
+                        '-vf',
+                        // ChatGPT: Therefore, just like BT.709, BT.2020 also uses the limited range where the digital code value for black is at 16,16,16 and not 0,0,0 in an 8-bit video system.
+                        'zscale=matrix=2020_ncl:matrixin=2020_ncl:range=limited',
+                    ],
+            ]
+            : [];
+    return [
+        ['-c:v', hasPreencoded ? 'copy' : encoderName],
+        codec === 'h264-ts' ? ['-f', 'mpegts'] : null,
+        // -c:v is the same as -vcodec as -codec:video
+        // and specified the video codec.
+        ...colorSpaceOptions,
+        ...firstEncodingStepOnly({
+            codec,
+            crf,
+            hasPreencoded,
+            pixelFormat,
+            proResProfileName,
+            videoBitrate,
+            encodingMaxRate,
+            encodingBufferSize,
+            x264Preset,
+            hardwareAcceleration,
+        }),
+    ].filter(truthy_1.truthy);
+};
+exports.generateFfmpegArgs = generateFfmpegArgs;

package/package/dist/ffmpeg-filter-file.d.ts

@@ -0,0 +1,13 @@
+import type { DownloadMap } from './assets/download-map';
+import type { FilterWithoutPaddingApplied } from './stringify-ffmpeg-filter';
+export declare const makeFfmpegFilterFile: (complexFilter: FilterWithoutPaddingApplied, downloadMap: DownloadMap) => Promise<{
+    file: string;
+    cleanup: () => void;
+}> | {
+    file: null;
+    cleanup: () => undefined;
+};
+export declare const makeFfmpegFilterFileStr: (complexFilter: string, downloadMap: DownloadMap) => Promise<{
+    file: string;
+    cleanup: () => void;
+}>;