@remotion/media 4.0.403 → 4.0.404

package/dist/convert-audiodata/resample-audiodata.js

@@ -1,94 +0,0 @@
-// Remotion exports all videos with 2 channels.
-export const TARGET_NUMBER_OF_CHANNELS = 2;
-// Remotion exports all videos with 48kHz sample rate.
-export const TARGET_SAMPLE_RATE = 48000;
-const fixFloatingPoint = (value) => {
-    if (value % 1 < 0.0000001) {
-        return Math.floor(value);
-    }
-    if (value % 1 > 0.9999999) {
-        return Math.ceil(value);
-    }
-    return value;
-};
-export const resampleAudioData = ({ srcNumberOfChannels, 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 * srcNumberOfChannels + channelIndex];
-            weightedSum += firstSample * (1 - startFraction);
-            totalWeight += 1 - startFraction;
-        }
-        // Handle full samples
-        for (let k = startCeil; k < endFloor; k++) {
-            const num = sourceChannels[k * srcNumberOfChannels + channelIndex];
-            weightedSum += num;
-            totalWeight += 1;
-        }
-        // Handle last fractional sample
-        if (endFraction > 0) {
-            const lastSample = sourceChannels[endFloor * srcNumberOfChannels + 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;
-        if (TARGET_NUMBER_OF_CHANNELS === srcNumberOfChannels) {
-            for (let i = 0; i < srcNumberOfChannels; i++) {
-                destination[newFrameIndex * srcNumberOfChannels + i] = getSourceValues(start, end, i);
-            }
-        }
-        // The following formulas were taken from Mediabunnys audio resampler:
-        // https://github.com/Vanilagy/mediabunny/blob/b9f7ab2fa2b9167784cbded044d466185308999f/src/conversion.ts
-        // Mono to Stereo: M -> L, M -> R
-        if (srcNumberOfChannels === 1) {
-            const m = getSourceValues(start, end, 0);
-            destination[newFrameIndex * 2 + 0] = m;
-            destination[newFrameIndex * 2 + 1] = m;
-        }
-        // Quad to Stereo: 0.5 * (L + SL), 0.5 * (R + SR)
-        else if (srcNumberOfChannels === 4) {
-            const l = getSourceValues(start, end, 0);
-            const r = getSourceValues(start, end, 1);
-            const sl = getSourceValues(start, end, 2);
-            const sr = getSourceValues(start, end, 3);
-            const l2 = 0.5 * (l + sl);
-            const r2 = 0.5 * (r + sr);
-            destination[newFrameIndex * 2 + 0] = l2;
-            destination[newFrameIndex * 2 + 1] = r2;
-        }
-        // 5.1 to Stereo: L + sqrt(1/2) * (C + SL), R + sqrt(1/2) * (C + SR)
-        else if (srcNumberOfChannels === 6) {
-            const l = getSourceValues(start, end, 0);
-            const r = getSourceValues(start, end, 1);
-            const c = getSourceValues(start, end, 2);
-            const sl = getSourceValues(start, end, 3);
-            const sr = getSourceValues(start, end, 4);
-            const sq = Math.sqrt(1 / 2);
-            const l2 = l + sq * (c + sl);
-            const r2 = r + sq * (c + sr);
-            destination[newFrameIndex * 2 + 0] = l2;
-            destination[newFrameIndex * 2 + 1] = r2;
-        }
-        // Discrete fallback: direct mapping with zero-fill or drop
-        else {
-            for (let i = 0; i < srcNumberOfChannels; i++) {
-                destination[newFrameIndex * TARGET_NUMBER_OF_CHANNELS + i] =
-                    getSourceValues(start, end, i);
-            }
-        }
-    }
-};

package/dist/debug-overlay/preview-overlay.js

