@remotion/media 4.0.356 → 4.0.358

package/LICENSE.md

@@ -1,49 +0,0 @@
-# Remotion License
-
-In Remotion 5.0, the license will slightly change. [View the changes here](https://github.com/remotion-dev/remotion/pull/3750).
-
----
-
-Depending on the type of your legal entity, you are granted permission to use Remotion for your project. Individuals and small companies are allowed to use Remotion to create videos for free (even commercial), while a company license is required for for-profit organizations of a certain size. This two-tier system was designed to ensure funding for this project while still allowing the source code to be available and the program to be free for most. Read below for the exact terms of use.
-
-- [Free License](#free-license)
-- [Company License](#company-license)
-
-## Free License
-
-Copyright © 2025 [Remotion](https://www.remotion.dev)
-
-### Eligibility
-
-You are eligible to use Remotion for free if you are:
-
-- an individual
-- a for-profit organization with up to 3 employees
-- a non-profit or not-for-profit organization
-- evaluating whether Remotion is a good fit, and are not yet using it in a commercial way
-
-### Allowed use cases
-
-Permission is hereby granted, free of charge, to any person eligible for the "Free License", to use the software non-commercially or commercially for the purpose of creating videos and images and to modify the software to their own liking, for the purpose of fulfilling their custom use case or to contribute bug fixes or improvements back to Remotion.
-
-### Disallowed use cases
-
-It is not allowed to copy or modify Remotion code for the purpose of selling, renting, licensing, relicensing, or sublicensing your own derivate of Remotion.
-
-### Warranty notice
-
-The software is provided "as is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and non-infringement. In no event shall the author or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the software.
-
-### Support
-
-Support is provided on a best-we-can-do basis via GitHub Issues and Discord.
-
-## Company License
-
-You are required to obtain a Company License to use Remotion if you are not within the group of entities eligible for a Free License. This license will enable you to use Remotion for the allowed use cases specified in the Free License, and give you access to prioritized support (read the [Support Policy](https://www.remotion.dev/docs/support)).
-
-Visit [remotion.pro](https://www.remotion.pro/license) for pricing and to buy a license.
-
-### FAQs
-
-Are you not sure whether you need a Company License because of an edge case? Here are some [frequently asked questions](https://www.remotion.pro/faq).

package/dist/convert-audiodata/apply-tonefrequency.d.ts

@@ -1,2 +0,0 @@
-import { type PcmS16AudioData } from './convert-audiodata';
-export declare const applyToneFrequency: (audioData: PcmS16AudioData, toneFrequency: number) => PcmS16AudioData;

package/dist/convert-audiodata/apply-tonefrequency.js

@@ -1,44 +0,0 @@
-import { FORMAT } from './convert-audiodata';
-import { resampleAudioData, TARGET_SAMPLE_RATE } from './resample-audiodata';
-import { wsolaInt16Interleaved } from './wsola';
-export const applyToneFrequency = (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 step1 = {
-        ...audioData,
-        sampleRate: audioData.sampleRate * toneFrequency,
-    };
-    const newNumberOfFrames = Math.round(audioData.numberOfFrames * (TARGET_SAMPLE_RATE / step1.sampleRate));
-    const step2Data = new Int16Array(newNumberOfFrames * audioData.numberOfChannels);
-    const chunkSize = audioData.numberOfFrames / newNumberOfFrames;
-    resampleAudioData({
-        srcNumberOfChannels: step1.numberOfChannels,
-        sourceChannels: step1.data,
-        destination: step2Data,
-        targetFrames: newNumberOfFrames,
-        chunkSize,
-    });
-    const step2AudioData = {
-        data: step2Data,
-        format: FORMAT,
-        numberOfChannels: step1.numberOfChannels,
-        numberOfFrames: newNumberOfFrames,
-        sampleRate: TARGET_SAMPLE_RATE,
-        timestamp: audioData.timestamp,
-    };
-    const step3Data = wsolaInt16Interleaved(step2AudioData.data, step2AudioData.numberOfChannels, toneFrequency);
-    // Target per-channel length and interleave
-    const targetPerChan = Math.max(1, Math.round(step2AudioData.numberOfFrames * toneFrequency));
-    const targetTotal = targetPerChan * step2AudioData.numberOfChannels;
-    return {
-        data: step3Data,
-        numberOfChannels: step2AudioData.numberOfChannels,
-        numberOfFrames: targetTotal,
-        sampleRate: TARGET_SAMPLE_RATE,
-        timestamp: audioData.timestamp,
-    };
-};

package/dist/convert-audiodata/wsola.d.ts

@@ -1,13 +0,0 @@
-/**
- * WSOLA time-scale modification for interleaved Int16 PCM (multi-channel).
- * - Preserves pitch approximately while changing tempo by factor f.
- * - Works for N interleaved channels.
- * - Mitigates head/tail fade-out via overlap-weight normalization and boundary reinforcement.
- *
- * @param input Interleaved Int16 PCM (e.g., LRLRLR... for stereo)
- * @param channels Number of channels (>=1)
- * @param f Tempo factor: >1 = faster/shorter, <1 = slower/longer
- * @param opts Optional tuning parameters
- * @returns Interleaved Int16Array with length ≈ round(input.length * f)
- */
-export declare function wsolaInt16Interleaved(input: Int16Array, channels: number, f: number): Int16Array;

package/dist/convert-audiodata/wsola.js

@@ -1,197 +0,0 @@
-function clamp16(x) {
-    const y = Math.round(x);
-    return y < -32768 ? -32768 : y > 32767 ? 32767 : y;
-}
-/**
- * WSOLA time-scale modification for interleaved Int16 PCM (multi-channel).
- * - Preserves pitch approximately while changing tempo by factor f.
- * - Works for N interleaved channels.
- * - Mitigates head/tail fade-out via overlap-weight normalization and boundary reinforcement.
- *
- * @param input Interleaved Int16 PCM (e.g., LRLRLR... for stereo)
- * @param channels Number of channels (>=1)
- * @param f Tempo factor: >1 = faster/shorter, <1 = slower/longer
- * @param opts Optional tuning parameters
- * @returns Interleaved Int16Array with length ≈ round(input.length * f)
- */
-export function wsolaInt16Interleaved(input, channels, f) {
-    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');
-    // Parameters and sensible defaults
-    const sampleRate = 48000;
-    const frameMs = 30; // 20–40 ms typical
-    const overlapRatio = 0.5;
-    const searchMs = 15; // +/- 8 ms local search
-    const winKind = 'hann';
-    const headReinf = 3;
-    const tailReinf = 3;
-    // Work per-channel
-    const samplesPerChannel = (n / channels) | 0;
-    // Frame and hop sizing
-    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));
-    // Search radius in samples
-    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); // Hamming
-    }
-    // Estimate output length per channel and allocate with extra headroom
-    const estFrames = Math.max(1, Math.ceil(Math.max(0, samplesPerChannel - frameSize) / anaHop) + 1);
-    const estLen = Math.max(0, frameSize + synHop * (estFrames - 1));
-    const extraHead = frameSize * (headReinf + 1);
-    const extraTail = frameSize * (tailReinf + 2);
-    const outLenAlloc = estLen + searchRadius + extraHead + extraTail;
-    const out = Array.from({ length: channels }, () => new Float32Array(outLenAlloc));
-    const outWeight = new Float32Array(outLenAlloc);
-    // Temporary buffers
-    const chanFrames = Array.from({ length: channels }, () => new Float32Array(frameSize));
-    const guideFrame = new Float32Array(frameSize);
-    // Helpers
-    function readChannelFrame(chan, start, dst) {
-        let srcIndex = start * channels + chan;
-        for (let i = 0; i < frameSize; i++) {
-            const pos = start + i;
-            dst[i] = pos >= 0 && pos < samplesPerChannel ? input[srcIndex] : 0;
-            srcIndex += channels;
-        }
-    }
-    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;
-                for (let c = 0; c < channels; c++)
-                    sum += input[base + c];
-                guideFrame[i] = sum / channels;
-            }
-            else {
-                guideFrame[i] = 0;
-            }
-        }
-    }
-    // Find best local alignment around outPos using normalized cross-correlation
-    function bestAlignment(outPoss) {
-        let bestShift = 0;
-        let bestScore = -Infinity;
-        for (let shift = -searchRadius; shift <= searchRadius; shift++) {
-            const pos = outPoss + shift - overlap;
-            let score = 0;
-            let normA = 0;
-            let normB = 0;
-            for (let i = 0; i < overlap; i++) {
-                const idx = pos + i;
-                const outVal = idx >= 0 && idx < outLenAlloc ? out[0][idx] : 0; // channel 0 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;
-    }
-    // Overlap-add a frame for all channels at writeStart with windowing
-    function olaAllChannels(writeStart) {
-        for (let c = 0; c < channels; 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; // track weights once
-                }
-            }
-        }
-    }
-    // 1) Seed: place the first frame at t=0
-    readGuideFrame(0);
-    for (let c = 0; c < channels; c++)
-        readChannelFrame(c, 0, chanFrames[c]);
-    olaAllChannels(0);
-    // 2) Head reinforcement: place extra frames whose writeStart <= 0
-    for (let h = 0; h < headReinf; h++) {
-        // Option 1: reuse the first analysis position to strengthen early region
-        const headIn = Math.min(anaHop * h, Math.max(0, samplesPerChannel - frameSize));
-        readGuideFrame(headIn);
-        for (let c = 0; c < channels; c++)
-            readChannelFrame(c, headIn, chanFrames[c]);
-        // Align around outPos=0 so we bias writeStart near/before 0
-        const shift = bestAlignment(0);
-        const writeStart = shift - overlap; // likely negative; ok, we clamp on write
-        olaAllChannels(writeStart);
-    }
-    // 3) Main WSOLA loop
-    let inPos = anaHop; // next analysis position (we already seeded at 0)
-    let outPos = synHop; // next synthesis position
-    while (inPos < samplesPerChannel - 1) {
-        readGuideFrame(inPos);
-        for (let c = 0; c < channels; c++)
-            readChannelFrame(c, inPos, chanFrames[c]);
-        const shift = bestAlignment(outPos);
-        const writeStart = outPos + shift - overlap;
-        olaAllChannels(writeStart);
-        inPos += anaHop;
-        outPos += synHop;
-        // Safety: if we're very close to capacity, break to handle tail separately
-        if (outPos > outLenAlloc - (frameSize + searchRadius + 8))
-            break;
-    }
-    // 4) Tail reinforcement: ensure the end gets full coverage
-    // Place a few extra frames around the last outPos using the last available input frames.
-    for (let t = 0; t < tailReinf; t++) {
-        const tailIn = Math.max(0, Math.min(samplesPerChannel - frameSize, inPos - anaHop * t));
-        readGuideFrame(tailIn);
-        for (let c = 0; c < channels; c++)
-            readChannelFrame(c, tailIn, chanFrames[c]);
-        const shift = bestAlignment(outPos);
-        const writeStart = outPos + shift - overlap;
-        olaAllChannels(writeStart);
-        outPos += synHop;
-    }
-    // 5) Normalize by accumulated weights BEFORE trimming
-    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;
-        }
-        else {
-            for (let c = 0; c < channels; c++)
-                out[c][i] = 0;
-        }
-    }
-    // 6) Produce final interleaved Int16Array with length ≈ round(n * f)
-    const targetPerChan = Math.max(1, Math.round(samplesPerChannel * f));
-    const targetTotal = targetPerChan * channels;
-    const result = new Int16Array(targetTotal);
-    // Interleave and clamp/round
-    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;
-}

