@remotion/media 4.0.402 → 4.0.404

package/dist/audio/audio-for-preview.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 import type { LogLevel, LoopVolumeCurveBehavior, VolumeProp } from 'remotion';
+import { type MediaOnError } from '../on-error';
 import type { FallbackHtml5AudioProps } from './props';
 type InnerAudioProps = {
     readonly loop?: boolean;
@@ -25,6 +26,7 @@ type InnerAudioProps = {
     readonly toneFrequency?: number;
     readonly audioStreamIndex?: number;
     readonly fallbackHtml5AudioProps?: FallbackHtml5AudioProps;
+    readonly onError?: MediaOnError;
 };
 export declare const AudioForPreview: React.FC<InnerAudioProps>;
 export {};

package/dist/audio/audio-preview-iterator.d.ts

@@ -1,5 +1,4 @@
 import type { WrappedAudioBuffer } from 'mediabunny';
-import type { PrewarmedAudioIteratorCache } from '../prewarm-iterator-for-looping';
 import { type AllowWait } from './allow-wait';
 export declare const HEALTHY_BUFFER_THRESHOLD_SECONDS = 1;
 export type QueuedNode = {
@@ -7,7 +6,13 @@ export type QueuedNode = {
     timestamp: number;
     buffer: AudioBuffer;
 };
-export declare const makeAudioIterator: (startFromSecond: number, cache: PrewarmedAudioIteratorCache) => {
+export declare const makeAudioIterator: (startFromSecond: number, cache: {
+    prewarmIteratorForLooping: ({ timeToSeek }: {
+        timeToSeek: number;
+    }) => void;
+    makeIteratorOrUsePrewarmed: (timeToSeek: number) => AsyncGenerator<WrappedAudioBuffer, void, unknown>;
+    destroy: () => void;
+}) => {
     destroy: () => void;
     getNext: () => Promise<IteratorResult<WrappedAudioBuffer, void>>;
     isDestroyed: () => boolean;
@@ -37,4 +42,4 @@ export type AudioIterator = ReturnType<typeof makeAudioIterator>;
 export declare const isAlreadyQueued: (time: number, queuedPeriod: {
     from: number;
     until: number;
-} | undefined | null) => boolean;
+} | null | undefined) => boolean;

package/dist/audio/props.d.ts

@@ -1,4 +1,5 @@
 import type { LogLevel, LoopVolumeCurveBehavior, VolumeProp } from 'remotion';
+import type { MediaOnError } from '../on-error';
 export type FallbackHtml5AudioProps = {
     crossOrigin?: '' | 'anonymous' | 'use-credentials' | undefined;
     onError?: (err: Error) => void;
@@ -30,4 +31,5 @@ export type AudioProps = {
     toneFrequency?: number;
     delayRenderRetries?: number;
     delayRenderTimeoutInMilliseconds?: number;
+    onError?: MediaOnError;
 };

package/dist/audio-extraction/audio-iterator.d.ts

@@ -1,13 +1,14 @@
 import type { AudioSample, AudioSampleSink } from 'mediabunny';
-import { type LogLevel } from 'remotion';
-import type { RememberActualMatroskaTimestamps } from '../video-extraction/remember-actual-matroska-timestamps';
 export declare const makeAudioIterator: ({ audioSampleSink, isMatroska, startTimestamp, src, actualMatroskaTimestamps, logLevel, }: {
     audioSampleSink: AudioSampleSink;
     isMatroska: boolean;
     startTimestamp: number;
     src: string;
-    actualMatroskaTimestamps: RememberActualMatroskaTimestamps;
-    logLevel: LogLevel;
+    actualMatroskaTimestamps: {
+        observeTimestamp: (startTime: number) => void;
+        getRealTimestamp: (observedTimestamp: number) => number | null;
+    };
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
 }) => {
     src: string;
     getSamples: (ts: number, dur: number) => Promise<AudioSample[]>;

package/dist/audio-extraction/audio-manager.d.ts

@@ -1,17 +1,33 @@
 import type { AudioSampleSink } from 'mediabunny';
-import { type LogLevel } from 'remotion';
-import type { RememberActualMatroskaTimestamps } from '../video-extraction/remember-actual-matroska-timestamps';
-import type { AudioSampleIterator } from './audio-iterator';
 export declare const makeAudioManager: () => {
     getIterator: ({ src, timeInSeconds, audioSampleSink, isMatroska, actualMatroskaTimestamps, logLevel, maxCacheSize, }: {
         src: string;
         timeInSeconds: number;
         audioSampleSink: AudioSampleSink;
         isMatroska: boolean;
-        actualMatroskaTimestamps: RememberActualMatroskaTimestamps;
-        logLevel: LogLevel;
+        actualMatroskaTimestamps: {
+            observeTimestamp: (startTime: number) => void;
+            getRealTimestamp: (observedTimestamp: number) => number | null;
+        };
+        logLevel: "error" | "info" | "trace" | "verbose" | "warn";
         maxCacheSize: number;
-    }) => Promise<AudioSampleIterator>;
+    }) => Promise<{
+        src: string;
+        getSamples: (ts: number, dur: number) => Promise<import("mediabunny").AudioSample[]>;
+        waitForCompletion: () => Promise<boolean>;
+        canSatisfyRequestedTime: (timestamp: number) => boolean;
+        logOpenFrames: () => void;
+        getCacheStats: () => {
+            count: number;
+            size: number;
+        };
+        getLastUsed: () => number;
+        prepareForDeletion: () => void;
+        startTimestamp: number;
+        clearBeforeThreshold: (threshold: number) => void;
+        getOldestTimestamp: () => number;
+        getNewestTimestamp: () => number | null;
+    }>;
     getCacheStats: () => {
         count: number;
         totalSize: number;
@@ -34,5 +50,5 @@ export declare const makeAudioManager: () => {
         getNewestTimestamp: () => number | null;
     } | null;
     logOpenFrames: () => void;
-    deleteDuplicateIterators: (logLevel: LogLevel) => void;
+    deleteDuplicateIterators: (logLevel: "error" | "info" | "trace" | "verbose" | "warn") => void;
 };

package/dist/audio-extraction/extract-audio.d.ts

@@ -1,6 +1,5 @@
 import { type LogLevel } from 'remotion';
 import type { PcmS16AudioData } from '../convert-audiodata/convert-audiodata';
-type ExtractAudioReturnType = Awaited<ReturnType<typeof extractAudioInternal>>;
 type ExtractAudioParams = {
     src: string;
     timeInSeconds: number;
@@ -14,9 +13,8 @@ type ExtractAudioParams = {
     fps: number;
     maxCacheSize: number;
 };
-declare const extractAudioInternal: ({ src, timeInSeconds: unloopedTimeInSeconds, durationInSeconds: durationNotYetApplyingPlaybackRate, logLevel, loop, playbackRate, audioStreamIndex, trimBefore, trimAfter, fps, maxCacheSize, }: ExtractAudioParams) => Promise<{
+export declare const extractAudio: (params: ExtractAudioParams) => Promise<"cannot-decode" | "network-error" | "unknown-container-format" | {
     data: PcmS16AudioData | null;
     durationInSeconds: number | null;
-} | "cannot-decode" | "unknown-container-format" | "network-error">;
-export declare const extractAudio: (params: ExtractAudioParams) => Promise<ExtractAudioReturnType>;
+}>;
 export {};

package/dist/audio-iterator-manager.d.ts

@@ -1,5 +1,5 @@
 import type { InputAudioTrack, WrappedAudioBuffer } from 'mediabunny';
-import type { useBufferState } from 'remotion';
+import type { UseBufferState } from 'remotion';
 import type { Nonce } from './nonce-manager';
 export declare const audioIteratorManager: ({ audioTrack, delayPlaybackHandleIfNotPremounting, sharedAudioContext, getIsLooping, getEndTime, getStartTime, updatePlaybackTime, }: {
     audioTrack: InputAudioTrack;
@@ -57,7 +57,7 @@ export declare const audioIteratorManager: ({ audioTrack, delayPlaybackHandleIfN
         fps: number;
         playbackRate: number;
         getIsPlaying: () => boolean;
-        bufferState: ReturnType<typeof useBufferState>;
+        bufferState: UseBufferState;
         scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => void;
     }) => Promise<void>;
     getAudioIteratorsCreated: () => number;

package/dist/caches.d.ts

@@ -1,19 +1,17 @@
-import { type LogLevel } from 'remotion';
-export declare const SAFE_BACK_WINDOW_IN_SECONDS = 1;
+export declare const SAFE_WINDOW_OF_MONOTONICITY = 0.2;
 export declare const keyframeManager: {
-    requestKeyframeBank: ({ packetSink, timestamp, videoSampleSink, src, logLevel, maxCacheSize, }: {
-        packetSink: import("mediabunny").EncodedPacketSink;
+    requestKeyframeBank: ({ timestamp, videoSampleSink, src, logLevel, maxCacheSize, }: {
         timestamp: number;
         videoSampleSink: import("mediabunny").VideoSampleSink;
         src: string;
-        logLevel: LogLevel;
+        logLevel: "error" | "info" | "trace" | "verbose" | "warn";
         maxCacheSize: number;
-    }) => Promise<import("./video-extraction/keyframe-bank").KeyframeBank | "has-alpha" | null>;
-    getCacheStats: () => Promise<{
+    }) => Promise<import("./video-extraction/keyframe-bank").KeyframeBank>;
+    getCacheStats: () => {
         count: number;
         totalSize: number;
-    }>;
-    clearAll: (logLevel: LogLevel) => Promise<void>;
+    };
+    clearAll: (logLevel: "error" | "info" | "trace" | "verbose" | "warn") => void;
 };
 export declare const audioManager: {
     getIterator: ({ src, timeInSeconds, audioSampleSink, isMatroska, actualMatroskaTimestamps, logLevel, maxCacheSize, }: {
@@ -21,10 +19,29 @@ export declare const audioManager: {
         timeInSeconds: number;
         audioSampleSink: import("mediabunny").AudioSampleSink;
         isMatroska: boolean;
-        actualMatroskaTimestamps: import("./video-extraction/remember-actual-matroska-timestamps").RememberActualMatroskaTimestamps;
-        logLevel: LogLevel;
+        actualMatroskaTimestamps: {
+            observeTimestamp: (startTime: number) => void;
+            getRealTimestamp: (observedTimestamp: number) => number | null;
+        };
+        logLevel: "error" | "info" | "trace" | "verbose" | "warn";
         maxCacheSize: number;
-    }) => Promise<import("./audio-extraction/audio-iterator").AudioSampleIterator>;
+    }) => Promise<{
+        src: string;
+        getSamples: (ts: number, dur: number) => Promise<import("mediabunny").AudioSample[]>;
+        waitForCompletion: () => Promise<boolean>;
+        canSatisfyRequestedTime: (timestamp: number) => boolean;
+        logOpenFrames: () => void;
+        getCacheStats: () => {
+            count: number;
+            size: number;
+        };
+        getLastUsed: () => number;
+        prepareForDeletion: () => void;
+        startTimestamp: number;
+        clearBeforeThreshold: (threshold: number) => void;
+        getOldestTimestamp: () => number;
+        getNewestTimestamp: () => number | null;
+    }>;
     getCacheStats: () => {
         count: number;
         totalSize: number;
@@ -47,11 +64,11 @@ export declare const audioManager: {
         getNewestTimestamp: () => number | null;
     } | null;
     logOpenFrames: () => void;
-    deleteDuplicateIterators: (logLevel: LogLevel) => void;
+    deleteDuplicateIterators: (logLevel: "error" | "info" | "trace" | "verbose" | "warn") => void;
 };
-export declare const getTotalCacheStats: () => Promise<{
+export declare const getTotalCacheStats: () => {
     count: number;
     totalSize: number;
-}>;
-export declare const getMaxVideoCacheSize: (logLevel: LogLevel) => number;
-export declare const useMaxMediaCacheSize: (logLevel: LogLevel) => number;
+};
+export declare const getMaxVideoCacheSize: (logLevel: "error" | "info" | "trace" | "verbose" | "warn") => number;
+export declare const useMaxMediaCacheSize: (logLevel: "error" | "info" | "trace" | "verbose" | "warn") => number;

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

@@ -1 +1 @@
-export declare const applyVolume: (array: Int16Array, volume: number) => void;
+export declare const applyVolume: (array: Int16Array<ArrayBufferLike>, volume: number) => void;

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

@@ -2,8 +2,8 @@ export declare const TARGET_NUMBER_OF_CHANNELS = 2;
 export declare const TARGET_SAMPLE_RATE = 48000;
 export declare const resampleAudioData: ({ srcNumberOfChannels, sourceChannels, destination, targetFrames, chunkSize, }: {
     srcNumberOfChannels: number;
-    sourceChannels: Int16Array;
-    destination: Int16Array;
+    sourceChannels: Int16Array<ArrayBufferLike>;
+    destination: Int16Array<ArrayBufferLike>;
     targetFrames: number;
     chunkSize: number;
 }) => void;

package/dist/debug-overlay/preview-overlay.d.ts

@@ -1,11 +1,89 @@
-import type { AudioIteratorManager } from '../audio-iterator-manager';
-import type { VideoIteratorManager } from '../video-iterator-manager';
 export declare const drawPreviewOverlay: ({ context, audioTime, audioContextState, audioSyncAnchor, playing, audioIteratorManager, videoIteratorManager, }: {
-    context: OffscreenCanvasRenderingContext2D | CanvasRenderingContext2D;
+    context: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D;
     audioTime: number | null;
     audioContextState: AudioContextState | null;
     audioSyncAnchor: number;
     playing: boolean;
-    audioIteratorManager: AudioIteratorManager | null;
-    videoIteratorManager: VideoIteratorManager | null;
+    audioIteratorManager: {
+        startAudioIterator: ({ nonce, playbackRate, startFromSecond, getIsPlaying, scheduleAudioNode, }: {
+            startFromSecond: number;
+            nonce: import("../nonce-manager").Nonce;
+            playbackRate: number;
+            getIsPlaying: () => boolean;
+            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => void;
+        }) => Promise<void>;
+        resumeScheduledAudioChunks: ({ playbackRate, scheduleAudioNode, }: {
+            playbackRate: number;
+            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => void;
+        }) => void;
+        pausePlayback: () => void;
+        getAudioBufferIterator: () => {
+            destroy: () => void;
+            getNext: () => Promise<IteratorResult<import("mediabunny").WrappedAudioBuffer, void>>;
+            isDestroyed: () => boolean;
+            addQueuedAudioNode: (node: AudioBufferSourceNode, timestamp: number, buffer: AudioBuffer) => void;
+            removeQueuedAudioNode: (node: AudioBufferSourceNode) => void;
+            getAndClearAudioChunksForAfterResuming: () => {
+                buffer: AudioBuffer;
+                timestamp: number;
+            }[];
+            getQueuedPeriod: () => {
+                from: number;
+                until: number;
+            } | null;
+            tryToSatisfySeek: (time: number, allowWait: import("../audio/allow-wait").AllowWait | null, onBufferScheduled: (buffer: import("mediabunny").WrappedAudioBuffer) => void) => Promise<{
+                type: "not-satisfied";
+                reason: string;
+            } | {
+                type: "ended";
+            } | {
+                type: "satisfied";
+            }>;
+            addChunkForAfterResuming: (buffer: AudioBuffer, timestamp: number) => void;
+            moveQueuedChunksToPauseQueue: () => void;
+            getNumberOfChunksAfterResuming: () => number;
+        } | null;
+        destroyIterator: () => void;
+        seek: ({ newTime, nonce, fps, playbackRate, getIsPlaying, scheduleAudioNode, bufferState, }: {
+            newTime: number;
+            nonce: import("../nonce-manager").Nonce;
+            fps: number;
+            playbackRate: number;
+            getIsPlaying: () => boolean;
+            bufferState: import("remotion").UseBufferState;
+            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => void;
+        }) => Promise<void>;
+        getAudioIteratorsCreated: () => number;
+        setMuted: (newMuted: boolean) => void;
+        setVolume: (volume: number) => void;
+        scheduleAudioChunk: ({ buffer, mediaTimestamp, playbackRate, scheduleAudioNode, }: {
+            buffer: AudioBuffer;
+            mediaTimestamp: number;
+            playbackRate: number;
+            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => void;
+        }) => void;
+    } | null;
+    videoIteratorManager: {
+        startVideoIterator: (timeToSeek: number, nonce: import("../nonce-manager").Nonce) => Promise<void>;
+        getVideoIteratorsCreated: () => number;
+        seek: ({ newTime, nonce }: {
+            newTime: number;
+            nonce: import("../nonce-manager").Nonce;
+        }) => Promise<void>;
+        destroy: () => void;
+        getVideoFrameIterator: () => {
+            destroy: () => void;
+            getNext: () => Promise<IteratorResult<import("mediabunny").WrappedCanvas, void>>;
+            isDestroyed: () => boolean;
+            tryToSatisfySeek: (time: number) => Promise<{
+                type: "not-satisfied";
+                reason: string;
+            } | {
+                type: "satisfied";
+                frame: import("mediabunny").WrappedCanvas;
+            }>;
+        } | null;
+        drawFrame: (frame: import("mediabunny").WrappedCanvas) => void;
+        getFramesRendered: () => number;
+    } | null;
 }) => void;