@remotion/media 4.0.352 → 4.0.354

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

@@ -1,15 +1,16 @@
 import type { LogLevel } from 'remotion';
 import type { PcmS16AudioData } from './convert-audiodata/convert-audiodata';
-export declare const extractFrameAndAudio: ({ src, timeInSeconds, logLevel, durationInSeconds, includeAudio, includeVideo, volume, loop, }: {
+export declare const extractFrameAndAudio: ({ src, timeInSeconds, logLevel, durationInSeconds, playbackRate, includeAudio, includeVideo, loop, }: {
     src: string;
     timeInSeconds: number;
     logLevel: LogLevel;
     durationInSeconds: number;
+    playbackRate: number;
     includeAudio: boolean;
     includeVideo: boolean;
-    volume: number;
     loop: boolean;
 }) => Promise<{
     frame: VideoFrame | null;
     audio: PcmS16AudioData | null;
+    durationInSeconds: number | null;
 }>;

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

@@ -1,6 +1,6 @@
 import { extractAudio } from './audio-extraction/extract-audio';
 import { extractFrame } from './video-extraction/extract-frame';
-export const extractFrameAndAudio = async ({ src, timeInSeconds, logLevel, durationInSeconds, includeAudio, includeVideo, volume, loop, }) => {
+export const extractFrameAndAudio = async ({ src, timeInSeconds, logLevel, durationInSeconds, playbackRate, includeAudio, includeVideo, loop, }) => {
     const [frame, audio] = await Promise.all([
         includeVideo
             ? extractFrame({
@@ -15,14 +15,15 @@ export const extractFrameAndAudio = async ({ src, timeInSeconds, logLevel, durat
                 src,
                 timeInSeconds,
                 durationInSeconds,
-                volume,
                 logLevel,
                 loop,
+                playbackRate,
             })
             : null,
     ]);
     return {
         frame: frame?.toVideoFrame() ?? null,
-        audio,
+        audio: audio?.data ?? null,
+        durationInSeconds: audio?.durationInSeconds ?? null,
     };
 };

package/dist/looped-frame.d.ts

@@ -0,0 +1,9 @@
+import { type LoopVolumeCurveBehavior } from 'remotion';
+export declare const frameForVolumeProp: ({ behavior, loop, assetDurationInSeconds, fps, frame, startsAt, }: {
+    behavior: LoopVolumeCurveBehavior;
+    loop: boolean;
+    assetDurationInSeconds: number;
+    fps: number;
+    frame: number;
+    startsAt: number;
+}) => number;

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/video/media-player.d.ts

@@ -1,4 +1,5 @@
-import { type LogLevel } from '../log';
+import type { LogLevel } from 'remotion';
+export declare const SEEK_THRESHOLD = 0.05;
 export declare class MediaPlayer {
     private canvas;
     private context;
@@ -11,54 +12,51 @@ export declare class MediaPlayer {
     private audioBufferIterator;
     private queuedAudioNodes;
     private gainNode;
-    private expectedAudioTime;
     private sharedAudioContext;
-    private mediaTimeOffset;
+    private audioSyncAnchor;
     private playing;
     private animationFrameId;
-    private asyncId;
+    private videoAsyncId;
     private initialized;
     private totalDuration;
-    private actualFps;
-    private isStalled;
-    private onStalledChangeCallback?;
-    private lastAudioProgressAtMs;
-    private lastNetworkActivityAtMs;
-    private isNetworkActive;
-    private isSeeking;
-    private canStartAudio;
+    private isBuffering;
+    private onBufferingChangeCallback?;
+    private audioBufferHealth;
+    private audioIteratorStarted;
+    private readonly HEALTHY_BUFER_THRESHOLD_SECONDS;
     constructor({ canvas, src, logLevel, sharedAudioContext, }: {
         canvas: HTMLCanvasElement;
         src: string;
         logLevel: LogLevel;
-        sharedAudioContext?: AudioContext | null;
+        sharedAudioContext: AudioContext;
     });
+    private input;
+    private isReady;
+    private hasAudio;
+    private isCurrentlyBuffering;
     initialize(startTime?: number): Promise<void>;
-    seekTo(time: number): void;
-    drawInitialFrame(time?: number): Promise<void>;
+    private cleanupAudioQueue;
+    private cleanAudioIteratorAndNodes;
+    seekTo(time: number): Promise<void>;
     play(): Promise<void>;
     pause(): void;
     dispose(): void;
-    get currentTime(): number;
     private getPlaybackTime;
-    get duration(): number;
-    get isPlaying(): boolean;
-    get stalled(): boolean;
-    onStalledChange(callback: (isStalled: boolean) => void): void;
-    private renderSingleFrame;
+    private scheduleAudioChunk;
+    onBufferingChange(callback: (isBuffering: boolean) => void): void;
+    private canRenderVideo;
     private startRenderLoop;
     private stopRenderLoop;
     private render;
+    private shouldRenderFrame;
+    private drawCurrentFrame;
+    private startAudioIterator;
     private startVideoIterator;
     private updateNextFrame;
-    private tryStartAudio;
-    private getCurrentTimeMs;
-    private resetAudioProgressStopwatch;
-    private getAudioLookaheadSec;
-    private calculateAudioStallThresholdSec;
-    private isNetworkStalled;
-    private checkVideoStall;
-    private checkIfStalled;
-    private updateStalledState;
+    private bufferingStartedAtMs;
+    private minBufferingTimeoutMs;
+    private setBufferingState;
+    private maybeResumeFromBuffering;
+    private maybeForceResumeFromBuffering;
     private runAudioIterator;
 }