@twick/ffmpeg 0.14.22 → 0.15.0

package/dist/index.cjs

@@ -0,0 +1,888 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FFmpegExporterServer: () => FFmpegExporterServer,
+  VideoFrameExtractor: () => VideoFrameExtractor,
+  audioCodecs: () => audioCodecs,
+  checkForAudioStream: () => checkForAudioStream,
+  concatenateMedia: () => concatenateMedia,
+  createSilentAudioFile: () => createSilentAudioFile,
+  doesFileExist: () => doesFileExist,
+  extensions: () => extensions,
+  ffmpegSettings: () => ffmpegSettings,
+  generateAudio: () => generateAudio,
+  getSampleRate: () => getSampleRate,
+  getVideoCodec: () => getVideoCodec,
+  getVideoDimensions: () => getVideoDimensions,
+  getVideoDuration: () => getVideoDuration,
+  getVideoMetadata: () => getVideoMetadata,
+  makeSureFolderExists: () => makeSureFolderExists,
+  mergeAudioWithVideo: () => mergeAudioWithVideo,
+  mergeMedia: () => mergeMedia,
+  resolvePath: () => resolvePath
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/ffmpeg-exporter-server.ts
+var import_telemetry = require("@twick/telemetry");
+var import_fluent_ffmpeg = __toESM(require("fluent-ffmpeg"), 1);
+var os = __toESM(require("os"), 1);
+var path3 = __toESM(require("path"), 1);
+
+// src/image-stream.ts
+var import_stream = require("stream");
+var ImageStream = class extends import_stream.Readable {
+  constructor() {
+    super(...arguments);
+    this.image = null;
+    this.hasData = false;
+  }
+  pushImage(image) {
+    this.image = image;
+    this.hasData = true;
+    this._read();
+  }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  _read() {
+    if (this.hasData) {
+      this.hasData = false;
+      this.push(this.image);
+    }
+  }
+};
+
+// src/settings.ts
+var ffmpegInstaller = __toESM(require("@ffmpeg-installer/ffmpeg"), 1);
+var ffprobeInstaller = __toESM(require("@ffprobe-installer/ffprobe"), 1);
+var ffmpegLogLevels = [
+  "quiet",
+  "panic",
+  "fatal",
+  "error",
+  "warning",
+  "info",
+  "verbose",
+  "debug",
+  "trace"
+];
+var FfmpegSettingState = class {
+  constructor() {
+    this.ffmpegPath = ffmpegInstaller.path;
+    this.ffprobePath = ffprobeInstaller.path;
+    if (process.env.FFMPEG_PATH) {
+      this.ffmpegPath = process.env.FFMPEG_PATH;
+    }
+    if (process.env.FFPROBE_PATH) {
+      this.ffprobePath = process.env.FFPROBE_PATH;
+    }
+    this.logLevel = "error";
+    if (process.env.FFMPEG_LOG_LEVEL && ffmpegLogLevels.includes(process.env.FFMPEG_LOG_LEVEL)) {
+      this.logLevel = process.env.FFMPEG_LOG_LEVEL;
+    }
+  }
+  getFfmpegPath() {
+    return this.ffmpegPath;
+  }
+  setFfmpegPath(ffmpegPath) {
+    this.ffmpegPath = ffmpegPath;
+  }
+  getFfprobePath() {
+    return this.ffprobePath;
+  }
+  setFfprobePath(ffprobePath) {
+    this.ffprobePath = ffprobePath;
+  }
+  getLogLevel() {
+    return this.logLevel;
+  }
+  setLogLevel(logLevel) {
+    this.logLevel = logLevel;
+  }
+};
+var ffmpegSettings = new FfmpegSettingState();
+
+// src/ffmpeg-exporter-server.ts
+var pixelFormats = {
+  mp4: "yuv420p",
+  webm: "yuva420p",
+  proRes: "yuva444p10le"
+};
+var extensions = {
+  mp4: "mp4",
+  webm: "webm",
+  proRes: "mov"
+};
+var FFmpegExporterServer = class {
+  constructor(settings) {
+    if (settings.exporter.name !== "@twick/core/ffmpeg") {
+      throw new Error("Invalid exporter");
+    }
+    this.settings = settings;
+    this.format = settings.exporter.options.format;
+    this.jobFolder = path3.join(
+      os.tmpdir(),
+      `twick-${this.settings.name}-${settings.hiddenFolderId}`
+    );
+    this.stream = new ImageStream();
+    import_fluent_ffmpeg.default.setFfmpegPath(ffmpegSettings.getFfmpegPath());
+    this.command = (0, import_fluent_ffmpeg.default)();
+    this.command.input(this.stream).inputFormat("image2pipe").inputFps(settings.fps);
+    const size = {
+      x: Math.round(settings.size.x * settings.resolutionScale),
+      y: Math.round(settings.size.y * settings.resolutionScale)
+    };
+    this.command.output(path3.join(this.jobFolder, `visuals.${extensions[this.format]}`)).outputOptions([`-pix_fmt ${pixelFormats[this.format]}`, "-shortest"]).outputFps(settings.fps).size(`${size.x}x${size.y}`);
+    if (this.format === "proRes") {
+      this.command.outputOptions(["-c:v prores_ks", "-profile:v 4444"]);
+    }
+    this.command.outputOptions(["-movflags +faststart"]);
+    this.promise = new Promise((resolve, reject) => {
+      this.command.on("end", resolve).on("error", reject);
+    });
+  }
+  async start() {
+    this.command.run();
+  }
+  async handleFrame({ data }) {
+    const base64Data = data.slice(data.indexOf(",") + 1);
+    this.stream.pushImage(Buffer.from(base64Data, "base64"));
+  }
+  async end(result) {
+    this.stream.pushImage(null);
+    if (result === 1) {
+      try {
+        this.command.kill("SIGKILL");
+        await this.promise;
+      } catch (err) {
+        (0, import_telemetry.sendEvent)(import_telemetry.EventName.Error, { message: err.message });
+      }
+    } else {
+      await this.promise;
+    }
+  }
+  async kill() {
+    try {
+      this.command.kill("SIGKILL");
+      await this.promise;
+    } catch (_) {
+      return;
+    }
+  }
+};
+
+// src/generate-audio.ts
+var import_fluent_ffmpeg2 = __toESM(require("fluent-ffmpeg"), 1);
+var fs2 = __toESM(require("fs"), 1);
+var os3 = __toESM(require("os"), 1);
+var path5 = __toESM(require("path"), 1);
+
+// src/utils.ts
+var fs = __toESM(require("fs"), 1);
+var os2 = __toESM(require("os"), 1);
+var path4 = __toESM(require("path"), 1);
+var import_uuid = require("uuid");
+var fluentFfmpeg = require("fluent-ffmpeg");
+function resolvePath(output, assetPath) {
+  let resolvedPath;
+  if (assetPath.startsWith("http://") || assetPath.startsWith("https://") || assetPath.startsWith("data:")) {
+    resolvedPath = assetPath;
+  } else {
+    resolvedPath = path4.join(output, "../public", assetPath);
+  }
+  return resolvedPath;
+}
+async function makeSureFolderExists(folderPath) {
+  if (await fs.promises.access(folderPath).then(() => false).catch(() => true)) {
+    await fs.promises.mkdir(folderPath, { recursive: true });
+  }
+}
+async function concatenateMedia(files, outputFile) {
+  const tempFile = path4.join(os2.tmpdir(), `${(0, import_uuid.v4)()}.txt`);
+  const fileContent = files.map((file) => `file '${file.replace(/'/g, "\\'")}'`).join("\n");
+  await fs.promises.writeFile(tempFile, fileContent);
+  return new Promise((resolve, reject) => {
+    fluentFfmpeg.setFfmpegPath(ffmpegSettings.getFfmpegPath());
+    const ffmpegCommand = fluentFfmpeg();
+    ffmpegCommand.input(tempFile).inputOptions([
+      "-f concat",
+      "-safe 0",
+      "-protocol_whitelist file,http,https,tcp,tls"
+    ]).outputOptions(["-c copy"]).on("error", (err) => {
+      console.error("Error:", err);
+      fs.promises.unlink(tempFile).catch(console.error);
+      reject(err);
+    }).on("end", () => {
+      fs.promises.unlink(tempFile).catch(console.error);
+      resolve();
+    }).save(outputFile);
+  });
+}
+async function createSilentAudioFile(filePath, duration) {
+  fluentFfmpeg.setFfmpegPath(ffmpegSettings.getFfmpegPath());
+  return new Promise((resolve, reject) => {
+    fluentFfmpeg().addInput(`anullsrc=channel_layout=stereo:sample_rate=${48e3}`).inputFormat("lavfi").duration(duration).on("end", () => {
+      resolve(filePath);
+    }).on("error", (err) => {
+      console.error("Error creating silent audio file:", err);
+      reject(err);
+    }).save(filePath);
+  });
+}
+async function getVideoDuration(filePath) {
+  fluentFfmpeg.setFfprobePath(ffmpegSettings.getFfprobePath());
+  return new Promise((resolve, reject) => {
+    fluentFfmpeg.ffprobe(filePath, (err, metadata) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      const duration = metadata.format.duration;
+      if (duration) {
+        resolve(duration);
+      } else {
+        reject(new Error("Could not determine video duration."));
+      }
+    });
+  });
+}
+async function getVideoDimensions(filePath) {
+  return new Promise((resolve, reject) => {
+    fluentFfmpeg.ffprobe(filePath, (err, metadata) => {
+      if (err) {
+        console.error("Error getting video dimensions:", err);
+        reject(new Error("Failed to get video dimensions"));
+        return;
+      }
+      const videoStream = metadata.streams.find(
+        (stream) => stream.codec_type === "video"
+      );
+      if (videoStream && videoStream.width && videoStream.height) {
+        resolve({
+          width: videoStream.width,
+          height: videoStream.height
+        });
+      }
+      reject(new Error("Could not find video dimensions in metadata"));
+    });
+  });
+}
+async function doesFileExist(filePath) {
+  try {
+    await fs.promises.access(filePath, fs.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function mergeAudioWithVideo(audioPath, videoPath, outputPath, audioCodec = "aac") {
+  fluentFfmpeg.setFfmpegPath(ffmpegSettings.getFfmpegPath());
+  return new Promise((resolve, reject) => {
+    fluentFfmpeg().input(videoPath).input(audioPath).outputOptions([
+      "-c:v",
+      "copy",
+      "-c:a",
+      audioCodec,
+      "-strict",
+      "experimental"
+    ]).on("end", () => {
+      resolve();
+    }).on("error", (err) => {
+      console.error(`Error merging video and audio: ${err.message}`);
+      reject(err);
+    }).save(outputPath);
+  });
+}
+async function checkForAudioStream(file) {
+  fluentFfmpeg.setFfprobePath(ffmpegSettings.getFfprobePath());
+  return new Promise((resolve, reject) => {
+    fluentFfmpeg.ffprobe(file, (err, metadata) => {
+      if (err) {
+        console.error(`error checking for audioStream for file ${file}`, err);
+        reject(err);
+        return;
+      }
+      const audioStreams = metadata.streams.filter(
+        (s) => s.codec_type === "audio"
+      );
+      resolve(audioStreams.length > 0);
+    });
+  });
+}
+async function getSampleRate(filePath) {
+  fluentFfmpeg.setFfprobePath(ffmpegSettings.getFfprobePath());
+  return new Promise((resolve, reject) => {
+    fluentFfmpeg.ffprobe(filePath, (err, metadata) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      const audioStream = metadata.streams.find((s) => s.codec_type === "audio");
+      if (audioStream && audioStream.sample_rate) {
+        resolve(audioStream.sample_rate);
+      } else {
+        reject(new Error("No audio stream found"));
+      }
+    });
+  });
+}
+async function getVideoCodec(filePath) {
+  fluentFfmpeg.setFfprobePath(ffmpegSettings.getFfprobePath());
+  return new Promise((resolve, reject) => {
+    fluentFfmpeg.ffprobe(filePath, (err, metadata) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      const videoStream = metadata.streams.find((s) => s.codec_type === "video");
+      if (videoStream && videoStream.codec_name) {
+        resolve(videoStream.codec_name);
+      } else {
+        reject(new Error("No video stream found"));
+      }
+    });
+  });
+}
+async function getVideoMetadata(filePath) {
+  fluentFfmpeg.setFfprobePath(ffmpegSettings.getFfprobePath());
+  return new Promise((resolve, reject) => {
+    fluentFfmpeg.ffprobe(filePath, (err, metadata) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      const videoStream = metadata.streams.find((s) => s.codec_type === "video");
+      if (videoStream && videoStream.codec_name && videoStream.width && videoStream.height) {
+        resolve({
+          codec: videoStream.codec_name,
+          width: videoStream.width,
+          height: videoStream.height
+        });
+      } else {
+        reject(new Error("Unable to retrieve complete video information"));
+      }
+    });
+  });
+}
+
+// src/generate-audio.ts
+var audioCodecs = {
+  mp4: "aac",
+  webm: "libopus",
+  proRes: "aac"
+};
+var SAMPLE_RATE = 48e3;
+function getAssetPlacement(frames) {
+  const assets = [];
+  const assetTimeMap = /* @__PURE__ */ new Map();
+  for (let frame = 0; frame < frames.length; frame++) {
+    for (const asset of frames[frame]) {
+      if (!assetTimeMap.has(asset.key)) {
+        assetTimeMap.set(asset.key, {
+          start: asset.currentTime,
+          end: asset.currentTime
+        });
+        assets.push({
+          key: asset.key,
+          src: asset.src,
+          type: asset.type,
+          startInVideo: frame,
+          endInVideo: frame,
+          duration: 0,
+          // Placeholder, will be recalculated later based on frames
+          durationInSeconds: 0,
+          // Placeholder, will be calculated based on currentTime
+          playbackRate: asset.playbackRate,
+          volume: asset.volume,
+          trimLeftInSeconds: asset.currentTime
+        });
+      } else {
+        const timeInfo = assetTimeMap.get(asset.key);
+        if (timeInfo) {
+          timeInfo.end = asset.currentTime;
+          assetTimeMap.set(asset.key, timeInfo);
+        }
+        const existingAsset = assets.find((a) => a.key === asset.key);
+        if (existingAsset) {
+          existingAsset.endInVideo = frame;
+        }
+      }
+    }
+  }
+  assets.forEach((asset) => {
+    const timeInfo = assetTimeMap.get(asset.key);
+    if (timeInfo) {
+      asset.durationInSeconds = (timeInfo.end - timeInfo.start) / asset.playbackRate;
+    }
+    asset.duration = asset.endInVideo - asset.startInVideo + 1;
+  });
+  return assets;
+}
+function calculateAtempoFilters(playbackRate) {
+  const atempoFilters = [];
+  let rate = playbackRate;
+  while (rate > 100) {
+    atempoFilters.push("atempo=100.0");
+    rate /= 100;
+  }
+  if (rate > 1) {
+    atempoFilters.push(`atempo=${rate}`);
+  }
+  rate = playbackRate;
+  while (rate < 0.5) {
+    atempoFilters.push("atempo=0.5");
+    rate *= 2;
+  }
+  if (rate < 1) {
+    atempoFilters.push(`atempo=${rate}`);
+  }
+  return atempoFilters;
+}
+async function prepareAudio(outputDir, tempDir, asset, startFrame, endFrame, fps) {
+  const sanitizedKey = asset.key.replace(/[/[\]]/g, "-");
+  const outputPath = path5.join(tempDir, `${sanitizedKey}.wav`);
+  const trimLeft = asset.trimLeftInSeconds / asset.playbackRate;
+  const trimRight = 1 / fps + Math.min(
+    trimLeft + asset.durationInSeconds,
+    trimLeft + (endFrame - startFrame) / fps
+  );
+  const padStart = asset.startInVideo / fps * 1e3;
+  const assetSampleRate = await getSampleRate(
+    resolvePath(outputDir, asset.src)
+  );
+  const padEnd = Math.max(
+    0,
+    assetSampleRate * (endFrame - startFrame + 1) / fps - assetSampleRate * asset.duration / fps - assetSampleRate * padStart / 1e3
+  );
+  const atempoFilters = calculateAtempoFilters(asset.playbackRate);
+  const resolvedPath = resolvePath(outputDir, asset.src);
+  await new Promise((resolve, reject) => {
+    const audioFilters = [
+      ...atempoFilters,
+      `atrim=start=${trimLeft}:end=${trimRight}`,
+      `apad=pad_len=${padEnd}`,
+      `adelay=${padStart}|${padStart}|${padStart}`,
+      `volume=${asset.volume}`
+    ].join(",");
+    import_fluent_ffmpeg2.default.setFfmpegPath(ffmpegSettings.getFfmpegPath());
+    (0, import_fluent_ffmpeg2.default)(resolvedPath).audioChannels(2).audioCodec("pcm_s16le").audioFrequency(SAMPLE_RATE).outputOptions([`-af`, audioFilters]).on("end", () => {
+      resolve();
+    }).on("error", (err) => {
+      console.error(
+        `Error processing audio for asset key: ${asset.key}`,
+        err
+      );
+      reject(err);
+    }).save(outputPath);
+  });
+  return outputPath;
+}
+async function mergeAudioTracks(tempDir, audioFilenames) {
+  return new Promise((resolve, reject) => {
+    import_fluent_ffmpeg2.default.setFfmpegPath(ffmpegSettings.getFfmpegPath());
+    const command = (0, import_fluent_ffmpeg2.default)();
+    audioFilenames.forEach((filename) => {
+      command.input(filename);
+    });
+    command.complexFilter([
+      `amix=inputs=${audioFilenames.length}:duration=longest,volume=${audioFilenames.length}`
+    ]).outputOptions(["-c:a", "pcm_s16le"]).on("end", () => {
+      resolve();
+    }).on("error", (err) => {
+      console.error(`Error merging audio tracks: ${err.message}`);
+      reject(err);
+    }).save(path5.join(tempDir, `audio.wav`));
+  });
+}
+async function generateAudio({
+  outputDir,
+  tempDir,
+  assets,
+  startFrame,
+  endFrame,
+  fps
+}) {
+  const fullTempDir = path5.join(os3.tmpdir(), tempDir);
+  await makeSureFolderExists(outputDir);
+  await makeSureFolderExists(fullTempDir);
+  const assetPositions = getAssetPlacement(assets);
+  const audioFilenames = [];
+  for (const asset of assetPositions) {
+    let hasAudioStream = true;
+    if (asset.type !== "audio") {
+      hasAudioStream = await checkForAudioStream(
+        resolvePath(outputDir, asset.src)
+      );
+    }
+    if (asset.playbackRate !== 0 && asset.volume !== 0 && hasAudioStream) {
+      const filename = await prepareAudio(
+        outputDir,
+        fullTempDir,
+        asset,
+        startFrame,
+        endFrame,
+        fps
+      );
+      audioFilenames.push(filename);
+    }
+  }
+  if (audioFilenames.length > 0) {
+    await mergeAudioTracks(fullTempDir, audioFilenames);
+  }
+  return audioFilenames;
+}
+async function mergeMedia(outputFilename, outputDir, tempDir, format) {
+  const fullTempDir = path5.join(os3.tmpdir(), tempDir);
+  await makeSureFolderExists(outputDir);
+  await makeSureFolderExists(fullTempDir);
+  const audioWavExists = fs2.existsSync(path5.join(fullTempDir, `audio.wav`));
+  if (audioWavExists) {
+    await mergeAudioWithVideo(
+      path5.join(fullTempDir, `audio.wav`),
+      path5.join(fullTempDir, `visuals.${extensions[format]}`),
+      path5.join(outputDir, `${outputFilename}.${extensions[format]}`),
+      audioCodecs[format]
+    );
+  } else {
+    const destination = path5.join(
+      outputDir,
+      `${outputFilename}.${extensions[format]}`
+    );
+    await fs2.promises.copyFile(
+      path5.join(fullTempDir, `visuals.${extensions[format]}`),
+      destination
+    );
+  }
+  if (fullTempDir.endsWith("-undefined")) {
+    await fs2.promises.rm(fullTempDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+
+// src/video-frame-extractor.ts
+var import_telemetry2 = require("@twick/telemetry");
+var fs3 = __toESM(require("fs"), 1);
+var os4 = __toESM(require("os"), 1);
+var path6 = __toESM(require("path"), 1);
+var import_uuid2 = require("uuid");
+var ffmpeg3 = require("fluent-ffmpeg");
+var _VideoFrameExtractor = class _VideoFrameExtractor {
+  constructor(filePath, startTime, fps, duration) {
+    this.ffmpegPath = ffmpegSettings.getFfmpegPath();
+    this.buffer = Buffer.alloc(0);
+    this.bufferOffset = 0;
+    // Images are buffered in memory until they are requested.
+    this.imageBuffers = [];
+    this.lastImage = null;
+    this.framesProcessed = 0;
+    this.width = 0;
+    this.height = 0;
+    this.frameSize = 0;
+    this.codec = null;
+    this.process = null;
+    this.terminated = false;
+    this.state = "processing";
+    this.filePath = filePath;
+    this.downloadedFilePath = _VideoFrameExtractor.downloadedVideoMap.get(
+      filePath
+    )?.localPath;
+    this.startTimeOffset = _VideoFrameExtractor.downloadedVideoMap.get(filePath)?.startTimeOffset;
+    this.startTime = startTime;
+    this.duration = duration;
+    this.toTime = this.getEndTime(this.startTime);
+    this.fps = fps;
+    getVideoMetadata(this.downloadedFilePath).then((metadata) => {
+      this.width = metadata.width;
+      this.height = metadata.height;
+      this.frameSize = this.width * this.height * 4;
+      this.buffer = Buffer.alloc(this.frameSize);
+      this.codec = metadata.codec;
+      if (this.startTime >= this.duration) {
+        this.process = this.createFfmpegProcessToExtractFirstFrame(
+          this.downloadedFilePath,
+          this.codec
+        );
+        return;
+      }
+      this.process = this.createFfmpegProcess(
+        this.startTime - this.startTimeOffset,
+        this.toTime,
+        this.downloadedFilePath,
+        this.fps,
+        this.codec
+      );
+    });
+  }
+  static downloadVideoChunk(url, startTime, endTime) {
+    const outputDir = path6.join(os4.tmpdir(), `twick-decoder-chunks`);
+    if (!fs3.existsSync(outputDir)) {
+      fs3.mkdirSync(outputDir, { recursive: true });
+    }
+    return new Promise((resolve, reject) => {
+      ffmpeg3.ffprobe(url, (err, metadata) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        const format = metadata.format.format_name?.split(",")[-1] || "mp4";
+        const outputFileName = `chunk_${(0, import_uuid2.v4)()}.${format}`;
+        const outputPath = path6.join(outputDir, outputFileName);
+        const toleranceInSeconds = 0.5;
+        const adjustedStartTime = Math.max(startTime - toleranceInSeconds, 0);
+        ffmpeg3(url).setFfmpegPath(ffmpegSettings.getFfmpegPath()).inputOptions([
+          `-ss ${adjustedStartTime}`,
+          `-to ${endTime + toleranceInSeconds}`
+        ]).outputOptions(["-c copy"]).output(outputPath).on("end", () => {
+          this.downloadedVideoMap.set(url, {
+            localPath: outputPath,
+            startTimeOffset: adjustedStartTime
+          });
+          resolve(outputPath);
+        }).on("error", (err2) => reject(err2)).run();
+      });
+    });
+  }
+  getTime() {
+    return this.startTime + this.framesProcessed / this.fps;
+  }
+  getLastTime() {
+    return this.startTime + (this.framesProcessed - 1) / this.fps;
+  }
+  getLastFrame() {
+    return this.lastImage;
+  }
+  getWidth() {
+    return this.width;
+  }
+  getHeight() {
+    return this.height;
+  }
+  getEndTime(startTime) {
+    return Math.min(
+      startTime + _VideoFrameExtractor.chunkLengthInSeconds,
+      this.duration
+    );
+  }
+  getArgs(codec, range, fps) {
+    const inputOptions = [];
+    const outputOptions = [];
+    inputOptions.push("-loglevel", ffmpegSettings.getLogLevel());
+    if (range) {
+      inputOptions.push(
+        ...["-ss", range[0].toFixed(2), "-to", range[1].toFixed(2)]
+      );
+    }
+    if (codec === "vp9") {
+      inputOptions.push("-vcodec", "libvpx-vp9");
+    }
+    if (fps) {
+      outputOptions.push("-vf", `fps=fps=${fps}`);
+    }
+    if (!range) {
+      outputOptions.push("-vframes", "1");
+    }
+    outputOptions.push("-f", "rawvideo");
+    outputOptions.push("-pix_fmt", "rgba");
+    return { inputOptions, outputOptions };
+  }
+  createFfmpegProcess(startTime, toTime, filePath, fps, codec) {
+    const { inputOptions, outputOptions } = this.getArgs(
+      codec,
+      [startTime, toTime],
+      fps
+    );
+    const process2 = ffmpeg3(filePath).setFfmpegPath(this.ffmpegPath).inputOptions(inputOptions).outputOptions(outputOptions).on("end", () => {
+      this.handleClose(0);
+    }).on("error", (err) => {
+      this.handleError(err);
+    }).on("stderr", (stderrLine) => {
+      console.log(stderrLine);
+    }).on("stdout", (stderrLine) => {
+      console.log(stderrLine);
+    });
+    const ffstream = process2.pipe();
+    ffstream.on("data", (data) => {
+      this.processData(data);
+    });
+    return process2;
+  }
+  /**
+   * We call this in the case that the time requested is greater than the
+   * duration of the video. In this case, we want to display the first frame
+   * of the video.
+   *
+   * Note: This does NOT match the behavior of the old implementation
+   * inside of 2d/src/lib/components/Video.ts. In the old implementation, the
+   * last frame is shown instead of the first frame.
+   */
+  createFfmpegProcessToExtractFirstFrame(filePath, codec) {
+    const { inputOptions, outputOptions } = this.getArgs(
+      codec,
+      void 0,
+      void 0
+    );
+    const process2 = ffmpeg3(filePath).setFfmpegPath(this.ffmpegPath).inputOptions(inputOptions).outputOptions(outputOptions).on("end", () => {
+      this.handleClose(0);
+    }).on("error", (err) => {
+      this.handleError(err);
+    }).on("stderr", (stderrLine) => {
+      console.log(stderrLine);
+    }).on("stdout", (stderrLine) => {
+      console.log(stderrLine);
+    });
+    const ffstream = process2.pipe();
+    ffstream.on("data", (data) => {
+      this.processData(data);
+    });
+    return process2;
+  }
+  processData(data) {
+    let dataOffset = 0;
+    while (dataOffset < data.length) {
+      const remainingSpace = this.frameSize - this.bufferOffset;
+      const chunkSize = Math.min(remainingSpace, data.length - dataOffset);
+      data.copy(
+        this.buffer,
+        this.bufferOffset,
+        dataOffset,
+        dataOffset + chunkSize
+      );
+      this.bufferOffset += chunkSize;
+      dataOffset += chunkSize;
+      if (this.bufferOffset === this.frameSize) {
+        this.imageBuffers.push(Buffer.from(this.buffer));
+        this.bufferOffset = 0;
+      }
+    }
+  }
+  async popImage() {
+    if (this.imageBuffers.length) {
+      const image2 = this.imageBuffers.shift();
+      this.framesProcessed++;
+      this.lastImage = image2;
+      return image2;
+    }
+    if (this.state === "error") {
+      throw new Error("An error occurred while extracting the video frames.");
+    }
+    if (this.state === "done" && this.toTime >= this.duration) {
+      return this.lastImage;
+    }
+    if (this.state === "done") {
+      this.startTime = this.toTime;
+      this.toTime = Math.min(
+        this.startTime + _VideoFrameExtractor.chunkLengthInSeconds,
+        this.duration
+      );
+      if (!this.codec) {
+        throw new Error(
+          "Can't extract frames without a codec. This error should never happen."
+        );
+      }
+      this.process = this.createFfmpegProcess(
+        this.startTime,
+        this.toTime,
+        this.downloadedFilePath,
+        this.fps,
+        this.codec
+      );
+      this.state = "processing";
+    }
+    while (this.imageBuffers.length < 1) {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    const image = this.imageBuffers.shift();
+    this.framesProcessed++;
+    this.lastImage = image;
+    return image;
+  }
+  handleClose(code) {
+    this.state = code === 0 ? "done" : "error";
+  }
+  async handleError(err) {
+    const code = err.code;
+    if (this.terminated) {
+      return;
+    }
+    if (code === "ENOENT") {
+      (0, import_telemetry2.sendEvent)(import_telemetry2.EventName.Error, { error: "ffmpeg-not-found" });
+      throw new Error(
+        "Error: ffmpeg not found. Make sure ffmpeg is installed on your system."
+      );
+    } else if (err.message.includes("SIGSEGV")) {
+      (0, import_telemetry2.sendEvent)(import_telemetry2.EventName.Error, {
+        error: "ffmpeg-sigsegv",
+        message: err.message
+      });
+      throw new Error(
+        `Error: Segmentation fault when running ffmpeg. This is a common issue on Linux, you might be able to fix it by installing nscd ('sudo apt-get install nscd'). For more information, see https://docs.re.video/common-issues/ffmpeg/`
+      );
+    } else {
+      await (0, import_telemetry2.sendEvent)(import_telemetry2.EventName.Error, {
+        error: "ffmpeg-error",
+        message: err.message
+      });
+      throw new Error(
+        `An ffmpeg error occurred while fetching frames from source video ${this.filePath}: ${err}`
+      );
+    }
+  }
+  destroy() {
+    this.terminated = true;
+    this.process?.kill("SIGTERM");
+  }
+};
+_VideoFrameExtractor.chunkLengthInSeconds = 5;
+_VideoFrameExtractor.downloadedVideoMap = /* @__PURE__ */ new Map();
+var VideoFrameExtractor = _VideoFrameExtractor;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FFmpegExporterServer,
+  VideoFrameExtractor,
+  audioCodecs,
+  checkForAudioStream,
+  concatenateMedia,
+  createSilentAudioFile,
+  doesFileExist,
+  extensions,
+  ffmpegSettings,
+  generateAudio,
+  getSampleRate,
+  getVideoCodec,
+  getVideoDimensions,
+  getVideoDuration,
+  getVideoMetadata,
+  makeSureFolderExists,
+  mergeAudioWithVideo,
+  mergeMedia,
+  resolvePath
+});
+//# sourceMappingURL=index.cjs.map