@remotion/media 4.0.369 → 4.0.371

package/dist/esm/index.mjs

@@ -2,7 +2,14 @@
 import { Internals as Internals14, useRemotionEnvironment as useRemotionEnvironment2 } from "remotion";
 
 // src/audio/audio-for-preview.tsx
-import { useContext as useContext2, useEffect as useEffect2, useMemo as useMemo2, useRef, useState as useState2 } from "react";
+import {
+  useContext as useContext2,
+  useEffect as useEffect2,
+  useLayoutEffect,
+  useMemo as useMemo2,
+  useRef,
+  useState as useState2
+} from "react";
 import {
   Internals as Internals6,
   Audio as RemotionAudio,
@@ -48,13 +55,30 @@ import { ALL_FORMATS, Input, UrlSource } from "mediabunny";
 import { Internals as Internals3 } from "remotion";
 
 // src/audio-iterator-manager.ts
-import { AudioBufferSink, InputDisposedError } from "mediabunny";
+import { AudioBufferSink } from "mediabunny";
 
 // src/helpers/round-to-4-digits.ts
 var roundTo4Digits = (timestamp) => {
   return Math.round(timestamp * 1000) / 1000;
 };
 
+// src/audio/allow-wait.ts
+var allowWaitRoutine = async (next, waitFn) => {
+  const result = await Promise.race([
+    next,
+    new Promise((resolve) => {
+      Promise.resolve().then(() => resolve());
+    })
+  ]);
+  if (!result) {
+    const unblock = waitFn.waitCallback();
+    const newRes = await next;
+    unblock();
+    return newRes;
+  }
+  return result;
+};
+
 // src/audio/audio-preview-iterator.ts
 var makeAudioIterator = (audioSink, startFromSecond) => {
   let destroyed = false;
@@ -71,7 +95,7 @@ var makeAudioIterator = (audioSink, startFromSecond) => {
   let iteratorEnded = false;
   const getNextOrNullIfNotAvailable = async (allowWait) => {
     const next = iterator.next();
-    const result = allowWait ? await next : await Promise.race([
+    const result = allowWait ? await allowWaitRoutine(next, allowWait) : await Promise.race([
       next,
       new Promise((resolve) => {
         Promise.resolve().then(() => resolve());
@@ -101,7 +125,7 @@ var makeAudioIterator = (audioSink, startFromSecond) => {
       buffer: result.value ?? null
     };
   };
-  const tryToSatisfySeek = async (time, allowWait) => {
+  const tryToSatisfySeek = async (time, allowWait, onBufferScheduled) => {
     if (lastReturnedBuffer) {
       const bufferTimestamp = roundTo4Digits(lastReturnedBuffer.timestamp);
       const bufferEndTimestamp = roundTo4Digits(lastReturnedBuffer.timestamp + lastReturnedBuffer.duration);
@@ -112,19 +136,20 @@ var makeAudioIterator = (audioSink, startFromSecond) => {
         };
       }
       if (roundTo4Digits(time) <= bufferEndTimestamp) {
+        onBufferScheduled(lastReturnedBuffer);
         return {
-          type: "satisfied",
-          buffers: [lastReturnedBuffer]
+          type: "satisfied"
         };
       }
     }
     if (iteratorEnded) {
+      if (lastReturnedBuffer) {
+        onBufferScheduled(lastReturnedBuffer);
+      }
       return {
-        type: "satisfied",
-        buffers: lastReturnedBuffer ? [lastReturnedBuffer] : []
+        type: "satisfied"
       };
     }
-    const toBeReturned = [];
     while (true) {
       const buffer = await getNextOrNullIfNotAvailable(allowWait);
       if (buffer.type === "need-to-wait-for-it") {
@@ -136,21 +161,23 @@ var makeAudioIterator = (audioSink, startFromSecond) => {
       if (buffer.type === "got-buffer-or-end") {
         if (buffer.buffer === null) {
           iteratorEnded = true;
+          if (lastReturnedBuffer) {
+            onBufferScheduled(lastReturnedBuffer);
+          }
           return {
-            type: "satisfied",
-            buffers: lastReturnedBuffer ? [lastReturnedBuffer] : []
+            type: "satisfied"
           };
         }
         const bufferTimestamp = roundTo4Digits(buffer.buffer.timestamp);
         const bufferEndTimestamp = roundTo4Digits(buffer.buffer.timestamp + buffer.buffer.duration);
         const timestamp = roundTo4Digits(time);
         if (bufferTimestamp <= timestamp && bufferEndTimestamp > timestamp) {
+          onBufferScheduled(buffer.buffer);
           return {
-            type: "satisfied",
-            buffers: [...toBeReturned, buffer.buffer]
+            type: "satisfied"
           };
         }
-        toBeReturned.push(buffer.buffer);
+        onBufferScheduled(buffer.buffer);
         continue;
       }
       throw new Error("Unreachable");
@@ -211,13 +238,9 @@ var makeAudioIterator = (audioSink, startFromSecond) => {
       audioChunksForAfterResuming.length = 0;
       return chunks;
     },
-    getQueuedPeriod: (pendingBuffers) => {
+    getQueuedPeriod: () => {
       let until = -Infinity;
       let from = Infinity;
-      for (const buffer of pendingBuffers) {
-        until = Math.max(until, buffer.timestamp + buffer.duration);
-        from = Math.min(from, buffer.timestamp);
-      }
       for (const node of queuedAudioNodes) {
         until = Math.max(until, node.timestamp + node.buffer.duration);
         from = Math.min(from, node.timestamp);
@@ -315,15 +338,7 @@ var audioIteratorManager = ({
     audioIteratorsCreated++;
     audioBufferIterator = iterator;
     for (let i = 0;i < 3; i++) {
-      const result = await iterator.getNext().catch((err) => {
-        if (iterator.isDestroyed() || err instanceof InputDisposedError) {} else {
-          throw err;
-        }
-      });
-      if (!result) {
-        delayHandle.unblock();
-        return;
-      }
+      const result = await iterator.getNext();
       if (iterator.isDestroyed()) {
         delayHandle.unblock();
         return;
@@ -357,7 +372,8 @@ var audioIteratorManager = ({
     fps,
     playbackRate,
     getIsPlaying,
-    scheduleAudioNode
+    scheduleAudioNode,
+    bufferState
   }) => {
     if (!audioBufferIterator) {
       await startAudioIterator({
@@ -369,10 +385,18 @@ var audioIteratorManager = ({
       });
       return;
     }
-    const currentTimeIsAlreadyQueued = isAlreadyQueued(newTime, audioBufferIterator.getQueuedPeriod([]));
-    const toBeScheduled = [];
+    const currentTimeIsAlreadyQueued = isAlreadyQueued(newTime, audioBufferIterator.getQueuedPeriod());
     if (!currentTimeIsAlreadyQueued) {
-      const audioSatisfyResult = await audioBufferIterator.tryToSatisfySeek(newTime, false);
+      const audioSatisfyResult = await audioBufferIterator.tryToSatisfySeek(newTime, null, (buffer) => {
+        if (!nonce.isStale()) {
+          onAudioChunk({
+            getIsPlaying,
+            buffer,
+            playbackRate,
+            scheduleAudioNode
+          });
+        }
+      });
       if (nonce.isStale()) {
         return;
       }
@@ -386,12 +410,28 @@ var audioIteratorManager = ({
         });
         return;
       }
-      toBeScheduled.push(...audioSatisfyResult.buffers);
     }
-    const nextTime = newTime + 1 / fps * playbackRate + 1 / fps * playbackRate;
-    const nextIsAlreadyQueued = isAlreadyQueued(nextTime, audioBufferIterator.getQueuedPeriod(toBeScheduled));
+    const nextTime = newTime + 1 / fps * Math.max(1, playbackRate) * 3;
+    const nextIsAlreadyQueued = isAlreadyQueued(nextTime, audioBufferIterator.getQueuedPeriod());
     if (!nextIsAlreadyQueued) {
-      const audioSatisfyResult = await audioBufferIterator.tryToSatisfySeek(nextTime, true);
+      const audioSatisfyResult = await audioBufferIterator.tryToSatisfySeek(nextTime, {
+        type: "allow-wait",
+        waitCallback: () => {
+          const handle = bufferState.delayPlayback();
+          return () => {
+            handle.unblock();
+          };
+        }
+      }, (buffer) => {
+        if (!nonce.isStale()) {
+          onAudioChunk({
+            getIsPlaying,
+            buffer,
+            playbackRate,
+            scheduleAudioNode
+          });
+        }
+      });
       if (nonce.isStale()) {
         return;
       }
@@ -403,17 +443,7 @@ var audioIteratorManager = ({
           getIsPlaying,
           scheduleAudioNode
         });
-        return;
       }
-      toBeScheduled.push(...audioSatisfyResult.buffers);
-    }
-    for (const buffer of toBeScheduled) {
-      onAudioChunk({
-        getIsPlaying,
-        buffer,
-        playbackRate,
-        scheduleAudioNode
-      });
     }
   };
   const resumeScheduledAudioChunks = ({
@@ -484,7 +514,7 @@ var drawPreviewOverlay = ({
     `Audio time: ${(audioTime - audioSyncAnchor).toFixed(3)}s`
   ];
   if (audioIteratorManager2) {
-    const queuedPeriod = audioIteratorManager2.getAudioBufferIterator()?.getQueuedPeriod([]);
+    const queuedPeriod = audioIteratorManager2.getAudioBufferIterator()?.getQueuedPeriod();
     const numberOfChunksAfterResuming = audioIteratorManager2?.getAudioBufferIterator()?.getNumberOfChunksAfterResuming();
     if (queuedPeriod) {
       lines.push(`Audio queued until: ${(queuedPeriod.until - (audioTime - audioSyncAnchor)).toFixed(3)}s`);
@@ -971,7 +1001,8 @@ class MediaPlayer {
       fps: this.fps,
       playbackRate: this.playbackRate * this.globalPlaybackRate,
       getIsPlaying: () => this.playing,
-      scheduleAudioNode: this.scheduleAudioNode
+      scheduleAudioNode: this.scheduleAudioNode,
+      bufferState: this.bufferState
     });
   }
   async play(time) {
@@ -1486,7 +1517,7 @@ var AudioForPreviewAssertedShowing = ({
       audioPlayer.pause();
     }
   }, [isPlayerBuffering, logLevel, playing]);
-  useEffect2(() => {
+  useLayoutEffect(() => {
     const audioPlayer = mediaPlayerRef.current;
     if (!audioPlayer || !mediaPlayerReady)
       return;
@@ -1651,7 +1682,7 @@ var AudioForPreview = ({
 };
 
 // src/audio/audio-for-rendering.tsx
-import { useContext as useContext3, useLayoutEffect, useMemo as useMemo3, useState as useState3 } from "react";
+import { useContext as useContext3, useLayoutEffect as useLayoutEffect2, useMemo as useMemo3, useState as useState3 } from "react";
 import {
   cancelRender as cancelRender2,
   Html5Audio,
@@ -2689,33 +2720,28 @@ var getMaxVideoCacheSize = (logLevel) => {
   return cachedMaxCacheSize;
 };
 
-// src/convert-audiodata/combine-audiodata.ts
-var combineAudioDataAndClosePrevious = (audioDataArray) => {
-  let numberOfFrames = 0;
-  const { timestamp } = audioDataArray[0];
-  for (const audioData of audioDataArray) {
-    numberOfFrames += audioData.numberOfFrames;
+// src/convert-audiodata/convert-audiodata.ts
+var FORMAT = "s16";
+var fixFloatingPoint2 = (value) => {
+  if (value % 1 < 0.0000001) {
+    return Math.floor(value);
   }
-  const arr = new Int16Array(numberOfFrames * TARGET_NUMBER_OF_CHANNELS);
-  let offset = 0;
-  for (const audioData of audioDataArray) {
-    arr.set(audioData.data, offset);
-    offset += audioData.data.length;
+  if (value % 1 > 0.9999999) {
+    return Math.ceil(value);
   }
-  return {
-    data: arr,
-    numberOfFrames,
-    timestamp
-  };
+  return value;
+};
+var ceilButNotIfFloatingPointIssue = (value) => {
+  const fixed = fixFloatingPoint2(value);
+  return Math.ceil(fixed);
 };
-
-// src/convert-audiodata/convert-audiodata.ts
-var FORMAT = "s16";
 var convertAudioData = ({
   audioData,
   trimStartInSeconds,
   trimEndInSeconds,
-  playbackRate
+  playbackRate,
+  audioDataTimestamp,
+  isLast
 }) => {
   const {
     numberOfChannels: srcNumberOfChannels,
@@ -2723,10 +2749,10 @@ var convertAudioData = ({
     numberOfFrames
   } = audioData;
   const ratio = currentSampleRate / TARGET_SAMPLE_RATE;
-  const frameOffset = Math.floor(trimStartInSeconds * audioData.sampleRate);
-  const unroundedFrameCount = numberOfFrames - (trimEndInSeconds + trimStartInSeconds) * audioData.sampleRate;
-  const frameCount = Math.ceil(unroundedFrameCount);
-  const newNumberOfFrames = Math.ceil(unroundedFrameCount / ratio / playbackRate);
+  const frameOffset = Math.floor(fixFloatingPoint2(trimStartInSeconds * audioData.sampleRate));
+  const unroundedFrameCount = numberOfFrames - trimEndInSeconds * audioData.sampleRate - frameOffset;
+  const frameCount = isLast ? ceilButNotIfFloatingPointIssue(unroundedFrameCount) : Math.round(unroundedFrameCount);
+  const newNumberOfFrames = isLast ? ceilButNotIfFloatingPointIssue(unroundedFrameCount / ratio / playbackRate) : Math.round(unroundedFrameCount / ratio / playbackRate);
   if (newNumberOfFrames === 0) {
     throw new Error("Cannot resample - the given sample rate would result in less than 1 sample");
   }
@@ -2739,11 +2765,13 @@ var convertAudioData = ({
   });
   const data = new Int16Array(newNumberOfFrames * TARGET_NUMBER_OF_CHANNELS);
   const chunkSize = frameCount / newNumberOfFrames;
+  const timestampOffsetMicroseconds = frameOffset / audioData.sampleRate * 1e6;
   if (newNumberOfFrames === frameCount && TARGET_NUMBER_OF_CHANNELS === srcNumberOfChannels && playbackRate === 1) {
     return {
       data: srcChannels,
       numberOfFrames: newNumberOfFrames,
-      timestamp: audioData.timestamp + frameOffset / audioData.sampleRate * 1e6
+      timestamp: audioDataTimestamp * 1e6 + fixFloatingPoint2(timestampOffsetMicroseconds),
+      durationInMicroSeconds: fixFloatingPoint2(newNumberOfFrames / TARGET_SAMPLE_RATE * 1e6)
     };
   }
   resampleAudioData({
@@ -2756,11 +2784,35 @@ var convertAudioData = ({
   const newAudioData = {
     data,
     numberOfFrames: newNumberOfFrames,
-    timestamp: audioData.timestamp + frameOffset / audioData.sampleRate * 1e6
+    timestamp: audioDataTimestamp * 1e6 + fixFloatingPoint2(timestampOffsetMicroseconds),
+    durationInMicroSeconds: fixFloatingPoint2(newNumberOfFrames / TARGET_SAMPLE_RATE * 1e6)
   };
   return newAudioData;
 };
 
+// src/convert-audiodata/combine-audiodata.ts
+var combineAudioDataAndClosePrevious = (audioDataArray) => {
+  let numberOfFrames = 0;
+  let durationInMicroSeconds = 0;
+  const { timestamp } = audioDataArray[0];
+  for (const audioData of audioDataArray) {
+    numberOfFrames += audioData.numberOfFrames;
+    durationInMicroSeconds += audioData.durationInMicroSeconds;
+  }
+  const arr = new Int16Array(numberOfFrames * TARGET_NUMBER_OF_CHANNELS);
+  let offset = 0;
+  for (const audioData of audioDataArray) {
+    arr.set(audioData.data, offset);
+    offset += audioData.data.length;
+  }
+  return {
+    data: arr,
+    numberOfFrames,
+    timestamp: fixFloatingPoint2(timestamp),
+    durationInMicroSeconds: fixFloatingPoint2(durationInMicroSeconds)
+  };
+};
+
 // src/get-sink.ts
 import { Internals as Internals12 } from "remotion";
 var sinkPromises = {};
@@ -2860,7 +2912,9 @@ var extractAudioInternal = async ({
       audioData: audioDataRaw,
       trimStartInSeconds,
       trimEndInSeconds,
-      playbackRate
+      playbackRate,
+      audioDataTimestamp: sample.timestamp,
+      isLast: isLastSample
     });
     audioDataRaw.close();
     if (audioData.numberOfFrames === 0) {
@@ -3281,7 +3335,7 @@ var AudioForRendering = ({
     sequenceContext?.relativeFrom,
     sequenceContext?.durationInFrames
   ]);
-  useLayoutEffect(() => {
+  useLayoutEffect2(() => {
     const timestamp = frame / fps;
     const durationInSeconds = 1 / fps;
     if (replaceWithHtml5Audio) {
@@ -3466,7 +3520,7 @@ import { Internals as Internals17, useRemotionEnvironment as useRemotionEnvironm
 import {
   useContext as useContext4,
   useEffect as useEffect3,
-  useLayoutEffect as useLayoutEffect2,
+  useLayoutEffect as useLayoutEffect3,
   useMemo as useMemo4,
   useRef as useRef2,
   useState as useState4
@@ -3687,7 +3741,7 @@ var VideoForPreviewAssertedShowing = ({
       mediaPlayer.pause();
     }
   }, [isPlayerBuffering, playing, logLevel, mediaPlayerReady]);
-  useLayoutEffect2(() => {
+  useLayoutEffect3(() => {
     const mediaPlayer = mediaPlayerRef.current;
     if (!mediaPlayer || !mediaPlayerReady)
       return;
@@ -3846,7 +3900,7 @@ var VideoForPreview = (props) => {
 // src/video/video-for-rendering.tsx
 import {
   useContext as useContext5,
-  useLayoutEffect as useLayoutEffect3,
+  useLayoutEffect as useLayoutEffect4,
   useMemo as useMemo5,
   useRef as useRef3,
   useState as useState5
@@ -3905,7 +3959,7 @@ var VideoForRendering = ({
   const [replaceWithOffthreadVideo, setReplaceWithOffthreadVideo] = useState5(false);
   const audioEnabled = Internals16.useAudioEnabled();
   const videoEnabled = Internals16.useVideoEnabled();
-  useLayoutEffect3(() => {
+  useLayoutEffect4(() => {
     if (!canvasRef.current) {
       return;
     }
@@ -4099,15 +4153,15 @@ var VideoForRendering = ({
       volume: volumeProp,
       id,
       onError: fallbackOffthreadVideoProps?.onError,
-      toneFrequency: fallbackOffthreadVideoProps?.toneFrequency ?? 1,
+      toneFrequency,
       showInTimeline: false,
       crossOrigin: undefined,
       onAutoPlayError: () => {
         return;
       },
       pauseWhenBuffering: false,
-      trimAfter: undefined,
-      trimBefore: undefined,
+      trimAfter: trimAfterValue,
+      trimBefore: trimBeforeValue,
       useWebAudioApi: false,
       startFrom: undefined,
       endAt: undefined,

package/dist/media-player.js

@@ -245,6 +245,7 @@ export class MediaPlayer {
             playbackRate: this.playbackRate * this.globalPlaybackRate,
             getIsPlaying: () => this.playing,
             scheduleAudioNode: this.scheduleAudioNode,
+            bufferState: this.bufferState,
         });
     }
     async play(time) {

package/dist/video/props.d.ts

@@ -1,7 +1,6 @@
 import type { LogLevel, LoopVolumeCurveBehavior, OnVideoFrame, VolumeProp } from 'remotion';
 export type FallbackOffthreadVideoProps = {
     acceptableTimeShiftInSeconds?: number;
-    toneFrequency?: number;
     transparent?: boolean;
     toneMapped?: boolean;
     onError?: (err: Error) => void;

package/dist/video/video-for-rendering.js

@@ -213,9 +213,9 @@ export const VideoForRendering = ({ volume: volumeProp, playbackRate, src, muted
             .join(' ');
     }, [className]);
     if (replaceWithOffthreadVideo) {
-        const fallback = (_jsx(Internals.InnerOffthreadVideo, { src: src, playbackRate: playbackRate ?? 1, muted: muted ?? false, acceptableTimeShiftInSeconds: fallbackOffthreadVideoProps?.acceptableTimeShiftInSeconds, loopVolumeCurveBehavior: loopVolumeCurveBehavior ?? 'repeat', delayRenderRetries: delayRenderRetries ?? undefined, delayRenderTimeoutInMilliseconds: delayRenderTimeoutInMilliseconds ?? undefined, style: style, allowAmplificationDuringRender: true, transparent: fallbackOffthreadVideoProps?.transparent ?? true, toneMapped: fallbackOffthreadVideoProps?.toneMapped ?? true, audioStreamIndex: audioStreamIndex ?? 0, name: name, className: className, onVideoFrame: onVideoFrame, volume: volumeProp, id: id, onError: fallbackOffthreadVideoProps?.onError, toneFrequency: fallbackOffthreadVideoProps?.toneFrequency ?? 1, 
+        const fallback = (_jsx(Internals.InnerOffthreadVideo, { src: src, playbackRate: playbackRate ?? 1, muted: muted ?? false, acceptableTimeShiftInSeconds: fallbackOffthreadVideoProps?.acceptableTimeShiftInSeconds, loopVolumeCurveBehavior: loopVolumeCurveBehavior ?? 'repeat', delayRenderRetries: delayRenderRetries ?? undefined, delayRenderTimeoutInMilliseconds: delayRenderTimeoutInMilliseconds ?? undefined, style: style, allowAmplificationDuringRender: true, transparent: fallbackOffthreadVideoProps?.transparent ?? true, toneMapped: fallbackOffthreadVideoProps?.toneMapped ?? true, audioStreamIndex: audioStreamIndex ?? 0, name: name, className: className, onVideoFrame: onVideoFrame, volume: volumeProp, id: id, onError: fallbackOffthreadVideoProps?.onError, toneFrequency: toneFrequency, 
             // these shouldn't matter during rendering / should not appear at all
-            showInTimeline: false, crossOrigin: undefined, onAutoPlayError: () => undefined, pauseWhenBuffering: false, trimAfter: undefined, trimBefore: undefined, useWebAudioApi: false, startFrom: undefined, endAt: undefined, stack: stack, _remotionInternalNativeLoopPassed: false }));
+            showInTimeline: false, crossOrigin: undefined, onAutoPlayError: () => undefined, pauseWhenBuffering: false, trimAfter: trimAfterValue, trimBefore: trimBeforeValue, useWebAudioApi: false, startFrom: undefined, endAt: undefined, stack: stack, _remotionInternalNativeLoopPassed: false }));
         if (loop) {
             if (!replaceWithOffthreadVideo.durationInSeconds) {
                 cancelRender(new Error(`Cannot render video ${src}: @remotion/media was unable to render, and fell back to <OffthreadVideo>. Also, "loop" was set, but <OffthreadVideo> does not support looping and @remotion/media could also not determine the duration of the video.`));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/media",
-	"version": "4.0.369",
+	"version": "4.0.371",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"module": "dist/esm/index.mjs",
@@ -21,8 +21,8 @@
 		"make": "tsc -d && bun --env-file=../.env.bundle bundle.ts"
 	},
 	"dependencies": {
-		"mediabunny": "1.24.2",
-		"remotion": "4.0.369",
+		"mediabunny": "1.24.3",
+		"remotion": "4.0.371",
 		"webdriverio": "9.19.2"
 	},
 	"peerDependencies": {
@@ -30,7 +30,7 @@
 		"react-dom": ">=16.8.0"
 	},
 	"devDependencies": {
-		"@remotion/eslint-config-internal": "4.0.369",
+		"@remotion/eslint-config-internal": "4.0.371",
 		"@vitest/browser": "^3.2.4",
 		"eslint": "9.19.0",
 		"react": "19.0.0",

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

@@ -1,11 +0,0 @@
-import type { AudioBufferSink } from 'mediabunny';
-export declare const HEALTHY_BUFFER_THRESHOLD_SECONDS = 1;
-export declare const makeAudioIterator: (audioSink: AudioBufferSink, startFromSecond: number) => {
-    iterator: AsyncGenerator<import("mediabunny").WrappedAudioBuffer, void, unknown>;
-    destroy: () => void;
-    isReadyToPlay: () => boolean;
-    setAudioIteratorStarted: (started: boolean) => void;
-    getNext: () => Promise<IteratorResult<import("mediabunny").WrappedAudioBuffer, void>>;
-    setAudioBufferHealth: (health: number) => void;
-};
-export type AudioIterator = ReturnType<typeof makeAudioIterator>;

package/dist/audio/audio-iterator.js

@@ -1,24 +0,0 @@
-export const HEALTHY_BUFFER_THRESHOLD_SECONDS = 1;
-export const makeAudioIterator = (audioSink, startFromSecond) => {
-    const iterator = audioSink.buffers(startFromSecond);
-    let audioIteratorStarted = false;
-    let audioBufferHealth = 0;
-    return {
-        iterator,
-        destroy: () => {
-            iterator.return().catch(() => undefined);
-        },
-        isReadyToPlay: () => {
-            return audioIteratorStarted && audioBufferHealth > 0;
-        },
-        setAudioIteratorStarted: (started) => {
-            audioIteratorStarted = started;
-        },
-        getNext: () => {
-            return iterator.next();
-        },
-        setAudioBufferHealth: (health) => {
-            audioBufferHealth = health;
-        },
-    };
-};

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

@@ -1,98 +0,0 @@
-import type { LogLevel } from 'remotion';
-export declare const SEEK_THRESHOLD = 0.05;
-export type MediaPlayerInitResult = {
-    type: 'success';
-    durationInSeconds: number;
-} | {
-    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 currentVolume;
-    private sharedAudioContext;
-    private audioSyncAnchor;
-    private playing;
-    private muted;
-    private loop;
-    private fps;
-    private trimBefore;
-    private trimAfter;
-    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 mediaEnded;
-    private onVideoFrameCallback?;
-    constructor({ canvas, src, logLevel, sharedAudioContext, loop, trimBefore, trimAfter, playbackRate, audioStreamIndex, fps, }: {
-        canvas: HTMLCanvasElement | null;
-        src: string;
-        logLevel: LogLevel;
-        sharedAudioContext: AudioContext;
-        loop: boolean;
-        trimBefore: number | undefined;
-        trimAfter: number | undefined;
-        playbackRate: number;
-        audioStreamIndex: number;
-        fps: number;
-    });
-    private input;
-    private isReady;
-    private hasAudio;
-    private isCurrentlyBuffering;
-    initialize(startTimeUnresolved: number): Promise<MediaPlayerInitResult>;
-    private clearCanvas;
-    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;
-    setFps(fps: 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;
-}