@remotion/renderer 4.0.355 → 4.0.357

package/dist/assets/apply-tone-frequency.d.ts

@@ -0,0 +1,11 @@
+import type { LogLevel } from '../log-level';
+import type { CancelSignal } from '../make-cancel-signal';
+export declare const applyToneFrequencyUsingFfmpeg: ({ input, output, toneFrequency, indent, logLevel, binariesDirectory, cancelSignal, }: {
+    input: string;
+    output: string;
+    toneFrequency: number;
+    indent: boolean;
+    logLevel: LogLevel;
+    binariesDirectory: string | null;
+    cancelSignal: CancelSignal | undefined;
+}) => Promise<void>;

package/dist/assets/apply-tone-frequency.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyToneFrequencyUsingFfmpeg = void 0;
+const call_ffmpeg_1 = require("../call-ffmpeg");
+const logger_1 = require("../logger");
+const sample_rate_1 = require("../sample-rate");
+const applyToneFrequencyUsingFfmpeg = async ({ input, output, toneFrequency, indent, logLevel, binariesDirectory, cancelSignal, }) => {
+    const filter = `asetrate=${sample_rate_1.DEFAULT_SAMPLE_RATE}*${toneFrequency},aresample=${sample_rate_1.DEFAULT_SAMPLE_RATE},atempo=1/${toneFrequency}`;
+    const args = [
+        '-hide_banner',
+        '-i',
+        input,
+        ['-ac', '2'],
+        '-filter:a',
+        filter,
+        ['-c:a', 'pcm_s16le'],
+        ['-ar', String(sample_rate_1.DEFAULT_SAMPLE_RATE)],
+        '-y',
+        output,
+    ].flat(2);
+    logger_1.Log.verbose({ indent, logLevel }, 'Changing tone frequency using FFmpeg:', JSON.stringify(args.join(' ')), 'Filter:', filter);
+    const startTimestamp = Date.now();
+    const task = (0, call_ffmpeg_1.callFf)({
+        bin: 'ffmpeg',
+        args,
+        indent,
+        logLevel,
+        binariesDirectory,
+        cancelSignal,
+    });
+    await task;
+    logger_1.Log.verbose({ indent, logLevel }, 'Changed tone frequency using FFmpeg', `${Date.now() - startTimestamp}ms`);
+};
+exports.applyToneFrequencyUsingFfmpeg = applyToneFrequencyUsingFfmpeg;

package/dist/assets/change-tempo.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Time-scale modification (tempo change) with approximate pitch preservation
+ * for interleaved Int16 PCM with multiple channels, using a SOLA/WSOLA-like method.
+ *
+ * @param input Interleaved Int16 PCM samples (e.g., LR LR LR ...)
+ * @param channels Number of channels (e.g., 2 for stereo)
+ * @param f Tempo factor: >1.0 = faster (shorter), <1.0 = slower (longer)
+ * @param opts Optional tuning parameters
+ * @returns Interleaved Int16 PCM with length ≈ round(input.length * f)
+ */
+export declare function atempoInt16Interleaved(input: Int16Array, channels: number, f: number, opts?: {
+    sampleRate?: number;
+    frameMs?: number;
+    overlapRatio?: number;
+    searchMs?: number;
+    window?: 'hann' | 'hamming';
+    clamp?: boolean;
+}): Int16Array;
+/**
+ * Reads a WAV file, applies WSOLA tempo modification, and writes it back.
+ * Ignores the first 44 bytes (WAV header) and treats the rest as interleaved Int16 PCM.
+ *
+ * @param filePath Path to the WAV file to process
+ * @param tempoFactor Tempo factor: >1 = faster/shorter, <1 = slower/longer
+ */
+export declare function processWavFileWithWSOLA(filePath: string, tempoFactor: number): Promise<void>;
+export declare const NUMBER_OF_CHANNELS = 2;
+export declare const applyToneFrequency: (numberOfFrames: number, audioData: Int16Array, toneFrequency: number) => Int16Array;
+export declare const resampleAudioData: ({ sourceChannels, destination, targetFrames, chunkSize, }: {
+    sourceChannels: Int16Array;
+    destination: Int16Array;
+    targetFrames: number;
+    chunkSize: number;
+}) => void;

