@remotion/renderer 4.0.356 → 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/create-audio.js

@@ -64,6 +64,12 @@ const createAudio = async ({ assets, onDownload, fps, logLevel, onProgress, down
         updateProgress();
         return result;
     }));
+    await downloadMap.inlineAudioMixing.finish({
+        indent,
+        logLevel,
+        binariesDirectory,
+        cancelSignal,
+    });
     const inlinedAudio = downloadMap.inlineAudioMixing.getListOfAssets();
     const preprocessed = [
         ...audioTracks.filter(truthy_1.truthy),

package/dist/esm/index.mjs

@@ -15101,6 +15101,43 @@ import path14 from "node:path";
 // src/sample-rate.ts
 var DEFAULT_SAMPLE_RATE = 48000;
 
+// src/assets/apply-tone-frequency.ts
+var applyToneFrequencyUsingFfmpeg = async ({
+  input,
+  output,
+  toneFrequency,
+  indent,
+  logLevel,
+  binariesDirectory,
+  cancelSignal
+}) => {
+  const filter = `asetrate=${DEFAULT_SAMPLE_RATE}*${toneFrequency},aresample=${DEFAULT_SAMPLE_RATE},atempo=1/${toneFrequency}`;
+  const args = [
+    "-hide_banner",
+    "-i",
+    input,
+    ["-ac", "2"],
+    "-filter:a",
+    filter,
+    ["-c:a", "pcm_s16le"],
+    ["-ar", String(DEFAULT_SAMPLE_RATE)],
+    "-y",
+    output
+  ].flat(2);
+  Log.verbose({ indent, logLevel }, "Changing tone frequency using FFmpeg:", JSON.stringify(args.join(" ")), "Filter:", filter);
+  const startTimestamp = Date.now();
+  const task = callFf({
+    bin: "ffmpeg",
+    args,
+    indent,
+    logLevel,
+    binariesDirectory,
+    cancelSignal
+  });
+  await task;
+  Log.verbose({ indent, logLevel }, "Changed tone frequency using FFmpeg", `${Date.now() - startTimestamp}ms`);
+};
+
 // src/assets/inline-audio-mixing.ts
 var numberTo32BiIntLittleEndian = (num) => {
   return new Uint8Array([
@@ -15115,10 +15152,12 @@ var numberTo16BitLittleEndian = (num) => {
 };
 var BIT_DEPTH = 16;
 var BYTES_PER_SAMPLE = BIT_DEPTH / 8;
+var NUMBER_OF_CHANNELS = 2;
 var makeInlineAudioMixing = (dir) => {
   const folderToAdd = makeAndReturn(dir, "remotion-inline-audio-mixing");
   const openFiles = {};
   const writtenHeaders = {};
+  const toneFrequencies = {};
   const cleanup = () => {
     for (const fd of Object.values(openFiles)) {
       try {
@@ -15148,9 +15187,8 @@ var makeInlineAudioMixing = (dir) => {
       return;
     }
     writtenHeaders[filePath] = true;
-    const expectedDataSize = Math.round((totalNumberOfFrames / fps - trimLeftOffset + trimRightOffset) * asset.numberOfChannels * DEFAULT_SAMPLE_RATE * BYTES_PER_SAMPLE);
+    const expectedDataSize = Math.round((totalNumberOfFrames / fps - trimLeftOffset + trimRightOffset) * NUMBER_OF_CHANNELS * DEFAULT_SAMPLE_RATE * BYTES_PER_SAMPLE);
     const expectedSize = 40 + expectedDataSize;
-    const { numberOfChannels } = asset;
     const fd = openFiles[filePath];
     writeSync(fd, new Uint8Array([82, 73, 70, 70]), 0, 4, 0);
     writeSync(fd, new Uint8Array(numberTo32BiIntLittleEndian(expectedSize)), 0, 4, 4);
@@ -15158,14 +15196,37 @@ var makeInlineAudioMixing = (dir) => {
     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([numberOfChannels, 0]), 0, 2, 22);
+    writeSync(fd, new Uint8Array([NUMBER_OF_CHANNELS, 0]), 0, 2, 22);
     writeSync(fd, new Uint8Array(numberTo32BiIntLittleEndian(DEFAULT_SAMPLE_RATE)), 0, 4, 24);
-    writeSync(fd, new Uint8Array(numberTo32BiIntLittleEndian(DEFAULT_SAMPLE_RATE * numberOfChannels * BYTES_PER_SAMPLE)), 0, 4, 28);
-    writeSync(fd, new Uint8Array(numberTo16BitLittleEndian(numberOfChannels * BYTES_PER_SAMPLE)), 0, 2, 32);
+    writeSync(fd, new Uint8Array(numberTo32BiIntLittleEndian(DEFAULT_SAMPLE_RATE * 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, 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);
   };
+  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 applyToneFrequencyUsingFfmpeg({
+          input: fd,
+          output: tmpFile,
+          toneFrequency: frequency,
+          indent,
+          logLevel,
+          binariesDirectory,
+          cancelSignal
+        });
+        fs12.renameSync(tmpFile, fd);
+      }
+    }
+  };
   const addAsset = ({
     asset,
     fps,
@@ -15182,7 +15243,11 @@ var 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;
@@ -15195,19 +15260,20 @@ var 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 * DEFAULT_SAMPLE_RATE) * asset.numberOfChannels * BYTES_PER_SAMPLE;
+    const position = Math.floor(positionInSeconds * DEFAULT_SAMPLE_RATE) * NUMBER_OF_CHANNELS * BYTES_PER_SAMPLE;
     writeSync(fileDescriptor, arr, 0, arr.byteLength, 44 + position);
   };
   return {
     cleanup,
     addAsset,
-    getListOfAssets
+    getListOfAssets,
+    finish
   };
 };
 
@@ -20726,6 +20792,12 @@ var createAudio = async ({
     updateProgress();
     return result;
   }));
+  await downloadMap.inlineAudioMixing.finish({
+    indent,
+    logLevel,
+    binariesDirectory,
+    cancelSignal
+  });
   const inlinedAudio = downloadMap.inlineAudioMixing.getListOfAssets();
   const preprocessed = [
     ...audioTracks.filter(truthy),
@@ -21300,7 +21372,7 @@ var validateOutputFilename = ({
 
 // src/render-media.ts
 var SLOWEST_FRAME_COUNT = 10;
-var MAX_RECENT_FRAME_TIMINGS = 50;
+var MAX_RECENT_FRAME_TIMINGS = 150;
 var internalRenderMediaRaw = ({
   proResProfile,
   x264Preset,
@@ -21597,10 +21669,14 @@ var internalRenderMediaRaw = ({
       });
     }).then(({ server, cleanupServer }) => {
       cleanupServerFn = cleanupServer;
+      let timeOfLastFrame = Date.now();
       const renderFramesProc = internalRenderFrames({
         composition,
-        onFrameUpdate: (frame, frameIndex, timeToRenderInMilliseconds) => {
+        onFrameUpdate: (frame, frameIndex) => {
           renderedFrames = frame;
+          const now = Date.now();
+          const timeToRenderInMilliseconds = now - timeOfLastFrame;
+          timeOfLastFrame = now;
           recentFrameTimings.push(timeToRenderInMilliseconds);
           if (recentFrameTimings.length > MAX_RECENT_FRAME_TIMINGS) {
             recentFrameTimings.shift();

package/dist/render-media.js

@@ -52,7 +52,7 @@ const validate_scale_1 = require("./validate-scale");
 const validate_videobitrate_1 = require("./validate-videobitrate");
 const wrap_with_error_handling_1 = require("./wrap-with-error-handling");
 const SLOWEST_FRAME_COUNT = 10;
-const MAX_RECENT_FRAME_TIMINGS = 50;
+const MAX_RECENT_FRAME_TIMINGS = 150;
 const internalRenderMediaRaw = ({ proResProfile, x264Preset, crf, composition: compositionWithPossibleUnevenDimensions, serializedInputPropsWithCustomSchema, pixelFormat: userPixelFormat, codec, envVariables, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, muted, enforceAudioTrack, ffmpegOverride, audioBitrate, videoBitrate, encodingMaxRate, encodingBufferSize, audioCodec, concurrency, disallowParallelEncoding, everyNthFrame, imageFormat: provisionalImageFormat, indent, jpegQuality, numberOfGifLoops, onCtrlCExit, preferLossless, serveUrl, server: reusedServer, logLevel, serializedResolvedPropsWithCustomSchema, offthreadVideoCacheSizeInBytes, colorSpace, repro, binariesDirectory, separateAudioTo, forSeamlessAacConcatenation, compositionStart, onBrowserDownload, onArtifact, metadata, hardwareAcceleration, chromeMode, offthreadVideoThreads, mediaCacheSizeInBytes, onLog, }) => {
     var _a, _b;
     const pixelFormat = (_a = userPixelFormat !== null && userPixelFormat !== void 0 ? userPixelFormat : compositionWithPossibleUnevenDimensions.defaultPixelFormat) !== null && _a !== void 0 ? _a : pixel_format_1.DEFAULT_PIXEL_FORMAT;
@@ -310,10 +310,14 @@ const internalRenderMediaRaw = ({ proResProfile, x264Preset, crf, composition: c
         })
             .then(({ server, cleanupServer }) => {
             cleanupServerFn = cleanupServer;
+            let timeOfLastFrame = Date.now();
             const renderFramesProc = (0, render_frames_1.internalRenderFrames)({
                 composition,
-                onFrameUpdate: (frame, frameIndex, timeToRenderInMilliseconds) => {
+                onFrameUpdate: (frame, frameIndex) => {
                     renderedFrames = frame;
+                    const now = Date.now();
+                    const timeToRenderInMilliseconds = now - timeOfLastFrame;
+                    timeOfLastFrame = now;
                     // Track recent frame timings (at most 50)
                     recentFrameTimings.push(timeToRenderInMilliseconds);
                     if (recentFrameTimings.length > MAX_RECENT_FRAME_TIMINGS) {

package/ensure-browser.mjs

@@ -2751,6 +2751,23 @@ var verboseTag = (str) => {
   return isColorSupported() ? chalk.bgBlack(` ${str} `) : `[${str}]`;
 };
 var Log = {
+  formatLogs: (logLevel, options, args) => {
+    return [
+      options.indent ? INDENT_TOKEN : null,
+      options.tag ? verboseTag(options.tag) : null
+    ].filter(truthy).concat(args.map((a) => {
+      if (logLevel === "warn") {
+        return chalk.yellow(a);
+      }
+      if (logLevel === "error") {
+        return chalk.red(a);
+      }
+      if (logLevel === "verbose" || logLevel === "trace") {
+        return chalk.gray(a);
+      }
+      return a;
+    }));
+  },
   trace: (options, ...args) => {
     writeInRepro("trace", ...args);
     if (isEqualOrBelowLogLevel(options.logLevel, "trace")) {
@@ -2758,10 +2775,7 @@ var Log = {
         return process.stdout.write(`
 `);
       }
-      return console.log(...[
-        options.indent ? INDENT_TOKEN : null,
-        options.tag ? verboseTag(options.tag) : null
-      ].filter(truthy).concat(args.map((a) => chalk.gray(a))));
+      return console.log(...Log.formatLogs("trace", options, args));
     }
   },
   verbose: (options, ...args) => {
@@ -2771,10 +2785,7 @@ var Log = {
         return process.stdout.write(`
 `);
       }
-      return console.log(...[
-        options.indent ? INDENT_TOKEN : null,
-        options.tag ? verboseTag(options.tag) : null
-      ].filter(truthy).concat(args.map((a) => chalk.gray(a))));
+      return console.log(...Log.formatLogs("verbose", options, args));
     }
   },
   info: (options, ...args) => {
@@ -2784,7 +2795,7 @@ var Log = {
         return process.stdout.write(`
 `);
       }
-      return console.log(...[options.indent ? INDENT_TOKEN : null].filter(truthy).concat(args ?? []));
+      return console.log(...Log.formatLogs("info", options, args));
     }
   },
   warn: (options, ...args) => {
@@ -2794,7 +2805,7 @@ var Log = {
         return process.stdout.write(`
 `);
       }
-      return console.warn(...[options.indent ? chalk.yellow(INDENT_TOKEN) : null].filter(truthy).concat(args.map((a) => chalk.yellow(a))));
+      return console.warn(...Log.formatLogs("warn", options, args));
     }
   },
   error: (options, ...args) => {
@@ -2804,10 +2815,7 @@ var Log = {
         return process.stdout.write(`
 `);
       }
-      return console.error(...[
-        options.indent ? INDENT_TOKEN : null,
-        options.tag ? verboseTag(options.tag) : null
-      ].filter(truthy).concat(args.map((a) => chalk.red(a))));
+      return console.error(...Log.formatLogs("error", options, args));
     }
   }
 };

package/package.json

@@ -3,7 +3,7 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/renderer"
   },
   "name": "@remotion/renderer",
-  "version": "4.0.356",
+  "version": "4.0.357",
   "description": "Render Remotion videos using Node.js or Bun",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,8 +18,8 @@
     "extract-zip": "2.0.1",
     "source-map": "^0.8.0-beta.0",
     "ws": "8.17.1",
-    "remotion": "4.0.356",
-    "@remotion/streaming": "4.0.356"
+    "remotion": "4.0.357",
+    "@remotion/streaming": "4.0.357"
   },
   "peerDependencies": {
     "react": ">=16.8.0",
@@ -33,17 +33,17 @@
     "react-dom": "19.0.0",
     "@types/ws": "8.5.10",
     "eslint": "9.19.0",
-    "@remotion/example-videos": "4.0.356",
-    "@remotion/eslint-config-internal": "4.0.356"
+    "@remotion/example-videos": "4.0.357",
+    "@remotion/eslint-config-internal": "4.0.357"
   },
   "optionalDependencies": {
-    "@remotion/compositor-linux-arm64-gnu": "4.0.356",
-    "@remotion/compositor-darwin-x64": "4.0.356",
-    "@remotion/compositor-linux-x64-gnu": "4.0.356",
-    "@remotion/compositor-linux-arm64-musl": "4.0.356",
-    "@remotion/compositor-darwin-arm64": "4.0.356",
-    "@remotion/compositor-win32-x64-msvc": "4.0.356",
-    "@remotion/compositor-linux-x64-musl": "4.0.356"
+    "@remotion/compositor-darwin-arm64": "4.0.357",
+    "@remotion/compositor-darwin-x64": "4.0.357",
+    "@remotion/compositor-linux-arm64-gnu": "4.0.357",
+    "@remotion/compositor-linux-arm64-musl": "4.0.357",
+    "@remotion/compositor-linux-x64-gnu": "4.0.357",
+    "@remotion/compositor-linux-x64-musl": "4.0.357",
+    "@remotion/compositor-win32-x64-msvc": "4.0.357"
   },
   "keywords": [
     "remotion",