package/dist/get-sink-weak.js

@@ -1,23 +0,0 @@
-import { Internals } from 'remotion';
-import { getSinks } from './video-extraction/get-frames-since-keyframe';
-export const sinkPromises = {};
-export const getSinkWeak = async (src, logLevel) => {
-    let promise = sinkPromises[src];
-    if (!promise) {
-        promise = getSinks(src);
-        sinkPromises[src] = promise;
-    }
-    let awaited = await promise;
-    let deferredValue = awaited.deref();
-    if (!deferredValue) {
-        Internals.Log.verbose({
-            logLevel,
-            tag: '@remotion/media',
-        }, `Sink for ${src} was garbage collected, creating new sink`);
-        promise = getSinks(src);
-        sinkPromises[src] = promise;
-        awaited = await promise;
-        deferredValue = awaited.deref();
-    }
-    return deferredValue;
-};

package/dist/log.d.ts

@@ -1,10 +0,0 @@
-export declare const logLevels: readonly ["trace", "verbose", "info", "warn", "error"];
-export type LogLevel = (typeof logLevels)[number];
-export declare const isEqualOrBelowLogLevel: (currentLevel: LogLevel, level: LogLevel) => boolean;
-export declare const Log: {
-    trace: (logLevel: LogLevel, message?: any, ...optionalParams: any[]) => void;
-    verbose: (logLevel: LogLevel, message?: any, ...optionalParams: any[]) => void;
-    info: (logLevel: LogLevel, message?: any, ...optionalParams: any[]) => void;
-    warn: (logLevel: LogLevel, message?: any, ...optionalParams: any[]) => void;
-    error: (message?: any, ...optionalParams: any[]) => void;
-};

package/dist/log.js

@@ -1,33 +0,0 @@
-/* eslint-disable no-console */
-export const logLevels = ['trace', 'verbose', 'info', 'warn', 'error'];
-const getNumberForLogLevel = (level) => {
-    return logLevels.indexOf(level);
-};
-export const isEqualOrBelowLogLevel = (currentLevel, level) => {
-    return getNumberForLogLevel(currentLevel) <= getNumberForLogLevel(level);
-};
-export const Log = {
-    trace: (logLevel, ...args) => {
-        if (isEqualOrBelowLogLevel(logLevel, 'trace')) {
-            return console.log(...args);
-        }
-    },
-    verbose: (logLevel, ...args) => {
-        if (isEqualOrBelowLogLevel(logLevel, 'verbose')) {
-            return console.log(...args);
-        }
-    },
-    info: (logLevel, ...args) => {
-        if (isEqualOrBelowLogLevel(logLevel, 'info')) {
-            return console.log(...args);
-        }
-    },
-    warn: (logLevel, ...args) => {
-        if (isEqualOrBelowLogLevel(logLevel, 'warn')) {
-            return console.warn(...args);
-        }
-    },
-    error: (...args) => {
-        return console.error(...args);
-    },
-};