package/dist/assets/change-tempo.js

@@ -0,0 +1,287 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resampleAudioData = exports.applyToneFrequency = exports.NUMBER_OF_CHANNELS = void 0;
+exports.atempoInt16Interleaved = atempoInt16Interleaved;
+exports.processWavFileWithWSOLA = processWavFileWithWSOLA;
+const promises_1 = __importDefault(require("fs/promises"));
+const sample_rate_1 = require("../sample-rate");
+function clamp16(x) {
+    const y = Math.round(x);
+    return y < -32768 ? -32768 : y > 32767 ? 32767 : y;
+}
+/**
+ * Time-scale modification (tempo change) with approximate pitch preservation
+ * for interleaved Int16 PCM with multiple channels, using a SOLA/WSOLA-like method.
+ *
+ * @param input Interleaved Int16 PCM samples (e.g., LR LR LR ...)
+ * @param channels Number of channels (e.g., 2 for stereo)
+ * @param f Tempo factor: >1.0 = faster (shorter), <1.0 = slower (longer)
+ * @param opts Optional tuning parameters
+ * @returns Interleaved Int16 PCM with length ≈ round(input.length * f)
+ */
+function atempoInt16Interleaved(input, channels, f, opts) {
+    var _a, _b, _c, _d, _e;
+    if (!Number.isFinite(f) || f <= 0) {
+        throw new Error('f must be a positive finite number');
+    }
+    if (!Number.isInteger(channels) || channels <= 0) {
+        throw new Error('channels must be a positive integer');
+    }
+    const n = input.length;
+    if (n === 0)
+        return new Int16Array(0);
+    if (n % channels !== 0) {
+        throw new Error('input length must be a multiple of channels (interleaved PCM)');
+    }
+    // Parameters
+    const sampleRate = (_a = opts === null || opts === void 0 ? void 0 : opts.sampleRate) !== null && _a !== void 0 ? _a : 48000;
+    const frameMs = (_b = opts === null || opts === void 0 ? void 0 : opts.frameMs) !== null && _b !== void 0 ? _b : 30;
+    const overlapRatio = Math.max(0.1, Math.min(0.95, (_c = opts === null || opts === void 0 ? void 0 : opts.overlapRatio) !== null && _c !== void 0 ? _c : 0.55));
+    const searchMs = (_d = opts === null || opts === void 0 ? void 0 : opts.searchMs) !== null && _d !== void 0 ? _d : 8;
+    const winKind = (_e = opts === null || opts === void 0 ? void 0 : opts.window) !== null && _e !== void 0 ? _e : 'hann';
+    // Work in samples per channel
+    const samplesPerChannel = (n / channels) | 0;
+    // Frame sizing and hops (per channel)
+    const frameSize = Math.max(128, Math.floor((sampleRate * frameMs) / 1000));
+    const overlap = Math.floor(frameSize * overlapRatio);
+    const anaHop = Math.max(1, frameSize - overlap);
+    const synHop = Math.max(1, Math.round(anaHop * f));
+    const searchRadius = Math.max(0, Math.floor((sampleRate * searchMs) / 1000));
+    // Window
+    const win = new Float32Array(frameSize);
+    for (let i = 0; i < frameSize; i++) {
+        const x = (Math.PI * 2 * i) / (frameSize - 1);
+        win[i] =
+            winKind === 'hann' ? 0.5 * (1 - Math.cos(x)) : 0.54 - 0.46 * Math.cos(x);
+    }
+    // Output buffers as float accumulators per channel
+    const estFrames = Math.ceil((samplesPerChannel - frameSize) / anaHop) + 1;
+    const estLen = Math.max(0, frameSize + synHop * (estFrames - 1));
+    const outLenAlloc = estLen + frameSize + searchRadius + 16;
+    const out = Array.from({ length: channels }, () => new Float32Array(outLenAlloc));
+    const outWeight = new Float32Array(outLenAlloc);
+    // Helper: read one channel’s frame from interleaved PCM
+    function readChannelFrame(chan, start, dst) {
+        // start is per-channel sample index
+        let srcIndex = start * channels + chan;
+        for (let i = 0; i < frameSize; i++) {
+            const pos = start + i;
+            let v = 0;
+            if (pos >= 0 && pos < samplesPerChannel) {
+                v = input[srcIndex];
+            }
+            dst[i] = v;
+            srcIndex += channels;
+        }
+    }
+    // Build a mono guide frame (mid/mono mix) to drive alignment
+    const guideFrame = new Float32Array(frameSize);
+    function readGuideFrame(start) {
+        for (let i = 0; i < frameSize; i++) {
+            const pos = start + i;
+            if (pos >= 0 && pos < samplesPerChannel) {
+                let sum = 0;
+                const base = (pos * channels) | 0;
+                for (let c = 0; c < channels; c++) {
+                    sum += input[base + c];
+                }
+                guideFrame[i] = sum / channels;
+            }
+            else {
+                guideFrame[i] = 0;
+            }
+        }
+    }
+    // Cross-correlation on overlap region using guide to find best local alignment
+    function bestAlignment(outPosition, baseShift) {
+        let bestShift = baseShift;
+        let bestScore = -Infinity;
+        for (let shift = -searchRadius; shift <= searchRadius; shift++) {
+            const pos = outPosition + shift - overlap;
+            let score = 0;
+            let normA = 0;
+            let normB = 0;
+            for (let i = 0; i < overlap; i++) {
+                const outIdx = pos + i;
+                const outVal = outIdx >= 0 && outIdx < outLenAlloc ? out[0][outIdx] : 0; // use channel 0 accumulator as proxy
+                const frmVal = guideFrame[i];
+                score += outVal * frmVal;
+                normA += outVal * outVal;
+                normB += frmVal * frmVal;
+            }
+            const denom = Math.sqrt((normA || 1e-9) * (normB || 1e-9));
+            const corr = score / denom;
+            if (corr > bestScore) {
+                bestScore = corr;
+                bestShift = shift;
+            }
+        }
+        return bestShift;
+    }
+    // Temp buffers per channel
+    const chanFrames = Array.from({ length: channels }, () => new Float32Array(frameSize));
+    let inPos = 0; // per-channel sample index
+    let outPos = 0; // per-channel sample index in accumulators
+    // First frame: place directly
+    readGuideFrame(0);
+    for (let c = 0; c < channels; c++) {
+        readChannelFrame(c, 0, chanFrames[c]);
+        for (let i = 0; i < frameSize; i++) {
+            const w = win[i];
+            const idx = i; // write starting at 0
+            out[c][idx] += chanFrames[c][i] * w;
+            if (c === 0)
+                outWeight[idx] += w;
+        }
+    }
+    inPos += anaHop;
+    outPos += synHop;
+    // Process remaining frames
+    while (inPos < samplesPerChannel - 1) {
+        readGuideFrame(inPos);
+        // Find best alignment using guide
+        const shift = bestAlignment(outPos, 0);
+        const writeStart = outPos + shift - overlap;
+        // Windowed overlap-add for each channel using same alignment
+        for (let c = 0; c < channels; c++) {
+            readChannelFrame(c, inPos, chanFrames[c]);
+            for (let i = 0; i < frameSize; i++) {
+                const idx = writeStart + i;
+                if (idx >= 0 && idx < outLenAlloc) {
+                    const w = win[i];
+                    out[c][idx] += chanFrames[c][i] * w;
+                    if (c === 0)
+                        outWeight[idx] += w;
+                }
+            }
+        }
+        inPos += anaHop;
+        outPos += synHop;
+        if (outPos + frameSize + searchRadius + 8 >= outLenAlloc)
+            break;
+    }
+    // Normalize by accumulated window weights
+    for (let i = 0; i < outLenAlloc; i++) {
+        const w = outWeight[i];
+        if (w > 1e-9) {
+            const inv = 1 / w;
+            for (let c = 0; c < channels; c++) {
+                out[c][i] *= inv;
+            }
+        }
+    }
+    // Target per-channel length and interleave
+    const targetPerChan = Math.max(1, Math.round(samplesPerChannel * f));
+    const targetTotal = targetPerChan * channels;
+    const result = new Int16Array(targetTotal);
+    // Clamp/convert and interleave
+    for (let i = 0; i < targetPerChan; i++) {
+        for (let c = 0; c < channels; c++) {
+            const v = i < out[c].length ? out[c][i] : 0;
+            const y = clamp16(v);
+            result[i * channels + c] = y;
+        }
+    }
+    return result;
+}
+/**
+ * Reads a WAV file, applies WSOLA tempo modification, and writes it back.
+ * Ignores the first 44 bytes (WAV header) and treats the rest as interleaved Int16 PCM.
+ *
+ * @param filePath Path to the WAV file to process
+ * @param tempoFactor Tempo factor: >1 = faster/shorter, <1 = slower/longer
+ */
+async function processWavFileWithWSOLA(filePath, tempoFactor) {
+    // Read the file
+    const fileBuffer = await promises_1.default.readFile(filePath);
+    // Skip first 44 bytes (WAV header) and create Int16Array
+    const audioData = new Int16Array(fileBuffer.buffer, 44);
+    // Apply WSOLA with 2 channels (stereo)
+    const processedAudio = (0, exports.applyToneFrequency)(audioData.length / 2, audioData, tempoFactor);
+    // Create new buffer with original header + processed audio
+    const newBuffer = new Uint8Array(44 + processedAudio.length * 2);
+    // Copy original header (first 44 bytes)
+    newBuffer.set(fileBuffer.subarray(0, 44), 0);
+    // Copy processed audio data
+    const processedBytes = new Uint8Array(processedAudio.buffer);
+    newBuffer.set(processedBytes, 44);
+    // Write the processed file back
+    await promises_1.default.writeFile(filePath, newBuffer);
+}
+exports.NUMBER_OF_CHANNELS = 2;
+const applyToneFrequency = (numberOfFrames, audioData, toneFrequency) => {
+    // In FFmpeg, we apply toneFrequency as follows:
+    // `asetrate=${DEFAULT_SAMPLE_RATE}*${toneFrequency},aresample=${DEFAULT_SAMPLE_RATE},atempo=1/${toneFrequency}`
+    // So there are 2 steps:
+    // 1. Change the assumed sample rate
+    // 2. Resample to 48Khz
+    // 3. Apply playback rate
+    const step1SampleRate = sample_rate_1.DEFAULT_SAMPLE_RATE * toneFrequency;
+    const newNumberOfFrames = Math.round(numberOfFrames * (sample_rate_1.DEFAULT_SAMPLE_RATE / step1SampleRate));
+    const step2Data = new Int16Array(newNumberOfFrames * exports.NUMBER_OF_CHANNELS);
+    const chunkSize = numberOfFrames / newNumberOfFrames;
+    (0, exports.resampleAudioData)({
+        sourceChannels: audioData,
+        destination: step2Data,
+        targetFrames: newNumberOfFrames,
+        chunkSize,
+    });
+    const step3Data = atempoInt16Interleaved(step2Data, exports.NUMBER_OF_CHANNELS, toneFrequency, {
+        sampleRate: 48000,
+    });
+    return step3Data;
+};
+exports.applyToneFrequency = applyToneFrequency;
+const fixFloatingPoint = (value) => {
+    if (value % 1 < 0.0000001) {
+        return Math.floor(value);
+    }
+    if (value % 1 > 0.9999999) {
+        return Math.ceil(value);
+    }
+    return value;
+};
+const resampleAudioData = ({ sourceChannels, destination, targetFrames, chunkSize, }) => {
+    const getSourceValues = (startUnfixed, endUnfixed, channelIndex) => {
+        const start = fixFloatingPoint(startUnfixed);
+        const end = fixFloatingPoint(endUnfixed);
+        const startFloor = Math.floor(start);
+        const startCeil = Math.ceil(start);
+        const startFraction = start - startFloor;
+        const endFraction = end - Math.floor(end);
+        const endFloor = Math.floor(end);
+        let weightedSum = 0;
+        let totalWeight = 0;
+        // Handle first fractional sample
+        if (startFraction > 0) {
+            const firstSample = sourceChannels[startFloor * exports.NUMBER_OF_CHANNELS + channelIndex];
+            weightedSum += firstSample * (1 - startFraction);
+            totalWeight += 1 - startFraction;
+        }
+        // Handle full samples
+        for (let k = startCeil; k < endFloor; k++) {
+            const num = sourceChannels[k * exports.NUMBER_OF_CHANNELS + channelIndex];
+            weightedSum += num;
+            totalWeight += 1;
+        }
+        // Handle last fractional sample
+        if (endFraction > 0) {
+            const lastSample = sourceChannels[endFloor * exports.NUMBER_OF_CHANNELS + channelIndex];
+            weightedSum += lastSample * endFraction;
+            totalWeight += endFraction;
+        }
+        const average = weightedSum / totalWeight;
+        return average;
+    };
+    for (let newFrameIndex = 0; newFrameIndex < targetFrames; newFrameIndex++) {
+        const start = newFrameIndex * chunkSize;
+        const end = start + chunkSize;
+        for (let i = 0; i < exports.NUMBER_OF_CHANNELS; i++) {
+            destination[newFrameIndex * exports.NUMBER_OF_CHANNELS + i] = getSourceValues(start, end, i);
+        }
+    }
+};
+exports.resampleAudioData = resampleAudioData;