@@ -1,44 +0,0 @@
-export const drawPreviewOverlay = ({ context, audioTime, audioContextState, audioSyncAnchor, playing, audioIteratorManager, videoIteratorManager, }) => {
-    // Collect all lines to be rendered
-    const lines = [
-        'Debug overlay',
-        `Video iterators created: ${videoIteratorManager?.getVideoIteratorsCreated()}`,
-        `Audio iterators created: ${audioIteratorManager?.getAudioIteratorsCreated()}`,
-        `Frames rendered: ${videoIteratorManager?.getFramesRendered()}`,
-        `Audio context state: ${audioContextState}`,
-        audioTime
-            ? `Audio time: ${(audioTime - audioSyncAnchor).toFixed(3)}s`
-            : null,
-    ].filter(Boolean);
-    if (audioIteratorManager) {
-        const queuedPeriod = audioIteratorManager
-            .getAudioBufferIterator()
-            ?.getQueuedPeriod();
-        const numberOfChunksAfterResuming = audioIteratorManager
-            ?.getAudioBufferIterator()
-            ?.getNumberOfChunksAfterResuming();
-        if (queuedPeriod && audioTime) {
-            lines.push(`Audio queued until: ${(queuedPeriod.until - (audioTime - audioSyncAnchor)).toFixed(3)}s`);
-        }
-        else if (numberOfChunksAfterResuming) {
-            lines.push(`Audio chunks for after resuming: ${numberOfChunksAfterResuming}`);
-        }
-        lines.push(`Playing: ${playing}`);
-    }
-    const lineHeight = 30; // px, should match or exceed font size
-    const boxPaddingX = 10;
-    const boxPaddingY = 10;
-    const boxLeft = 20;
-    const boxTop = 20;
-    const boxWidth = 600;
-    const boxHeight = lines.length * lineHeight + 2 * boxPaddingY;
-    // Draw background for text legibility
-    context.fillStyle = 'rgba(0, 0, 0, 1)';
-    context.fillRect(boxLeft, boxTop, boxWidth, boxHeight);
-    context.fillStyle = 'white';
-    context.font = '24px sans-serif';
-    context.textBaseline = 'top';
-    for (let i = 0; i < lines.length; i++) {
-        context.fillText(lines[i], boxLeft + boxPaddingX, boxTop + boxPaddingY + i * lineHeight);
-    }
-};

package/dist/extract-frame-and-audio.js

@@ -1,86 +0,0 @@
-import { extractAudio } from './audio-extraction/extract-audio';
-import { isNetworkError } from './is-type-of-error';
-import { extractFrame } from './video-extraction/extract-frame';
-import { rotateFrame } from './video-extraction/rotate-frame';
-export const extractFrameAndAudio = async ({ src, timeInSeconds, logLevel, durationInSeconds, playbackRate, includeAudio, includeVideo, loop, audioStreamIndex, trimAfter, trimBefore, fps, maxCacheSize, }) => {
-    try {
-        const [video, audio] = await Promise.all([
-            includeVideo
-                ? extractFrame({
-                    src,
-                    timeInSeconds,
-                    logLevel,
-                    loop,
-                    trimAfter,
-                    playbackRate,
-                    trimBefore,
-                    fps,
-                    maxCacheSize,
-                })
-                : null,
-            includeAudio
-                ? extractAudio({
-                    src,
-                    timeInSeconds,
-                    durationInSeconds,
-                    logLevel,
-                    loop,
-                    playbackRate,
-                    audioStreamIndex,
-                    trimAfter,
-                    fps,
-                    trimBefore,
-                    maxCacheSize,
-                })
-                : null,
-        ]);
-        if (video?.type === 'cannot-decode') {
-            return {
-                type: 'cannot-decode',
-                durationInSeconds: video.durationInSeconds,
-            };
-        }
-        if (video?.type === 'unknown-container-format') {
-            return { type: 'unknown-container-format' };
-        }
-        if (video?.type === 'cannot-decode-alpha') {
-            return {
-                type: 'cannot-decode-alpha',
-                durationInSeconds: video.durationInSeconds,
-            };
-        }
-        if (video?.type === 'network-error') {
-            return { type: 'network-error' };
-        }
-        if (audio === 'unknown-container-format') {
-            return { type: 'unknown-container-format' };
-        }
-        if (audio === 'network-error') {
-            return { type: 'network-error' };
-        }
-        if (audio === 'cannot-decode') {
-            return {
-                type: 'cannot-decode',
-                durationInSeconds: video?.type === 'success' ? video.durationInSeconds : null,
-            };
-        }
-        return {
-            type: 'success',
-            frame: video?.sample
-                ? await rotateFrame({
-                    frame: video.sample.toVideoFrame(),
-                    rotation: video.sample.rotation,
-                })
-                : null,
-            audio: audio?.data ?? null,
-            durationInSeconds: audio?.durationInSeconds ?? null,
-        };
-    }
-    catch (err) {
-        const error = err;
-        if (isNetworkError(error)) {
-            return { type: 'network-error' };
-        }
-        throw err;
-    }
-};

