@remotion/media 4.0.355 → 4.0.357

package/dist/extract-frame-and-audio.d.ts

@@ -1,6 +1,6 @@
 import type { LogLevel } from 'remotion';
-import type { PcmS16AudioData } from './convert-audiodata/convert-audiodata';
-export declare const extractFrameAndAudio: ({ src, timeInSeconds, logLevel, durationInSeconds, playbackRate, includeAudio, includeVideo, loop, }: {
+import type { ExtractFrameViaBroadcastChannelResult } from './video-extraction/extract-frame-via-broadcast-channel';
+export declare const extractFrameAndAudio: ({ src, timeInSeconds, logLevel, durationInSeconds, playbackRate, includeAudio, includeVideo, loop, audioStreamIndex, trimAfter, trimBefore, fps, }: {
     src: string;
     timeInSeconds: number;
     logLevel: LogLevel;
@@ -9,8 +9,8 @@ export declare const extractFrameAndAudio: ({ src, timeInSeconds, logLevel, dura
     includeAudio: boolean;
     includeVideo: boolean;
     loop: boolean;
-}) => Promise<{
-    frame: VideoFrame | null;
-    audio: PcmS16AudioData | null;
-    durationInSeconds: number | null;
-}>;
+    audioStreamIndex: number;
+    trimAfter: number | undefined;
+    trimBefore: number | undefined;
+    fps: number;
+}) => Promise<ExtractFrameViaBroadcastChannelResult>;

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

@@ -1,29 +1,72 @@
 import { extractAudio } from './audio-extraction/extract-audio';
+import { isNetworkError } from './is-network-error';
 import { extractFrame } from './video-extraction/extract-frame';
-export const extractFrameAndAudio = async ({ src, timeInSeconds, logLevel, durationInSeconds, playbackRate, includeAudio, includeVideo, loop, }) => {
-    const [frame, audio] = await Promise.all([
-        includeVideo
-            ? extractFrame({
-                src,
-                timeInSeconds,
-                logLevel,
-                loop,
-            })
-            : null,
-        includeAudio
-            ? extractAudio({
-                src,
-                timeInSeconds,
-                durationInSeconds,
-                logLevel,
-                loop,
-                playbackRate,
-            })
-            : null,
-    ]);
-    return {
-        frame: frame?.toVideoFrame() ?? null,
-        audio: audio?.data ?? null,
-        durationInSeconds: audio?.durationInSeconds ?? null,
-    };
+export const extractFrameAndAudio = async ({ src, timeInSeconds, logLevel, durationInSeconds, playbackRate, includeAudio, includeVideo, loop, audioStreamIndex, trimAfter, trimBefore, fps, }) => {
+    try {
+        const [frame, audio] = await Promise.all([
+            includeVideo
+                ? extractFrame({
+                    src,
+                    timeInSeconds,
+                    logLevel,
+                    loop,
+                    trimAfter,
+                    playbackRate,
+                    trimBefore,
+                    fps,
+                })
+                : null,
+            includeAudio
+                ? extractAudio({
+                    src,
+                    timeInSeconds,
+                    durationInSeconds,
+                    logLevel,
+                    loop,
+                    playbackRate,
+                    audioStreamIndex,
+                    trimAfter,
+                    fps,
+                    trimBefore,
+                })
+                : 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 (audio === 'unknown-container-format') {
+            if (frame !== null) {
+                frame?.frame?.close();
+            }
+            return { type: 'unknown-container-format' };
+        }
+        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,
+            };
+        }
+        return {
+            type: 'success',
+            frame: frame?.frame?.toVideoFrame() ?? 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-weak.d.ts

@@ -1,14 +1,9 @@
 import type { LogLevel } from 'remotion';
 import type { GetSink } from './video-extraction/get-frames-since-keyframe';
 export declare const sinkPromises: Record<string, Promise<GetSink>>;
-export declare const getSinkWeak: (src: string, logLevel: LogLevel) => Promise<{
-    video: {
-        sampleSink: import("mediabunny").VideoSampleSink;
-        packetSink: import("mediabunny").EncodedPacketSink;
-    } | null;
-    audio: {
-        sampleSink: import("mediabunny").AudioSampleSink;
-    } | null;
+export declare const getSink: (src: string, logLevel: LogLevel) => Promise<{
+    getVideo: () => Promise<import("./video-extraction/get-frames-since-keyframe").VideoSinkResult>;
+    getAudio: (index: number) => Promise<import("./video-extraction/get-frames-since-keyframe").AudioSinkResult>;
     actualMatroskaTimestamps: {
         observeTimestamp: (startTime: number) => void;
         getRealTimestamp: (observedTimestamp: number) => number | null;

package/dist/get-sink-weak.js

@@ -1,23 +1,15 @@
 import { Internals } from 'remotion';
 import { getSinks } from './video-extraction/get-frames-since-keyframe';
 export const sinkPromises = {};
-export const getSinkWeak = async (src, logLevel) => {
+export const getSink = (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`);
+        }, `Sink for ${src} was not found, creating new sink`);
         promise = getSinks(src);
         sinkPromises[src] = promise;
-        awaited = await promise;
-        deferredValue = awaited.deref();
     }
-    return deferredValue;
+    return promise;
 };

package/dist/get-sink.d.ts

@@ -0,0 +1,13 @@
+import type { LogLevel } from 'remotion';
+import type { GetSink } from './video-extraction/get-frames-since-keyframe';
+export declare const sinkPromises: Record<string, Promise<GetSink>>;
+export declare const getSink: (src: string, logLevel: LogLevel) => Promise<{
+    getVideo: () => Promise<import("./video-extraction/get-frames-since-keyframe").VideoSinkResult>;
+    getAudio: (index: number) => Promise<import("./video-extraction/get-frames-since-keyframe").AudioSinkResult>;
+    actualMatroskaTimestamps: {
+        observeTimestamp: (startTime: number) => void;
+        getRealTimestamp: (observedTimestamp: number) => number | null;
+    };
+    isMatroska: boolean;
+    getDuration: () => Promise<number>;
+}>;

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.d.ts

@@ -0,0 +1,10 @@
+export declare const getTimeInSeconds: ({ loop, mediaDurationInSeconds, unloopedTimeInSeconds, src, trimAfter, trimBefore, fps, playbackRate, }: {
+    loop: boolean;
+    mediaDurationInSeconds: number | null;
+    unloopedTimeInSeconds: number;
+    src: string;
+    trimAfter: number | undefined;
+    trimBefore: number | undefined;
+    playbackRate: number;
+    fps: number;
+}) => number | null;

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

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

package/dist/index.d.ts

@@ -1,4 +1,14 @@
-export { Audio as experimental_Audio } from './audio/audio';
-export { AudioProps } from './audio/props';
+import { Audio } from './audio/audio';
+import { Video } from './video/video';
+/**
+ * @deprecated Now just `Audio`
+ */
+export declare const experimental_Audio: import("react").FC<import(".").AudioProps>;
+/**
+ * @deprecated Now just `Video`
+ */
+export declare const experimental_Video: import("react").FC<import(".").VideoProps>;
+export { AudioForPreview } from './audio/audio-for-preview';
+export { AudioProps, FallbackHtml5AudioProps } from './audio/props';
 export { VideoProps } from './video/props';
-export { Video as experimental_Video } from './video/video';
+export { Audio, Video };

package/dist/index.js

@@ -1,2 +1,12 @@
-export { Audio as experimental_Audio } from './audio/audio';
-export { Video as experimental_Video } from './video/video';
+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-network-error.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Utility to check if error is network error
+ * @param error
+ * @returns
+ */
+export declare function isNetworkError(error: Error): boolean;

package/dist/is-network-error.js

@@ -0,0 +1,17 @@
+/**
+ * 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;
+}

package/dist/render-timestamp-range.d.ts

@@ -0,0 +1 @@
+export declare const renderTimestampRange: (timestamps: number[]) => string;

package/dist/render-timestamp-range.js

@@ -0,0 +1,9 @@
+export const renderTimestampRange = (timestamps) => {
+    if (timestamps.length === 0) {
+        return '(none)';
+    }
+    if (timestamps.length === 1) {
+        return timestamps[0].toFixed(3);
+    }
+    return `${timestamps[0].toFixed(3)}...${timestamps[timestamps.length - 1].toFixed(3)}`;
+};

package/dist/video/media-player.d.ts

@@ -0,0 +1,91 @@
+import type { LogLevel } from 'remotion';
+export declare const SEEK_THRESHOLD = 0.05;
+export type MediaPlayerInitResult = {
+    type: 'success';
+} | {
+    type: 'unknown-container-format';
+} | {
+    type: 'cannot-decode';
+} | {
+    type: 'network-error';
+} | {
+    type: 'no-tracks';
+};
+export declare class MediaPlayer {
+    private canvas;
+    private context;
+    private src;
+    private logLevel;
+    private playbackRate;
+    private audioStreamIndex;
+    private canvasSink;
+    private videoFrameIterator;
+    private nextFrame;
+    private audioSink;
+    private audioBufferIterator;
+    private queuedAudioNodes;
+    private gainNode;
+    private sharedAudioContext;
+    private audioSyncAnchor;
+    private playing;
+    private muted;
+    private loop;
+    private trimBeforeSeconds;
+    private trimAfterSeconds;
+    private animationFrameId;
+    private videoAsyncId;
+    private audioAsyncId;
+    private initialized;
+    private totalDuration;
+    private isBuffering;
+    private onBufferingChangeCallback?;
+    private audioBufferHealth;
+    private audioIteratorStarted;
+    private readonly HEALTHY_BUFER_THRESHOLD_SECONDS;
+    private onVideoFrameCallback?;
+    constructor({ canvas, src, logLevel, sharedAudioContext, loop, trimBeforeSeconds, trimAfterSeconds, playbackRate, audioStreamIndex, }: {
+        canvas: HTMLCanvasElement | null;
+        src: string;
+        logLevel: LogLevel;
+        sharedAudioContext: AudioContext;
+        loop: boolean;
+        trimBeforeSeconds: number | undefined;
+        trimAfterSeconds: number | undefined;
+        playbackRate: number;
+        audioStreamIndex: number;
+    });
+    private input;
+    private isReady;
+    private hasAudio;
+    private isCurrentlyBuffering;
+    initialize(startTimeUnresolved: number): Promise<MediaPlayerInitResult>;
+    private cleanupAudioQueue;
+    private cleanAudioIteratorAndNodes;
+    seekTo(time: number): Promise<void>;
+    play(): Promise<void>;
+    pause(): void;
+    setMuted(muted: boolean): void;
+    setVolume(volume: number): void;
+    setPlaybackRate(rate: number): void;
+    setLoop(loop: boolean): void;
+    dispose(): void;
+    private getPlaybackTime;
+    private scheduleAudioChunk;
+    onBufferingChange(callback: (isBuffering: boolean) => void): () => void;
+    onVideoFrame(callback: (frame: CanvasImageSource) => void): () => void;
+    private canRenderVideo;
+    private startRenderLoop;
+    private stopRenderLoop;
+    private render;
+    private shouldRenderFrame;
+    private drawCurrentFrame;
+    private startAudioIterator;
+    private startVideoIterator;
+    private updateNextFrame;
+    private bufferingStartedAtMs;
+    private minBufferingTimeoutMs;
+    private setBufferingState;
+    private maybeResumeFromBuffering;
+    private maybeForceResumeFromBuffering;
+    private runAudioIterator;
+}