package/dist/assets/change-tonefrequency.d.ts

@@ -0,0 +1,2 @@
+export declare const NUMBER_OF_CHANNELS = 2;
+export declare const applyToneFrequency: (numberOfFrames: number, audioData: Int16Array, toneFrequency: number) => Int16Array;

package/dist/assets/change-tonefrequency.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyToneFrequency = exports.NUMBER_OF_CHANNELS = void 0;
+const sample_rate_1 = require("../sample-rate");
+const change_tempo_1 = require("./change-tempo");
+const resample_audiodata_1 = require("./resample-audiodata");
+exports.NUMBER_OF_CHANNELS = 2;
+const applyToneFrequency = (numberOfFrames, audioData, toneFrequency) => {
+    // In FFmpeg, we apply toneFrequency as follows:
+    // `asetrate=${DEFAULT_SAMPLE_RATE}*${toneFrequency},aresample=${DEFAULT_SAMPLE_RATE},atempo=1/${toneFrequency}`
+    // So there are 2 steps:
+    // 1. Change the assumed sample rate
+    // 2. Resample to 48Khz
+    // 3. Apply playback rate
+    const step1SampleRate = sample_rate_1.DEFAULT_SAMPLE_RATE * toneFrequency;
+    const newNumberOfFrames = Math.round(numberOfFrames * (sample_rate_1.DEFAULT_SAMPLE_RATE / step1SampleRate));
+    const step2Data = new Int16Array(newNumberOfFrames * exports.NUMBER_OF_CHANNELS);
+    const chunkSize = numberOfFrames / newNumberOfFrames;
+    (0, resample_audiodata_1.resampleAudioData)({
+        sourceChannels: audioData,
+        destination: step2Data,
+        targetFrames: newNumberOfFrames,
+        chunkSize,
+    });
+    const step3Data = (0, change_tempo_1.wsolaInt16Interleaved)(step2Data, exports.NUMBER_OF_CHANNELS, toneFrequency);
+    return step3Data;
+};
+exports.applyToneFrequency = applyToneFrequency;

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

