@remotion/media 4.0.429 → 4.0.430

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

@@ -0,0 +1,101 @@
+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 [frame, 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 (frame?.type === 'cannot-decode') {
+            return {
+                type: 'cannot-decode',
+                durationInSeconds: frame.durationInSeconds,
+            };
+        }
+        if (frame?.type === 'unknown-container-format') {
+            return { type: 'unknown-container-format' };
+        }
+        if (frame?.type === 'cannot-decode-alpha') {
+            return {
+                type: 'cannot-decode-alpha',
+                durationInSeconds: frame.durationInSeconds,
+            };
+        }
+        if (frame?.type === 'network-error') {
+            return { type: 'network-error' };
+        }
+        if (audio === 'unknown-container-format') {
+            if (frame !== null) {
+                frame?.frame?.close();
+            }
+            return { type: 'unknown-container-format' };
+        }
+        if (audio === 'network-error') {
+            if (frame !== null) {
+                frame?.frame?.close();
+            }
+            return { type: 'network-error' };
+        }
+        if (audio === 'cannot-decode') {
+            if (frame?.type === 'success' && frame.frame !== null) {
+                frame?.frame.close();
+            }
+            return {
+                type: 'cannot-decode',
+                durationInSeconds: frame?.type === 'success' ? frame.durationInSeconds : null,
+            };
+        }
+        if (!frame?.frame) {
+            return {
+                type: 'success',
+                frame: null,
+                audio: audio?.data ?? null,
+                durationInSeconds: audio?.durationInSeconds ?? null,
+            };
+        }
+        return {
+            type: 'success',
+            frame: await rotateFrame({
+                frame: frame.frame.toVideoFrame(),
+                rotation: frame.frame.rotation,
+            }),
+            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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,4 @@
+// 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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,20 @@
+/**
+ * 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

@@ -0,0 +1,10 @@
+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;
+};

package/dist/media-player.d.ts

@@ -1,6 +1,5 @@
 import type { LogLevel, useBufferState } from 'remotion';
 import { type AudioIteratorManager } from './audio-iterator-manager';
-import type { Nonce } from './nonce-manager';
 import type { VideoIteratorManager } from './video-iterator-manager';
 export type MediaPlayerInitResult = {
     type: 'success';
@@ -33,6 +32,7 @@ export declare class MediaPlayer {
     private fps;
     private trimBefore;
     private trimAfter;
+    private durationInFrames;
     private totalDuration;
     private debugOverlay;
     private nonceManager;
@@ -42,7 +42,7 @@ export declare class MediaPlayer {
     private isPremounting;
     private isPostmounting;
     private seekPromiseChain;
-    constructor({ canvas, src, logLevel, sharedAudioContext, loop, trimBefore, trimAfter, playbackRate, globalPlaybackRate, audioStreamIndex, fps, debugOverlay, bufferState, isPremounting, isPostmounting, onVideoFrameCallback, playing }: {
+    constructor({ canvas, src, logLevel, sharedAudioContext, loop, trimBefore, trimAfter, playbackRate, globalPlaybackRate, audioStreamIndex, fps, debugOverlay, bufferState, isPremounting, isPostmounting, durationInFrames, onVideoFrameCallback, playing }: {
         canvas: HTMLCanvasElement | OffscreenCanvas | null;
         src: string;
         logLevel: LogLevel;
@@ -58,6 +58,7 @@ export declare class MediaPlayer {
         bufferState: ReturnType<typeof useBufferState>;
         isPremounting: boolean;
         isPostmounting: boolean;
+        durationInFrames: number;
         onVideoFrameCallback: null | ((frame: CanvasImageSource) => void);
         playing: boolean;
     });
@@ -69,27 +70,30 @@ export declare class MediaPlayer {
     private _initialize;
     private seekToWithQueue;
     seekTo(time: number): Promise<void>;
-    seekToDoNotCallDirectly(newTime: number, nonce: Nonce): Promise<void>;
+    private seekToDoNotCallDirectly;
+    playAudio(time: number): Promise<void>;
     play(time: number): Promise<void>;
     private delayPlaybackHandleIfNotPremounting;
     pause(): void;
     setMuted(muted: boolean): void;
     setVolume(volume: number): void;
+    private getTrimmedTime;
     private updateAfterTrimChange;
     setTrimBefore(trimBefore: number | undefined, unloopedTimeInSeconds: number): Promise<void>;
     setTrimAfter(trimAfter: number | undefined, unloopedTimeInSeconds: number): Promise<void>;
     setDebugOverlay(debugOverlay: boolean): void;
     private updateAudioTimeAfterPlaybackRateChange;
-    setPlaybackRate(rate: number): void;
+    setPlaybackRate(rate: number, unloopedTimeInSeconds: number): Promise<void>;
     setGlobalPlaybackRate(rate: number): void;
     setFps(fps: number): void;
     setIsPremounting(isPremounting: boolean): void;
     setIsPostmounting(isPostmounting: boolean): void;
     setLoop(loop: boolean): void;
+    setDurationInFrames(durationInFrames: number): void;
     dispose(): Promise<void>;
     private scheduleAudioNode;
     private getAudioPlaybackTime;
-    private setPlaybackTime;
+    private setAudioPlaybackTime;
     setVideoFrameCallback(callback: null | ((frame: CanvasImageSource) => void)): void;
     private drawDebugOverlay;
 }