@remotion/renderer 4.0.516 → 4.0.517

package/dist/assets/inline-audio-mixing.d.ts

@@ -1,5 +1,10 @@
 import type { InlineAudioAsset } from 'remotion/no-react';
 import type { CancelSignal } from '../make-cancel-signal';
+export type InlineAudioTrack = {
+    outName: string;
+    startInSamples: number;
+    durationInSamples: number;
+};
 export declare const makeInlineAudioMixing: (dir: string, sampleRate: number) => {
     cleanup: () => void;
     addAsset: ({ asset, fps, totalNumberOfFrames, firstFrame, trimLeftOffset, trimRightOffset, }: {
@@ -10,7 +15,7 @@ export declare const makeInlineAudioMixing: (dir: string, sampleRate: number) =>
         trimLeftOffset: number;
         trimRightOffset: number;
     }) => void;
-    getListOfAssets: () => string[];
+    getListOfAssets: () => InlineAudioTrack[];
     finish: ({ binariesDirectory, indent, logLevel, cancelSignal, sampleRate: finishSampleRate, }: {
         indent: boolean;
         logLevel: "error" | "info" | "trace" | "verbose" | "warn";

package/dist/assets/inline-audio-mixing.js

@@ -69,12 +69,14 @@ const correctFloatingPointError = (value) => {
 const BIT_DEPTH = 16;
 const BYTES_PER_SAMPLE = BIT_DEPTH / 8;
 const NUMBER_OF_CHANNELS = 2;
+const WAV_HEADER_SIZE = 44;
 const makeInlineAudioMixing = (dir, sampleRate) => {
     const folderToAdd = (0, download_map_1.makeAndReturn)(dir, 'remotion-inline-audio-mixing');
-    // asset id -> file descriptor
     const openFiles = {};
     const writtenHeaders = {};
     const toneFrequencies = {};
+    const startTimesInSamples = {};
+    const writtenDataSizes = {};
     const cleanup = () => {
         for (const fileName of Object.keys(openFiles)) {
             try {
@@ -86,42 +88,51 @@ const makeInlineAudioMixing = (dir, sampleRate) => {
         (0, delete_directory_1.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 node_path_1.default.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] = node_fs_1.default.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];
         (0, node_fs_1.writeSync)(fd, new Uint8Array([0x52, 0x49, 0x46, 0x46]), 0, 4, 0); // "RIFF"
-        (0, node_fs_1.writeSync)(fd, new Uint8Array(numberTo32BiIntLittleEndian(expectedSize)), 0, 4, 4); // Remaining size
+        (0, node_fs_1.writeSync)(fd, numberTo32BiIntLittleEndian(36), 0, 4, 4); // Remaining size
         (0, node_fs_1.writeSync)(fd, new Uint8Array([0x57, 0x41, 0x56, 0x45]), 0, 4, 8); // "WAVE"
         (0, node_fs_1.writeSync)(fd, new Uint8Array([0x66, 0x6d, 0x74, 0x20]), 0, 4, 12); // "fmt "
         (0, node_fs_1.writeSync)(fd, new Uint8Array([BIT_DEPTH, 0x00, 0x00, 0x00]), 0, 4, 16); // fmt chunk size = 16
         (0, node_fs_1.writeSync)(fd, new Uint8Array([0x01, 0x00]), 0, 2, 20); // Audio format (PCM) = 1, set 3 if float32 would be true
         (0, node_fs_1.writeSync)(fd, new Uint8Array([NUMBER_OF_CHANNELS, 0x00]), 0, 2, 22); // Number of channels
-        (0, node_fs_1.writeSync)(fd, new Uint8Array(numberTo32BiIntLittleEndian(sampleRate)), 0, 4, 24); // Sample rate
-        (0, node_fs_1.writeSync)(fd, new Uint8Array(numberTo32BiIntLittleEndian(sampleRate * NUMBER_OF_CHANNELS * BYTES_PER_SAMPLE)), 0, 4, 28); // Byte rate
-        (0, node_fs_1.writeSync)(fd, new Uint8Array(numberTo16BitLittleEndian(NUMBER_OF_CHANNELS * BYTES_PER_SAMPLE)), 0, 2, 32); // Block align
+        (0, node_fs_1.writeSync)(fd, numberTo32BiIntLittleEndian(sampleRate), 0, 4, 24); // Sample rate
+        (0, node_fs_1.writeSync)(fd, numberTo32BiIntLittleEndian(sampleRate * NUMBER_OF_CHANNELS * BYTES_PER_SAMPLE), 0, 4, 28); // Byte rate
+        (0, node_fs_1.writeSync)(fd, numberTo16BitLittleEndian(NUMBER_OF_CHANNELS * BYTES_PER_SAMPLE), 0, 2, 32); // Block align
         (0, node_fs_1.writeSync)(fd, numberTo16BitLittleEndian(BIT_DEPTH), 0, 2, 34); // Bits per sample
         (0, node_fs_1.writeSync)(fd, new Uint8Array([0x64, 0x61, 0x74, 0x61]), 0, 4, 36); // "data"
-        (0, node_fs_1.writeSync)(fd, new Uint8Array(numberTo32BiIntLittleEndian(expectedDataSize)), 0, 4, 40); // Remaining size
+        (0, node_fs_1.writeSync)(fd, numberTo32BiIntLittleEndian(0), 0, 4, 40); // Data size
     };
     const finish = async ({ binariesDirectory, indent, logLevel, 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, node_fs_1.default.fstatSync(fd).size - WAV_HEADER_SIZE);
+            writtenDataSizes[fileName] = dataSize;
+            (0, node_fs_1.writeSync)(fd, numberTo32BiIntLittleEndian(36 + dataSize), 0, 4, 4);
+            (0, node_fs_1.writeSync)(fd, numberTo32BiIntLittleEndian(dataSize), 0, 4, 40);
+            node_fs_1.default.closeSync(fd);
+            delete openFiles[fileName];
             const frequency = toneFrequencies[fileName];
             if (frequency === 1) {
                 continue;
@@ -137,21 +148,12 @@ const makeInlineAudioMixing = (dir, sampleRate) => {
                 cancelSignal,
                 sampleRate: finishSampleRate,
             });
-            try {
-                node_fs_1.default.closeSync(openFiles[fileName]);
-            }
-            catch (_a) { }
             node_fs_1.default.renameSync(tmpFile, fileName);
         }
     };
     const addAsset = ({ asset, fps, totalNumberOfFrames, firstFrame, trimLeftOffset, trimRightOffset, }) => {
-        ensureAsset({
-            asset,
-            fps,
-            totalNumberOfFrames,
-            trimLeftOffset,
-            trimRightOffset,
-        });
+        var _a;
+        ensureAsset(asset);
         const filePath = getFilePath(asset);
         if (toneFrequencies[filePath] !== undefined &&
             toneFrequencies[filePath] !== asset.toneFrequency) {
@@ -159,6 +161,15 @@ const makeInlineAudioMixing = (dir, sampleRate) => {
         }
         const fileDescriptor = openFiles[filePath];
         toneFrequencies[filePath] = asset.toneFrequency;
+        const assetStartInVideo = (_a = asset.startInVideo) !== null && _a !== void 0 ? _a : 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;
@@ -176,25 +187,17 @@ const makeInlineAudioMixing = (dir, sampleRate) => {
                 Math.ceil(correctFloatingPointError(samplesToShaveFromEnd)) *
                     NUMBER_OF_CHANNELS);
         }
-        const positionInSeconds = (asset.frame - firstFrame) / fps - (isFirst ? 0 : trimLeftOffset);
+        const positionInRenderInSeconds = (asset.frame - firstFrame) / fps - (isFirst ? 0 : trimLeftOffset);
         // Always rounding down to ensure there are no gaps when the samples don't align
         // In @remotion/media, we also round down the sample start timestamp and round up the end timestamp
         // This might lead to overlapping, hopefully aligning perfectly!
         // Test case: https://github.com/remotion-dev/remotion/issues/5758
-        const position = Math.floor(correctFloatingPointError(positionInSeconds * sampleRate)) *
+        const position = (Math.floor(correctFloatingPointError(positionInRenderInSeconds * sampleRate)) -
+            startInSamples) *
             NUMBER_OF_CHANNELS *
             BYTES_PER_SAMPLE;
-        (0, node_fs_1.writeSync)(
-        // fs
-        fileDescriptor, 
-        // data
-        arr, 
-        // offset of data
-        0, 
-        // length
-        arr.byteLength, 
-        // position
-        44 + position);
+        (0, node_fs_1.writeSync)(fileDescriptor, arr, 0, arr.byteLength, WAV_HEADER_SIZE + position);
+        writtenDataSizes[filePath] = Math.max(writtenDataSizes[filePath], position + arr.byteLength);
     };
     return {
         cleanup,

package/dist/combine-chunks.js

@@ -18,20 +18,6 @@ const audio_codec_1 = require("./options/audio-codec");
 const tmp_dir_1 = require("./tmp-dir");
 const truthy_1 = require("./truthy");
 const validate_number_of_gif_loops_1 = require("./validate-number-of-gif-loops");
-const 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,
-};
 const REMOTION_FILELIST_TOKEN = 'remotion-filelist';
 const internalCombineChunks = async ({ outputLocation: output, onProgress, codec, fps, numberOfGifLoops, audioBitrate, indent, logLevel, binariesDirectory, cancelSignal, metadata, audioFiles, videoFiles, framesPerChunk, audioCodec, preferLossless, everyNthFrame, frameRange, compositionDurationInFrames, sampleRate, }) => {
     (0, validate_number_of_gif_loops_1.validateNumberOfGifLoops)(numberOfGifLoops, codec);
@@ -136,7 +122,6 @@ const internalCombineChunks = async ({ outputLocation: output, onProgress, codec
             binariesDirectory,
             fps,
             cancelSignal,
-            addFaststart: codecSupportsFastStart[codec],
             metadata,
             numberOfGifLoops,
         });

package/dist/create-audio.js

@@ -12,6 +12,7 @@ const compress_audio_1 = require("./compress-audio");
 const delete_directory_1 = require("./delete-directory");
 const logger_1 = require("./logger");
 const merge_audio_track_1 = require("./merge-audio-track");
+const merge_inline_audio_tracks_1 = require("./merge-inline-audio-tracks");
 const audio_codec_1 = require("./options/audio-codec");
 const preprocess_audio_track_1 = require("./preprocess-audio-track");
 const truthy_1 = require("./truthy");
@@ -73,16 +74,29 @@ const createAudio = async ({ assets, onDownload, fps, logLevel, onProgress, down
         sampleRate,
     });
     const inlinedAudio = downloadMap.inlineAudioMixing.getListOfAssets();
+    const mergedInlineAudio = await (0, merge_inline_audio_tracks_1.mergeInlineAudioTracks)({
+        tracks: inlinedAudio,
+        downloadMap,
+        remotionRoot,
+        indent,
+        logLevel,
+        binariesDirectory,
+        cancelSignal,
+        fps,
+        chunkLengthInSeconds,
+        sampleRate,
+    });
     const preprocessed = [
         ...audioTracks.filter(truthy_1.truthy),
-        ...inlinedAudio.map((asset) => ({
-            outName: asset,
-            filter: {
-                filter: null,
-                pad_start: null,
-                pad_end: null,
-            },
-        })),
+        ...(mergedInlineAudio
+            ? [
+                (0, merge_inline_audio_tracks_1.inlineAudioTrackToPreprocessedAudioTrack)({
+                    track: mergedInlineAudio,
+                    relativeToInSamples: 0,
+                    padToDurationInSamples: Math.round(chunkLengthInSeconds * sampleRate),
+                }),
+            ]
+            : []),
     ];
     const merged = path_1.default.join(downloadMap.audioPreprocessing, 'merged.wav');
     const extension = (0, audio_codec_1.getExtensionFromAudioCodec)(audioCodec);