@@ -1,4 +1,6 @@
 import type { InlineAudioAsset } from 'remotion/no-react';
+import type { LogLevel } from '../log-level';
+import type { CancelSignal } from '../make-cancel-signal';
 export declare const makeInlineAudioMixing: (dir: string) => {
     cleanup: () => void;
     addAsset: ({ asset, fps, totalNumberOfFrames, firstFrame, trimLeftOffset, trimRightOffset, }: {
@@ -10,5 +12,11 @@ export declare const makeInlineAudioMixing: (dir: string) => {
         trimRightOffset: number;
     }) => void;
     getListOfAssets: () => string[];
+    finish: ({ binariesDirectory, indent, logLevel, cancelSignal, }: {
+        indent: boolean;
+        logLevel: LogLevel;
+        binariesDirectory: string | null;
+        cancelSignal: CancelSignal | undefined;
+    }) => Promise<void>;
 };
 export type InlineAudioMixing = ReturnType<typeof makeInlineAudioMixing>;

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

@@ -41,6 +41,7 @@ const node_fs_1 = __importStar(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const delete_directory_1 = require("../delete-directory");
 const sample_rate_1 = require("../sample-rate");
+const apply_tone_frequency_1 = require("./apply-tone-frequency");
 const download_map_1 = require("./download-map");
 const numberTo32BiIntLittleEndian = (num) => {
     return new Uint8Array([
@@ -55,11 +56,13 @@ const numberTo16BitLittleEndian = (num) => {
 };
 const BIT_DEPTH = 16;
 const BYTES_PER_SAMPLE = BIT_DEPTH / 8;
+const NUMBER_OF_CHANNELS = 2;
 const makeInlineAudioMixing = (dir) => {
     const folderToAdd = (0, download_map_1.makeAndReturn)(dir, 'remotion-inline-audio-mixing');
     // asset id -> file descriptor
     const openFiles = {};
     const writtenHeaders = {};
+    const toneFrequencies = {};
     const cleanup = () => {
         for (const fd of Object.values(openFiles)) {
             try {
@@ -85,11 +88,10 @@ const makeInlineAudioMixing = (dir) => {
         }
         writtenHeaders[filePath] = true;
         const expectedDataSize = Math.round((totalNumberOfFrames / fps - trimLeftOffset + trimRightOffset) *
-            asset.numberOfChannels *
+            NUMBER_OF_CHANNELS *
             sample_rate_1.DEFAULT_SAMPLE_RATE *
             BYTES_PER_SAMPLE);
         const expectedSize = 40 + expectedDataSize;
-        const { numberOfChannels } = asset;
         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
@@ -97,14 +99,32 @@ const makeInlineAudioMixing = (dir) => {
         (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([numberOfChannels, 0x00]), 0, 2, 22); // Number of channels
+        (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(sample_rate_1.DEFAULT_SAMPLE_RATE)), 0, 4, 24); // Sample rate
-        (0, node_fs_1.writeSync)(fd, new Uint8Array(numberTo32BiIntLittleEndian(sample_rate_1.DEFAULT_SAMPLE_RATE * numberOfChannels * BYTES_PER_SAMPLE)), 0, 4, 28); // Byte rate
-        (0, node_fs_1.writeSync)(fd, new Uint8Array(numberTo16BitLittleEndian(numberOfChannels * BYTES_PER_SAMPLE)), 0, 2, 32); // Block align
+        (0, node_fs_1.writeSync)(fd, new Uint8Array(numberTo32BiIntLittleEndian(sample_rate_1.DEFAULT_SAMPLE_RATE * 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, 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
     };
+    const finish = async ({ binariesDirectory, indent, logLevel, cancelSignal, }) => {
+        for (const fd of Object.keys(openFiles)) {
+            const frequency = toneFrequencies[fd];
+            if (frequency !== 1) {
+                const tmpFile = fd.replace(/.wav$/, '-tmp.wav');
+                await (0, apply_tone_frequency_1.applyToneFrequencyUsingFfmpeg)({
+                    input: fd,
+                    output: tmpFile,
+                    toneFrequency: frequency,
+                    indent,
+                    logLevel,
+                    binariesDirectory,
+                    cancelSignal,
+                });
+                node_fs_1.default.renameSync(tmpFile, fd);
+            }
+        }
+    };
     const addAsset = ({ asset, fps, totalNumberOfFrames, firstFrame, trimLeftOffset, trimRightOffset, }) => {
         ensureAsset({
             asset,
@@ -114,7 +134,12 @@ const makeInlineAudioMixing = (dir) => {
             trimRightOffset,
         });
         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;
         let arr = new Int16Array(asset.audio);
         const isFirst = asset.frame === firstFrame;
         const isLast = asset.frame === totalNumberOfFrames + firstFrame - 1;
@@ -129,14 +154,18 @@ const makeInlineAudioMixing = (dir) => {
             throw new Error(`samplesToShaveFromStart should be approximately an integer, is ${samplesToShaveFromStart}`);
         }
         if (isFirst) {
-            arr = arr.slice(Math.round(samplesToShaveFromStart) * asset.numberOfChannels);
+            arr = arr.slice(Math.round(samplesToShaveFromStart) * NUMBER_OF_CHANNELS);
         }
         if (isLast) {
-            arr = arr.slice(0, arr.length + Math.round(samplesToShaveFromEnd) * asset.numberOfChannels);
+            arr = arr.slice(0, arr.length + Math.round(samplesToShaveFromEnd) * NUMBER_OF_CHANNELS);
         }
         const positionInSeconds = (asset.frame - firstFrame) / fps - (isFirst ? 0 : trimLeftOffset);
-        const position = Math.round(positionInSeconds * sample_rate_1.DEFAULT_SAMPLE_RATE) *
-            asset.numberOfChannels *
+        // 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(positionInSeconds * sample_rate_1.DEFAULT_SAMPLE_RATE) *
+            NUMBER_OF_CHANNELS *
             BYTES_PER_SAMPLE;
         (0, node_fs_1.writeSync)(
         // fs
@@ -154,6 +183,7 @@ const makeInlineAudioMixing = (dir) => {
         cleanup,
         addAsset,
         getListOfAssets,
+        finish,
     };
 };
 exports.makeInlineAudioMixing = makeInlineAudioMixing;

package/dist/assets/resample-audiodata.d.ts

@@ -0,0 +1,6 @@
+export declare const resampleAudioData: ({ sourceChannels, destination, targetFrames, chunkSize, }: {
+    sourceChannels: Int16Array;
+    destination: Int16Array;
+    targetFrames: number;
+    chunkSize: number;
+}) => void;

package/dist/assets/resample-audiodata.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resampleAudioData = void 0;
+const change_tempo_1 = require("./change-tempo");
+const fixFloatingPoint = (value) => {
+    if (value % 1 < 0.0000001) {
+        return Math.floor(value);
+    }
+    if (value % 1 > 0.9999999) {
+        return Math.ceil(value);
+    }
+    return value;
+};
+const resampleAudioData = ({ sourceChannels, destination, targetFrames, chunkSize, }) => {
+    const getSourceValues = (startUnfixed, endUnfixed, channelIndex) => {
+        const start = fixFloatingPoint(startUnfixed);
+        const end = fixFloatingPoint(endUnfixed);
+        const startFloor = Math.floor(start);
+        const startCeil = Math.ceil(start);
+        const startFraction = start - startFloor;
+        const endFraction = end - Math.floor(end);
+        const endFloor = Math.floor(end);
+        let weightedSum = 0;
+        let totalWeight = 0;
+        // Handle first fractional sample
+        if (startFraction > 0) {
+            const firstSample = sourceChannels[startFloor * change_tempo_1.NUMBER_OF_CHANNELS + channelIndex];
+            weightedSum += firstSample * (1 - startFraction);
+            totalWeight += 1 - startFraction;
+        }
+        // Handle full samples
+        for (let k = startCeil; k < endFloor; k++) {
+            const num = sourceChannels[k * change_tempo_1.NUMBER_OF_CHANNELS + channelIndex];
+            weightedSum += num;
+            totalWeight += 1;
+        }
+        // Handle last fractional sample
+        if (endFraction > 0) {
+            const lastSample = sourceChannels[endFloor * change_tempo_1.NUMBER_OF_CHANNELS + channelIndex];
+            weightedSum += lastSample * endFraction;
+            totalWeight += endFraction;
+        }
+        const average = weightedSum / totalWeight;
+        return average;
+    };
+    for (let newFrameIndex = 0; newFrameIndex < targetFrames; newFrameIndex++) {
+        const start = newFrameIndex * chunkSize;
+        const end = start + chunkSize;
+        for (let i = 0; i < change_tempo_1.NUMBER_OF_CHANNELS; i++) {
+            destination[newFrameIndex * change_tempo_1.NUMBER_OF_CHANNELS + i] = getSourceValues(start, end, i);
+        }
+    }
+};
+exports.resampleAudioData = resampleAudioData;

package/dist/assets/types.d.ts

@@ -6,7 +6,7 @@ export type UnsafeAsset = Omit<AudioOrVideoAsset, 'frame' | 'id' | 'volume' | 'm
     volume: number[];
     id: string;
     playbackRate: number;
-    toneFrequency: number | null;
+    toneFrequency: number;
     audioStreamIndex: number;
 };
 export type AssetVolume = number | number[];

package/dist/browser/Browser.d.ts

@@ -15,7 +15,7 @@
  */
 import { BrowserLog } from '../browser-log';
 import type { LogLevel } from '../log-level';
-import type { Page } from './BrowserPage';
+import type { OnLog, Page } from './BrowserPage';
 import type { BrowserRunner } from './BrowserRunner';
 import type { Connection } from './Connection';
 import { EventEmitter } from './EventEmitter';
@@ -52,19 +52,21 @@ export declare class HeadlessBrowser extends EventEmitter {
         runner: BrowserRunner;
     });
     browserContexts(): BrowserContext[];
-    newPage({ context, logLevel, indent, pageIndex, onBrowserLog, }: {
+    newPage({ context, logLevel, indent, pageIndex, onBrowserLog, onLog, }: {
         context: SourceMapGetter;
         logLevel: LogLevel;
         indent: boolean;
         pageIndex: number;
         onBrowserLog: null | ((log: BrowserLog) => void);
+        onLog: OnLog;
     }): Promise<Page>;
-    _createPageInContext({ context, logLevel, indent, pageIndex, onBrowserLog, }: {
+    _createPageInContext({ context, logLevel, indent, pageIndex, onBrowserLog, onLog, }: {
         context: SourceMapGetter;
         logLevel: LogLevel;
         indent: boolean;
         pageIndex: number;
         onBrowserLog: null | ((log: BrowserLog) => void);
+        onLog: OnLog;
     }): Promise<Page>;
     targets(): Target[];
     waitForTarget(predicate: (x: Target) => boolean | Promise<boolean>, options?: WaitForTargetOptions): Promise<Target>;
@@ -82,12 +84,13 @@ export declare class BrowserContext extends EventEmitter {
         timeout?: number;
     }): Promise<Target>;
     pages(): Promise<Page[]>;
-    newPage({ context, logLevel, indent, pageIndex, onBrowserLog, }: {
+    newPage({ context, logLevel, indent, pageIndex, onBrowserLog, onLog, }: {
         context: SourceMapGetter;
         logLevel: LogLevel;
         indent: boolean;
         pageIndex: number;
         onBrowserLog: null | ((log: BrowserLog) => void);
+        onLog: OnLog;
     }): Promise<Page>;
     browser(): HeadlessBrowser;
 }