package/dist/get-sink.js

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

package/dist/get-time-in-seconds.js

@@ -1,40 +0,0 @@
-import { Internals } from 'remotion';
-export const getTimeInSeconds = ({ loop, mediaDurationInSeconds, unloopedTimeInSeconds, src, trimAfter, trimBefore, fps, playbackRate, ifNoMediaDuration, }) => {
-    if (mediaDurationInSeconds === null && loop && ifNoMediaDuration === 'fail') {
-        throw new Error(`Could not determine duration of ${src}, but "loop" was set.`);
-    }
-    const loopDuration = loop
-        ? Internals.calculateMediaDuration({
-            trimAfter,
-            mediaDurationInFrames: mediaDurationInSeconds
-                ? mediaDurationInSeconds * fps
-                : Infinity,
-            // Playback rate was already specified before
-            playbackRate: 1,
-            trimBefore,
-        }) / fps
-        : Infinity;
-    const timeInSeconds = (unloopedTimeInSeconds * playbackRate) % loopDuration;
-    if ((trimAfter ?? null) !== null && !loop) {
-        const time = (trimAfter - (trimBefore ?? 0)) / fps;
-        if (timeInSeconds >= time) {
-            return null;
-        }
-    }
-    return timeInSeconds + (trimBefore ?? 0) / fps;
-};
-export const calculateEndTime = ({ mediaDurationInSeconds, ifNoMediaDuration, src, trimAfter, trimBefore, fps, }) => {
-    if (mediaDurationInSeconds === null && ifNoMediaDuration === 'fail') {
-        throw new Error(`Could not determine duration of ${src}, but "loop" was set.`);
-    }
-    const mediaDuration = Internals.calculateMediaDuration({
-        trimAfter,
-        mediaDurationInFrames: mediaDurationInSeconds
-            ? mediaDurationInSeconds * fps
-            : Infinity,
-        // Playback rate was already specified before
-        playbackRate: 1,
-        trimBefore,
-    }) / fps;
-    return mediaDuration + (trimBefore ?? 0) / fps;
-};

package/dist/helpers/round-to-4-digits.js

@@ -1,4 +0,0 @@
-// Round to only 4 digits, because WebM has a timescale of 1_000, e.g. framer.webm
-export const roundTo4Digits = (timestamp) => {
-    return Math.round(timestamp * 1000) / 1000;
-};

package/dist/index.js

@@ -1,12 +0,0 @@
-import { Audio } from './audio/audio';
-import { Video } from './video/video';
-/**
- * @deprecated Now just `Audio`
- */
-export const experimental_Audio = Audio;
-/**
- * @deprecated Now just `Video`
- */
-export const experimental_Video = Video;
-export { AudioForPreview } from './audio/audio-for-preview';
-export { Audio, Video };

package/dist/is-type-of-error.js

@@ -1,20 +0,0 @@
-/**
- * Utility to check if error is network error
- * @param error
- * @returns
- */
-export function isNetworkError(error) {
-    if (
-    // Chrome
-    error.message.includes('Failed to fetch') ||
-        // Safari
-        error.message.includes('Load failed') ||
-        // Firefox
-        error.message.includes('NetworkError when attempting to fetch resource')) {
-        return true;
-    }
-    return false;
-}
-export function isUnsupportedConfigurationError(error) {
-    return error.message.includes('Unsupported configuration');
-}

package/dist/looped-frame.js

@@ -1,10 +0,0 @@
-export const frameForVolumeProp = ({ behavior, loop, assetDurationInSeconds, fps, frame, startsAt, }) => {
-    if (!loop) {
-        return frame + startsAt;
-    }
-    if (behavior === 'extend') {
-        return frame + startsAt;
-    }
-    const assetDurationInFrames = Math.floor(assetDurationInSeconds * fps) - startsAt;
-    return (frame % assetDurationInFrames) + startsAt;
-};