@remotion/renderer 4.0.516 → 4.0.518

package/dist/esm/index.mjs

@@ -17206,11 +17206,14 @@ var correctFloatingPointError = (value) => {
 var BIT_DEPTH = 16;
 var BYTES_PER_SAMPLE = BIT_DEPTH / 8;
 var NUMBER_OF_CHANNELS = 2;
+var WAV_HEADER_SIZE = 44;
 var makeInlineAudioMixing = (dir, sampleRate) => {
   const folderToAdd = makeAndReturn(dir, "remotion-inline-audio-mixing");
   const openFiles = {};
   const writtenHeaders = {};
   const toneFrequencies = {};
+  const startTimesInSamples = {};
+  const writtenDataSizes = {};
   const cleanup = () => {
     for (const fileName of Object.keys(openFiles)) {
       try {
@@ -17221,42 +17224,39 @@ var makeInlineAudioMixing = (dir, sampleRate) => {
     deleteDirectory(folderToAdd);
   };
   const getListOfAssets = () => {
-    return Object.keys(openFiles);
+    return Object.keys(writtenHeaders).map((outName) => ({
+      outName,
+      startInSamples: startTimesInSamples[outName],
+      durationInSamples: writtenDataSizes[outName] / (NUMBER_OF_CHANNELS * BYTES_PER_SAMPLE)
+    })).sort((a, b) => a.startInSamples - b.startInSamples);
   };
   const getFilePath = (asset) => {
     return path15.join(folderToAdd, `${asset.id}.wav`);
   };
-  const ensureAsset = ({
-    asset,
-    fps,
-    totalNumberOfFrames,
-    trimLeftOffset,
-    trimRightOffset
-  }) => {
+  const ensureAsset = (asset) => {
     const filePath = getFilePath(asset);
-    if (!openFiles[filePath]) {
+    if (openFiles[filePath] === undefined) {
       openFiles[filePath] = fs15.openSync(filePath, "w");
     }
     if (writtenHeaders[filePath]) {
       return;
     }
     writtenHeaders[filePath] = true;
-    const expectedDataSize = Math.round((totalNumberOfFrames / fps - trimLeftOffset + trimRightOffset) * NUMBER_OF_CHANNELS * sampleRate * BYTES_PER_SAMPLE);
-    const expectedSize = 40 + expectedDataSize;
+    writtenDataSizes[filePath] = 0;
     const fd = openFiles[filePath];
     writeSync(fd, new Uint8Array([82, 73, 70, 70]), 0, 4, 0);
-    writeSync(fd, new Uint8Array(numberTo32BiIntLittleEndian(expectedSize)), 0, 4, 4);
+    writeSync(fd, numberTo32BiIntLittleEndian(36), 0, 4, 4);
     writeSync(fd, new Uint8Array([87, 65, 86, 69]), 0, 4, 8);
     writeSync(fd, new Uint8Array([102, 109, 116, 32]), 0, 4, 12);
     writeSync(fd, new Uint8Array([BIT_DEPTH, 0, 0, 0]), 0, 4, 16);
     writeSync(fd, new Uint8Array([1, 0]), 0, 2, 20);
     writeSync(fd, new Uint8Array([NUMBER_OF_CHANNELS, 0]), 0, 2, 22);
-    writeSync(fd, new Uint8Array(numberTo32BiIntLittleEndian(sampleRate)), 0, 4, 24);
-    writeSync(fd, new Uint8Array(numberTo32BiIntLittleEndian(sampleRate * NUMBER_OF_CHANNELS * BYTES_PER_SAMPLE)), 0, 4, 28);
-    writeSync(fd, new Uint8Array(numberTo16BitLittleEndian(NUMBER_OF_CHANNELS * BYTES_PER_SAMPLE)), 0, 2, 32);
+    writeSync(fd, numberTo32BiIntLittleEndian(sampleRate), 0, 4, 24);
+    writeSync(fd, numberTo32BiIntLittleEndian(sampleRate * NUMBER_OF_CHANNELS * BYTES_PER_SAMPLE), 0, 4, 28);
+    writeSync(fd, numberTo16BitLittleEndian(NUMBER_OF_CHANNELS * BYTES_PER_SAMPLE), 0, 2, 32);
     writeSync(fd, numberTo16BitLittleEndian(BIT_DEPTH), 0, 2, 34);
     writeSync(fd, new Uint8Array([100, 97, 116, 97]), 0, 4, 36);
-    writeSync(fd, new Uint8Array(numberTo32BiIntLittleEndian(expectedDataSize)), 0, 4, 40);
+    writeSync(fd, numberTo32BiIntLittleEndian(0), 0, 4, 40);
   };
   const finish = async ({
     binariesDirectory,
@@ -17265,7 +17265,14 @@ var makeInlineAudioMixing = (dir, sampleRate) => {
     cancelSignal,
     sampleRate: finishSampleRate
   }) => {
-    for (const fileName of Object.keys(openFiles)) {
+    for (const fileName of Object.keys(writtenHeaders)) {
+      const fd = openFiles[fileName];
+      const dataSize = Math.max(0, fs15.fstatSync(fd).size - WAV_HEADER_SIZE);
+      writtenDataSizes[fileName] = dataSize;
+      writeSync(fd, numberTo32BiIntLittleEndian(36 + dataSize), 0, 4, 4);
+      writeSync(fd, numberTo32BiIntLittleEndian(dataSize), 0, 4, 40);
+      fs15.closeSync(fd);
+      delete openFiles[fileName];
       const frequency = toneFrequencies[fileName];
       if (frequency === 1) {
         continue;
@@ -17281,9 +17288,6 @@ var makeInlineAudioMixing = (dir, sampleRate) => {
         cancelSignal,
         sampleRate: finishSampleRate
       });
-      try {
-        fs15.closeSync(openFiles[fileName]);
-      } catch {}
       fs15.renameSync(tmpFile, fileName);
     }
   };
@@ -17295,19 +17299,20 @@ var makeInlineAudioMixing = (dir, sampleRate) => {
     trimLeftOffset,
     trimRightOffset
   }) => {
-    ensureAsset({
-      asset,
-      fps,
-      totalNumberOfFrames,
-      trimLeftOffset,
-      trimRightOffset
-    });
+    ensureAsset(asset);
     const filePath = getFilePath(asset);
     if (toneFrequencies[filePath] !== undefined && toneFrequencies[filePath] !== asset.toneFrequency) {
       throw new Error(`toneFrequency must be the same across the entire audio, got ${asset.toneFrequency}, but before it was ${toneFrequencies[filePath]}`);
     }
     const fileDescriptor = openFiles[filePath];
     toneFrequencies[filePath] = asset.toneFrequency;
+    const assetStartInVideo = asset.startInVideo ?? firstFrame;
+    const firstFrameForAsset = Math.max(assetStartInVideo, firstFrame);
+    const startInSamples = Math.max(0, Math.floor(correctFloatingPointError(((firstFrameForAsset - firstFrame) / fps - trimLeftOffset) * sampleRate)));
+    if (startTimesInSamples[filePath] !== undefined && startTimesInSamples[filePath] !== startInSamples) {
+      throw new Error(`The start time for inline audio asset ${asset.id} changed from ${startTimesInSamples[filePath]} to ${startInSamples} samples`);
+    }
+    startTimesInSamples[filePath] = startInSamples;
     let arr = new Int16Array(asset.audio);
     const isFirst = asset.frame === firstFrame;
     const isLast = asset.frame === totalNumberOfFrames + firstFrame - 1;
@@ -17319,9 +17324,10 @@ var makeInlineAudioMixing = (dir, sampleRate) => {
     if (isLast) {
       arr = arr.slice(0, arr.length + Math.ceil(correctFloatingPointError(samplesToShaveFromEnd)) * NUMBER_OF_CHANNELS);
     }
-    const positionInSeconds = (asset.frame - firstFrame) / fps - (isFirst ? 0 : trimLeftOffset);
-    const position = Math.floor(correctFloatingPointError(positionInSeconds * sampleRate)) * NUMBER_OF_CHANNELS * BYTES_PER_SAMPLE;
-    writeSync(fileDescriptor, arr, 0, arr.byteLength, 44 + position);
+    const positionInRenderInSeconds = (asset.frame - firstFrame) / fps - (isFirst ? 0 : trimLeftOffset);
+    const position = (Math.floor(correctFloatingPointError(positionInRenderInSeconds * sampleRate)) - startInSamples) * NUMBER_OF_CHANNELS * BYTES_PER_SAMPLE;
+    writeSync(fileDescriptor, arr, 0, arr.byteLength, WAV_HEADER_SIZE + position);
+    writtenDataSizes[filePath] = Math.max(writtenDataSizes[filePath], position + arr.byteLength);
   };
   return {
     cleanup,
@@ -21564,7 +21570,7 @@ var renderFrames = (options2) => {
 // src/render-media.ts
 import fs19 from "node:fs";
 import os10 from "node:os";
-import path28 from "node:path";
+import path30 from "node:path";
 import { LicensingInternals } from "@remotion/licensing";
 import { NoReactInternals as NoReactInternals17 } from "remotion/no-react";
 
@@ -21844,7 +21850,8 @@ var getCodecName = ({
   crf,
   hardwareAcceleration,
   logLevel,
-  indent
+  indent,
+  onLog
 }) => {
   const preferredHwAcceleration = hardwareAcceleration === "required" || hardwareAcceleration === "if-possible";
   const unsupportedQualityOption = hasSpecifiedUnsupportedHardwareQualifySettings({
@@ -21857,8 +21864,17 @@ var getCodecName = ({
   }
   const warnAboutDisabledHardwareAcceleration = () => {
     if (hardwareAcceleration === "if-possible" && unsupportedQualityOption) {
+      const message = `Hardware accelerated encoding disabled - "${unsupportedQualityOption}" option is not supported with hardware acceleration`;
+      if (onLog !== null) {
+        onLog({
+          logLevel: "warn",
+          previewString: message,
+          tag: ""
+        });
+        return;
+      }
       Log.warn({ indent, logLevel }, `${indent ? "" : `
-`}Hardware accelerated encoding disabled - "${unsupportedQualityOption}" option is not supported with hardware acceleration`);
+`}${message}`);
     }
   };
   if (codec === "prores") {
@@ -21990,7 +22006,8 @@ var generateFfmpegArgs = ({
     crf,
     hardwareAcceleration,
     indent,
-    logLevel
+    logLevel,
+    onLog: null
   });
   if (encoderSettings === null) {
     throw new TypeError(`encoderSettings is null: ${JSON.stringify(codec)} (hwaccel = ${hardwareAcceleration})`);
@@ -22105,7 +22122,8 @@ var resolveHardwareAcceleration = ({
   logLevel,
   crf,
   encodingMaxRate,
-  encodingBufferSize
+  encodingBufferSize,
+  onLog
 }) => {
   if (hardwareAcceleration === "disable") {
     return "disable";
@@ -22117,12 +22135,20 @@ var resolveHardwareAcceleration = ({
     encodingMaxRate,
     encodingBufferSize,
     logLevel,
-    indent
+    indent,
+    onLog
   });
   if (preferred === null) {
     return hardwareAcceleration;
   }
   if (!preferred.hardwareAccelerated) {
+    if (hardwareAcceleration === "if-possible" && hasSpecifiedUnsupportedHardwareQualifySettings({
+      crf,
+      encodingMaxRate,
+      encodingBufferSize
+    })) {
+      return "disable";
+    }
     return hardwareAcceleration;
   }
   const encoderAvailable = probeEncoderAvailability({
@@ -22209,7 +22235,8 @@ var prespawnFfmpeg = (options2) => {
     logLevel: options2.logLevel,
     crf: options2.crf,
     encodingMaxRate: options2.encodingMaxRate,
-    encodingBufferSize: options2.encodingBufferSize
+    encodingBufferSize: options2.encodingBufferSize,
+    onLog: options2.onLog
   });
   const ffmpegArgs = [
     ["-r", options2.fps],
@@ -22342,8 +22369,8 @@ var validateSelectedCodecAndProResCombination = ({
 };
 
 // src/stitch-frames-to-video.ts
-import { cpSync as cpSync2, promises as promises4, rmSync as rmSync4 } from "node:fs";
-import path27 from "node:path";
+import { cpSync as cpSync2, promises as promises5, rmSync as rmSync4 } from "node:fs";
+import path29 from "node:path";
 
 // src/convert-number-of-gif-loops-to-ffmpeg.ts
 var convertNumberOfGifLoopsToFfmpegSyntax = (loops) => {
@@ -22357,7 +22384,7 @@ var convertNumberOfGifLoopsToFfmpegSyntax = (loops) => {
 };
 
 // src/create-audio.ts
-import path26 from "path";
+import path27 from "path";
 
 // src/resolve-asset-src.ts
 import url from "node:url";
@@ -22831,6 +22858,83 @@ var mergeAudioTrack = (options2) => {
   return limit2(mergeAudioTrackUnlimited, options2);
 };
 
+// src/merge-inline-audio-tracks.ts
+import path26 from "node:path";
+var MAX_INLINE_AUDIO_INPUTS = 10;
+var inlineAudioTrackToPreprocessedAudioTrack = ({
+  track,
+  relativeToInSamples,
+  padToDurationInSamples
+}) => {
+  const delayInSamples = Math.max(0, track.startInSamples - relativeToInSamples);
+  const padAtEndInSamples = padToDurationInSamples === null ? 0 : Math.max(0, padToDurationInSamples - delayInSamples - track.durationInSamples);
+  return {
+    outName: track.outName,
+    filter: {
+      pad_start: delayInSamples === 0 ? null : `adelay=${new Array(3).fill(`${delayInSamples}S`).join("|")}`,
+      pad_end: padAtEndInSamples === 0 ? null : `apad=pad_len=${padAtEndInSamples}`
+    }
+  };
+};
+var mergeInlineAudioTracks = async ({
+  tracks,
+  downloadMap,
+  remotionRoot,
+  indent,
+  logLevel,
+  binariesDirectory,
+  cancelSignal,
+  fps,
+  chunkLengthInSeconds,
+  sampleRate
+}) => {
+  let currentTracks = tracks.sort((a, b) => a.startInSamples - b.startInSamples);
+  let level = 0;
+  while (currentTracks.length > 1) {
+    const groups = chunk2(currentTracks, MAX_INLINE_AUDIO_INPUTS);
+    currentTracks = await Promise.all(groups.map(async (group, index) => {
+      if (group.length === 1) {
+        return group[0];
+      }
+      const [{ startInSamples }] = group;
+      const durationInSamples = Math.max(...group.map((track) => {
+        return track.startInSamples - startInSamples + track.durationInSamples;
+      }));
+      const outName = path26.join(downloadMap.audioMixing, `inline-${level}-${index}.wav`);
+      await mergeAudioTrack({
+        files: group.map((track) => inlineAudioTrackToPreprocessedAudioTrack({
+          track,
+          relativeToInSamples: startInSamples,
+          padToDurationInSamples: null
+        })),
+        outName,
+        downloadMap,
+        remotionRoot,
+        indent,
+        logLevel,
+        binariesDirectory,
+        cancelSignal,
+        onProgress: () => {
+          return;
+        },
+        fps,
+        chunkLengthInSeconds,
+        sampleRate
+      });
+      for (const track of group) {
+        deleteDirectory(track.outName);
+      }
+      return {
+        outName,
+        startInSamples,
+        durationInSamples
+      };
+    }));
+    level++;
+  }
+  return currentTracks[0] ?? null;
+};
+
 // src/assets/calculate-atempo.ts
 var calculateATempo = (playbackRate) => {
   if (playbackRate === 1) {
@@ -23204,7 +23308,7 @@ var createAudio = async ({
     onProgress(totalProgress);
   };
   const audioTracks = await Promise.all(assetPositions.map(async (asset, index) => {
-    const filterFile = path26.join(downloadMap.audioMixing, `${index}.wav`);
+    const filterFile = path27.join(downloadMap.audioMixing, `${index}.wav`);
     const result = await preprocessAudioTrack({
       outName: filterFile,
       asset,
@@ -23237,20 +23341,31 @@ var createAudio = async ({
     sampleRate
   });
   const inlinedAudio = downloadMap.inlineAudioMixing.getListOfAssets();
+  const mergedInlineAudio = await mergeInlineAudioTracks({
+    tracks: inlinedAudio,
+    downloadMap,
+    remotionRoot,
+    indent,
+    logLevel,
+    binariesDirectory,
+    cancelSignal,
+    fps,
+    chunkLengthInSeconds,
+    sampleRate
+  });
   const preprocessed = [
     ...audioTracks.filter(truthy),
-    ...inlinedAudio.map((asset) => ({
-      outName: asset,
-      filter: {
-        filter: null,
-        pad_start: null,
-        pad_end: null
-      }
-    }))
+    ...mergedInlineAudio ? [
+      inlineAudioTrackToPreprocessedAudioTrack({
+        track: mergedInlineAudio,
+        relativeToInSamples: 0,
+        padToDurationInSamples: Math.round(chunkLengthInSeconds * sampleRate)
+      })
+    ] : []
   ];
-  const merged = path26.join(downloadMap.audioPreprocessing, "merged.wav");
+  const merged = path27.join(downloadMap.audioPreprocessing, "merged.wav");
   const extension = getExtensionFromAudioCodec(audioCodec);
-  const outName = path26.join(downloadMap.audioPreprocessing, `audio.${extension}`);
+  const outName = path27.join(downloadMap.audioPreprocessing, `audio.${extension}`);
   await mergeAudioTrack({
     files: preprocessed,
     outName: merged,
@@ -23292,6 +23407,85 @@ var createAudio = async ({
   return outName;
 };
 
+// src/finalize-fast-start.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { promises as promises4 } from "node:fs";
+import path28 from "node:path";
+var finalizeFastStart = async ({
+  input,
+  output,
+  muxer,
+  force,
+  indent,
+  logLevel,
+  binariesDirectory,
+  cancelSignal
+}) => {
+  let fastStartFile = null;
+  for (let attempt = 0;attempt < 3; attempt++) {
+    const candidate = path28.join(path28.dirname(output), `${path28.basename(output)}.${randomUUID2()}.remotion-in-progress`);
+    const task = callFf({
+      bin: "ffmpeg",
+      args: [
+        "-hide_banner",
+        "-i",
+        input,
+        "-c",
+        "copy",
+        "-movflags",
+        "faststart",
+        "-y",
+        "-f",
+        muxer,
+        candidate
+      ],
+      indent,
+      logLevel,
+      binariesDirectory,
+      cancelSignal: cancelSignal ?? undefined
+    });
+    let stderr = "";
+    task.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    try {
+      await task;
+      fastStartFile = candidate;
+      break;
+    } catch (error) {
+      await promises4.rm(candidate, { force: true }).catch(() => {
+        return;
+      });
+      const isReopenFailure = stderr.includes("Unable to re-open") && stderr.includes("output file for shifting data");
+      if (!isReopenFailure || attempt === 2) {
+        throw error;
+      }
+      Log.verbose({ indent, logLevel, tag: "stitchFramesToVideo()" }, `Retrying Fast Start finalization (attempt ${attempt + 2} of 3)`);
+    }
+  }
+  if (fastStartFile === null) {
+    throw new Error("Fast Start finalization did not produce an output file");
+  }
+  if (force) {
+    await promises4.rename(fastStartFile, output);
+    return;
+  }
+  try {
+    await promises4.link(fastStartFile, output);
+  } finally {
+    await promises4.rm(fastStartFile, { force: true });
+  }
+};
+
+// src/get-fast-start-muxer.ts
+var getFastStartMuxer = (outputExtension) => {
+  const normalizedExtension = outputExtension.toLowerCase();
+  if (normalizedExtension === "mp4" || normalizedExtension === "mov") {
+    return normalizedExtension;
+  }
+  return null;
+};
+
 // src/make-metadata-args.ts
 import { VERSION as VERSION5 } from "remotion/version";
 var makeMetadataArgs = (metadata) => {
@@ -23384,7 +23578,8 @@ var innerStitchFramesToVideo = async ({
   separateAudioTo,
   metadata,
   hardwareAcceleration,
-  sampleRate
+  sampleRate,
+  onLog
 }, remotionRoot) => {
   validateDimension(height, "height", "passed to `stitchFramesToVideo()`");
   validateDimension(width, "width", "passed to `stitchFramesToVideo()`");
@@ -23430,7 +23625,10 @@ var innerStitchFramesToVideo = async ({
     setting: audioCodecSetting,
     separateAudioTo
   });
-  const tempFile = outputLocation ? null : path27.join(assetsInfo.downloadMap.stitchFrames, `out.${getFileExtensionFromCodec(codec, resolvedAudioCodec)}`);
+  const tempFile = outputLocation ? null : path29.join(assetsInfo.downloadMap.stitchFrames, `out.${getFileExtensionFromCodec(codec, resolvedAudioCodec)}`);
+  const outputExtension = (getExtensionOfFilename(outputLocation) ?? getFileExtensionFromCodec(codec, resolvedAudioCodec)).toLowerCase();
+  const fastStartMuxer = getFastStartMuxer(outputExtension);
+  const fastStartIntermediate = fastStartMuxer === null ? null : path29.join(assetsInfo.downloadMap.stitchFrames, "fast-start-intermediate.remotion-in-progress");
   Log.verbose({
     indent,
     logLevel,
@@ -23506,10 +23704,10 @@ var innerStitchFramesToVideo = async ({
     }
     cpSync2(audio, outputLocation ?? tempFile);
     onProgress?.(Math.round(assetsInfo.chunkLengthInSeconds * fps));
-    deleteDirectory(path27.dirname(audio));
+    deleteDirectory(path29.dirname(audio));
     const file = await new Promise((resolve2, reject) => {
       if (tempFile) {
-        promises4.readFile(tempFile).then((f) => {
+        promises5.readFile(tempFile).then((f) => {
           return resolve2(f);
         }).catch((e) => reject(e));
       } else {
@@ -23520,7 +23718,7 @@ var innerStitchFramesToVideo = async ({
     assetsInfo.downloadMap.allowCleanup();
     return Promise.resolve(file);
   }
-  const resolvedHardwareAcceleration = resolveHardwareAcceleration({
+  const resolvedHardwareAcceleration = preEncodedFileLocation ? "disable" : resolveHardwareAcceleration({
     codec,
     hardwareAcceleration,
     binariesDirectory,
@@ -23528,7 +23726,8 @@ var innerStitchFramesToVideo = async ({
     logLevel,
     crf,
     encodingMaxRate: maxRate,
-    encodingBufferSize: bufferSize
+    encodingBufferSize: bufferSize,
+    onLog
   });
   const ffmpegArgs = [
     ...preEncodedFileLocation ? [["-i", preEncodedFileLocation]] : [
@@ -23557,11 +23756,11 @@ var innerStitchFramesToVideo = async ({
       indent,
       logLevel
     }),
-    codec === "h264" ? ["-movflags", "faststart"] : null,
     ["-map_metadata", "-1"],
     ...makeMetadataArgs(metadata ?? {}),
-    force ? "-y" : null,
-    outputLocation ?? tempFile
+    force || fastStartIntermediate ? "-y" : null,
+    fastStartIntermediate ? ["-f", fastStartMuxer] : null,
+    fastStartIntermediate ?? outputLocation ?? tempFile
   ];
   const ffmpegString = ffmpegArgs.flat(2).filter(Boolean);
   const finalFfmpegString = ffmpegOverride ? ffmpegOverride({ type: "stitcher", args: ffmpegString }) : ffmpegString;
@@ -23606,29 +23805,37 @@ var innerStitchFramesToVideo = async ({
     if (!audio) {
       throw new Error(`\`separateAudioTo\` was set to ${JSON.stringify(separateAudioTo)}, but this render included no audio`);
     }
-    const finalDestination = path27.resolve(remotionRoot, separateAudioTo);
+    const finalDestination = path29.resolve(remotionRoot, separateAudioTo);
     cpSync2(audio, finalDestination);
     rmSync4(audio);
   }
-  const result = await new Promise((resolve2, reject) => {
+  await new Promise((resolve2, reject) => {
     task.once("close", (code, signal) => {
       if (code === 0) {
-        if (tempFile === null) {
-          cleanDownloadMap(assetsInfo.downloadMap);
-          return resolve2(null);
-        }
-        promises4.readFile(tempFile).then((f) => {
-          resolve2(f);
-        }).catch((e) => {
-          reject(e);
-        }).finally(() => {
-          cleanDownloadMap(assetsInfo.downloadMap);
-        });
+        resolve2();
       } else {
         reject(new Error(`FFmpeg quit with code ${code} ${signal ? `(${signal})` : ""} The FFmpeg output was ${ffmpegStderr}`));
       }
     });
   });
+  if (fastStartIntermediate && fastStartMuxer) {
+    const destination = outputLocation ?? tempFile;
+    if (destination === null) {
+      throw new Error("Expected a Fast Start output destination");
+    }
+    await finalizeFastStart({
+      input: fastStartIntermediate,
+      output: path29.resolve(remotionRoot, destination),
+      muxer: fastStartMuxer,
+      force,
+      indent,
+      logLevel,
+      binariesDirectory,
+      cancelSignal
+    });
+  }
+  const result = tempFile === null ? null : await promises5.readFile(tempFile);
+  cleanDownloadMap(assetsInfo.downloadMap);
   assetsInfo.downloadMap.allowCleanup();
   return result;
 };
@@ -23711,7 +23918,8 @@ var stitchFramesToVideo = ({
     metadata: metadata ?? null,
     separateAudioTo: separateAudioTo ?? null,
     hardwareAcceleration: hardwareAcceleration ?? "disable",
-    sampleRate: sampleRate ?? 48000
+    sampleRate: sampleRate ?? 48000,
+    onLog: defaultOnLog
   });
 };
 
@@ -23975,7 +24183,7 @@ var internalRenderMediaRaw = ({
       separateAudioTo
     });
   }
-  const absoluteOutputLocation = outputLocation ? path28.resolve(process.cwd(), outputLocation) : null;
+  const absoluteOutputLocation = outputLocation ? path30.resolve(process.cwd(), outputLocation) : null;
   validateScale(scale);
   validateFfmpegOverride(ffmpegOverride);
   validateEveryNthFrame(everyNthFrame);
@@ -24041,8 +24249,8 @@ var internalRenderMediaRaw = ({
   }
   const imageFormat = isAudioCodec(codec) ? "none" : provisionalImageFormat ?? compositionWithPossibleUnevenDimensions.defaultVideoImageFormat ?? DEFAULT_VIDEO_IMAGE_FORMAT;
   validateSelectedPixelFormatAndImageFormatCombination(pixelFormat, imageFormat);
-  const workingDir = fs19.mkdtempSync(path28.join(os10.tmpdir(), "react-motion-render"));
-  const preEncodedFileLocation = parallelEncoding ? path28.join(workingDir, "pre-encode." + getFileExtensionFromCodec(codec, audioCodec)) : null;
+  const workingDir = fs19.mkdtempSync(path30.join(os10.tmpdir(), "react-motion-render"));
+  const preEncodedFileLocation = parallelEncoding ? path30.join(workingDir, "pre-encode." + getFileExtensionFromCodec(codec, audioCodec)) : null;
   if (onCtrlCExit && workingDir) {
     onCtrlCExit(`Delete ${workingDir}`, () => deleteDirectory(workingDir));
   }
@@ -24115,7 +24323,8 @@ var internalRenderMediaRaw = ({
         gopSize,
         colorSpace,
         binariesDirectory,
-        hardwareAcceleration
+        hardwareAcceleration,
+        onLog
       });
       stitcherFfmpeg = preStitcher.task;
     }
@@ -24319,6 +24528,7 @@ var internalRenderMediaRaw = ({
         separateAudioTo,
         metadata,
         hardwareAcceleration,
+        onLog,
         sampleRate
       });
     }).then((buffer2) => {
@@ -24382,7 +24592,7 @@ var internalRenderMediaRaw = ({
       reject(err);
     }).finally(() => {
       if (preEncodedFileLocation !== null && fs19.existsSync(preEncodedFileLocation)) {
-        deleteDirectory(path28.dirname(preEncodedFileLocation));
+        deleteDirectory(path30.dirname(preEncodedFileLocation));
       }
       if (workingDir && fs19.existsSync(workingDir)) {
         deleteDirectory(workingDir);
@@ -24560,7 +24770,7 @@ var renderMedia = ({
 
 // src/render-still.ts
 import fs20, { statSync as statSync2 } from "node:fs";
-import path29 from "node:path";
+import path31 from "node:path";
 import { LicensingInternals as LicensingInternals2 } from "@remotion/licensing";
 import { NoReactInternals as NoReactInternals18 } from "remotion/no-react";
 var innerRenderStill = async ({
@@ -24611,7 +24821,7 @@ var innerRenderStill = async ({
   });
   validatePuppeteerTimeout(timeoutInMilliseconds);
   validateScale(scale);
-  output = typeof output === "string" ? path29.resolve(process.cwd(), output) : null;
+  output = typeof output === "string" ? path31.resolve(process.cwd(), output) : null;
   validateJpegQuality(jpegQuality);
   if (output) {
     if (fs20.existsSync(output)) {
@@ -25393,12 +25603,13 @@ var muxVideoAndAudio = async ({
   binariesDirectory,
   fps,
   cancelSignal,
-  addFaststart,
   metadata,
   numberOfGifLoops
 }) => {
   const startTime = Date.now();
   Log.verbose({ indent, logLevel }, "Muxing video and audio together");
+  const outputExtension = getExtensionOfFilename(output);
+  const fastStartMuxer = outputExtension ? getFastStartMuxer(outputExtension) : null;
   const command = [
     "-hide_banner",
     videoOutput ? "-i" : null,
@@ -25413,8 +25624,8 @@ var muxVideoAndAudio = async ({
     videoOutput ? String(fps) : null,
     numberOfGifLoops === null ? null : "-loop",
     numberOfGifLoops === null ? null : convertNumberOfGifLoopsToFfmpegSyntax(numberOfGifLoops),
-    addFaststart ? "-movflags" : null,
-    addFaststart ? "faststart" : null,
+    fastStartMuxer ? "-movflags" : null,
+    fastStartMuxer ? "faststart" : null,
     ...makeMetadataArgs(metadata ?? {}),
     "-y",
     output
@@ -25445,20 +25656,6 @@ var muxVideoAndAudio = async ({
 };
 
 // src/combine-chunks.ts
-var codecSupportsFastStart = {
-  "h264-mkv": false,
-  "h264-ts": false,
-  h264: true,
-  h265: true,
-  av1: true,
-  aac: false,
-  gif: false,
-  mp3: false,
-  prores: false,
-  vp8: false,
-  vp9: false,
-  wav: false
-};
 var REMOTION_FILELIST_TOKEN = "remotion-filelist";
 var internalCombineChunks = async ({
   outputLocation: output,
@@ -25564,7 +25761,6 @@ var internalCombineChunks = async ({
       binariesDirectory,
       fps,
       cancelSignal,
-      addFaststart: codecSupportsFastStart[codec],
       metadata,
       numberOfGifLoops
     });