@remotion/media 4.0.351

package/dist/extract-audio.d.ts

@@ -0,0 +1,7 @@
+import type { PcmS16AudioData } from './convert-audiodata/convert-audiodata';
+export declare const extractAudio: ({ src, timeInSeconds, durationInSeconds, volume, }: {
+    src: string;
+    timeInSeconds: number;
+    durationInSeconds: number;
+    volume: number;
+}) => Promise<PcmS16AudioData | null>;

package/dist/extract-audio.js

@@ -0,0 +1,98 @@
+import { combineAudioDataAndClosePrevious } from './convert-audiodata/combine-audiodata';
+import { convertAudioData } from './convert-audiodata/convert-audiodata';
+import { TARGET_NUMBER_OF_CHANNELS, TARGET_SAMPLE_RATE, } from './convert-audiodata/resample-audiodata';
+import { sinkPromises } from './extract-frame';
+import { getSinks } from './video-extraction/get-frames-since-keyframe';
+export const extractAudio = async ({ src, timeInSeconds, durationInSeconds, volume, }) => {
+    console.time('extractAudio');
+    if (!sinkPromises[src]) {
+        sinkPromises[src] = getSinks(src);
+    }
+    const { audio, actualMatroskaTimestamps, isMatroska } = await sinkPromises[src];
+    if (audio === null) {
+        console.timeEnd('extractAudio');
+        return null;
+    }
+    // https://discord.com/channels/@me/1409810025844838481/1415028953093111870
+    // Audio frames might have dependencies on previous and next frames so we need to decode a bit more
+    // and then discard it.
+    // The worst case seems to be FLAC files with a 65'535 sample window, which would be 1486.0ms at 44.1Khz.
+    // So let's set a threshold of 1.5 seconds.
+    const extraThreshold = 1.5;
+    // Matroska timestamps are not accurate unless we start from the beginning
+    // So for matroska, we need to decode all samples :(
+    // https://github.com/Vanilagy/mediabunny/issues/105
+    const sampleIterator = audio.sampleSink.samples(isMatroska ? 0 : Math.max(0, timeInSeconds - extraThreshold), timeInSeconds + durationInSeconds);
+    const samples = [];
+    for await (const sample of sampleIterator) {
+        const realTimestamp = actualMatroskaTimestamps.getRealTimestamp(sample.timestamp);
+        if (realTimestamp !== null && realTimestamp !== sample.timestamp) {
+            sample.setTimestamp(realTimestamp);
+        }
+        actualMatroskaTimestamps.observeTimestamp(sample.timestamp);
+        actualMatroskaTimestamps.observeTimestamp(sample.timestamp + sample.duration);
+        if (sample.timestamp + sample.duration - 0.0000000001 <= timeInSeconds) {
+            continue;
+        }
+        if (sample.timestamp >= timeInSeconds + durationInSeconds - 0.0000000001) {
+            continue;
+        }
+        samples.push(sample);
+    }
+    const audioDataArray = [];
+    for (let i = 0; i < samples.length; i++) {
+        const sample = samples[i];
+        // Less than 1 sample would be included - we did not need it after all!
+        if (Math.abs(sample.timestamp - (timeInSeconds + durationInSeconds)) *
+            sample.sampleRate <
+            1) {
+            sample.close();
+            continue;
+        }
+        // Less than 1 sample would be included - we did not need it after all!
+        if (sample.timestamp + sample.duration <= timeInSeconds) {
+            sample.close();
+            continue;
+        }
+        const isFirstSample = i === 0;
+        const isLastSample = i === samples.length - 1;
+        const audioDataRaw = sample.toAudioData();
+        // amount of samples to shave from start and end
+        let trimStartInSeconds = 0;
+        let trimEndInSeconds = 0;
+        // TODO: Apply playback rate
+        // TODO: Apply tone frequency
+        if (isFirstSample) {
+            trimStartInSeconds = timeInSeconds - sample.timestamp;
+        }
+        if (isLastSample) {
+            trimEndInSeconds =
+                // clamp to 0 in case the audio ends early
+                Math.max(0, sample.timestamp +
+                    sample.duration -
+                    (timeInSeconds + durationInSeconds));
+        }
+        const audioData = convertAudioData({
+            audioData: audioDataRaw,
+            newSampleRate: TARGET_SAMPLE_RATE,
+            trimStartInSeconds,
+            trimEndInSeconds,
+            targetNumberOfChannels: TARGET_NUMBER_OF_CHANNELS,
+            volume,
+        });
+        audioDataRaw.close();
+        if (audioData.numberOfFrames === 0) {
+            sample.close();
+            continue;
+        }
+        audioDataArray.push(audioData);
+        sample.close();
+    }
+    if (audioDataArray.length === 0) {
+        console.timeEnd('extractAudio');
+        return null;
+    }
+    const combined = combineAudioDataAndClosePrevious(audioDataArray);
+    console.timeEnd('extractAudio');
+    return combined;
+};

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

@@ -0,0 +1,15 @@
+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, }: {
+    src: string;
+    timeInSeconds: number;
+    logLevel: LogLevel;
+    durationInSeconds: number;
+    includeAudio: boolean;
+    includeVideo: boolean;
+    volume: number;
+    loop: boolean;
+}) => Promise<{
+    frame: VideoFrame | null;
+    audio: PcmS16AudioData | null;
+}>;

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

@@ -0,0 +1,28 @@
+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, }) => {
+    const [frame, audio] = await Promise.all([
+        includeVideo
+            ? extractFrame({
+                src,
+                timeInSeconds,
+                logLevel,
+                loop,
+            })
+            : null,
+        includeAudio
+            ? extractAudio({
+                src,
+                timeInSeconds,
+                durationInSeconds,
+                volume,
+                logLevel,
+                loop,
+            })
+            : null,
+    ]);
+    return {
+        frame: frame?.toVideoFrame() ?? null,
+        audio,
+    };
+};

package/dist/extract-frame-via-broadcast-channel.d.ts

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

package/dist/extract-frame-via-broadcast-channel.js

@@ -0,0 +1,104 @@
+import { extractFrameAndAudio } from './extract-frame-and-audio';
+// Doesn't exist in studio
+if (window.remotion_broadcastChannel && window.remotion_isMainTab) {
+    window.remotion_broadcastChannel.addEventListener('message', async (event) => {
+        const data = event.data;
+        if (data.type === 'request') {
+            try {
+                const { frame, audio } = await extractFrameAndAudio({
+                    src: data.src,
+                    timeInSeconds: data.timeInSeconds,
+                    logLevel: data.logLevel,
+                    durationInSeconds: data.durationInSeconds,
+                    includeAudio: data.includeAudio,
+                    includeVideo: data.includeVideo,
+                    volume: data.volume,
+                });
+                const videoFrame = frame;
+                const imageBitmap = videoFrame
+                    ? await createImageBitmap(videoFrame)
+                    : null;
+                if (videoFrame) {
+                    videoFrame.close();
+                }
+                const response = {
+                    type: 'response-success',
+                    id: data.id,
+                    frame: imageBitmap,
+                    audio,
+                };
+                window.remotion_broadcastChannel.postMessage(response);
+                videoFrame?.close();
+            }
+            catch (error) {
+                const response = {
+                    type: 'response-error',
+                    id: data.id,
+                    errorStack: error.stack ?? 'No stack trace',
+                };
+                window.remotion_broadcastChannel.postMessage(response);
+            }
+        }
+        else {
+            throw new Error('Invalid message: ' + JSON.stringify(data));
+        }
+    });
+}
+export const extractFrameViaBroadcastChannel = ({ src, timeInSeconds, logLevel, durationInSeconds, includeAudio, includeVideo, isClientSideRendering, volume, }) => {
+    if (isClientSideRendering || window.remotion_isMainTab) {
+        return extractFrameAndAudio({
+            logLevel,
+            src,
+            timeInSeconds,
+            durationInSeconds,
+            includeAudio,
+            includeVideo,
+            volume,
+        });
+    }
+    const requestId = crypto.randomUUID();
+    const resolvePromise = new Promise((resolve, reject) => {
+        const onMessage = (event) => {
+            const data = event.data;
+            if (!data) {
+                return;
+            }
+            if (data.type === 'response-success' && data.id === requestId) {
+                resolve({
+                    frame: data.frame ? data.frame : null,
+                    audio: data.audio ? data.audio : null,
+                });
+                window.remotion_broadcastChannel.removeEventListener('message', onMessage);
+            }
+            else if (data.type === 'response-error' && data.id === requestId) {
+                reject(data.errorStack);
+                window.remotion_broadcastChannel.removeEventListener('message', onMessage);
+            }
+        };
+        window.remotion_broadcastChannel.addEventListener('message', onMessage);
+    });
+    const request = {
+        type: 'request',
+        src,
+        timeInSeconds,
+        id: requestId,
+        logLevel,
+        durationInSeconds,
+        includeAudio,
+        includeVideo,
+        volume,
+    };
+    window.remotion_broadcastChannel.postMessage(request);
+    let timeoutId;
+    return Promise.race([
+        resolvePromise.then((res) => {
+            clearTimeout(timeoutId);
+            return res;
+        }),
+        new Promise((_, reject) => {
+            timeoutId = setTimeout(() => {
+                reject(new Error(`Timeout while extracting frame at time ${timeInSeconds}sec from ${src}`));
+            }, Math.max(3000, window.remotion_puppeteerTimeout - 5000));
+        }),
+    ]);
+};

package/dist/extract-frame.d.ts

@@ -0,0 +1,27 @@
+import type { LogLevel } from './log';
+import { type GetSink } from './video-extraction/get-frames-since-keyframe';
+export declare const keyframeManager: {
+    requestKeyframeBank: ({ packetSink, timestamp, videoSampleSink, src, logLevel, }: {
+        timestamp: number;
+        packetSink: import("mediabunny").EncodedPacketSink;
+        videoSampleSink: import("mediabunny").VideoSampleSink;
+        src: string;
+        logLevel: LogLevel;
+    }) => Promise<import("./video-extraction/keyframe-bank").KeyframeBank>;
+    addKeyframeBank: ({ src, bank, startTimestampInSeconds, }: {
+        src: string;
+        bank: Promise<import("./video-extraction/keyframe-bank").KeyframeBank>;
+        startTimestampInSeconds: number;
+    }) => void;
+    getCacheStats: () => Promise<{
+        count: number;
+        totalSize: number;
+    }>;
+    clearAll: () => Promise<void>;
+};
+export declare const sinkPromises: Record<string, Promise<GetSink>>;
+export declare const extractFrame: ({ src, timeInSeconds, logLevel, }: {
+    src: string;
+    timeInSeconds: number;
+    logLevel: LogLevel;
+}) => Promise<import("mediabunny").VideoSample | null>;

package/dist/extract-frame.js

@@ -0,0 +1,21 @@
+import { getSinks, } from './video-extraction/get-frames-since-keyframe';
+import { makeKeyframeManager } from './video-extraction/keyframe-manager';
+export const keyframeManager = makeKeyframeManager();
+export const sinkPromises = {};
+export const extractFrame = async ({ src, timeInSeconds, logLevel, }) => {
+    console.time('extractFrame');
+    if (!sinkPromises[src]) {
+        sinkPromises[src] = getSinks(src);
+    }
+    const { video } = await sinkPromises[src];
+    const keyframeBank = await keyframeManager.requestKeyframeBank({
+        packetSink: video.packetSink,
+        videoSampleSink: video.sampleSink,
+        timestamp: timeInSeconds,
+        src,
+        logLevel,
+    });
+    const frame = await keyframeBank.getFrameFromTimestamp(timeInSeconds);
+    console.timeEnd('extractFrame');
+    return frame;
+};

package/dist/extrct-audio.d.ts

@@ -0,0 +1,7 @@
+import type { PcmS16AudioData } from './convert-audiodata/convert-audiodata';
+export declare const extractAudio: ({ src, timeInSeconds, durationInSeconds, volume, }: {
+    src: string;
+    timeInSeconds: number;
+    durationInSeconds: number;
+    volume: number;
+}) => Promise<PcmS16AudioData | null>;

package/dist/extrct-audio.js

@@ -0,0 +1,94 @@
+import { combineAudioDataAndClosePrevious } from './convert-audiodata/combine-audiodata';
+import { convertAudioData } from './convert-audiodata/convert-audiodata';
+import { TARGET_NUMBER_OF_CHANNELS, TARGET_SAMPLE_RATE, } from './convert-audiodata/resample-audiodata';
+import { sinkPromises } from './extract-frame';
+import { getSinks } from './get-frames-since-keyframe';
+export const extractAudio = async ({ src, timeInSeconds, durationInSeconds, volume, }) => {
+    if (!sinkPromises[src]) {
+        sinkPromises[src] = getSinks(src);
+    }
+    const { audio, actualMatroskaTimestamps, isMatroska } = await sinkPromises[src];
+    if (audio === null) {
+        return null;
+    }
+    // https://discord.com/channels/@me/1409810025844838481/1415028953093111870
+    // Audio frames might have dependencies on previous and next frames so we need to decode a bit more
+    // and then discard it.
+    // The worst case seems to be FLAC files with a 65'535 sample window, which would be 1486.0ms at 44.1Khz.
+    // So let's set a threshold of 1.5 seconds.
+    const extraThreshold = 1.5;
+    // Matroska timestamps are not accurate unless we start from the beginning
+    // So for matroska, we need to decode all samples :(
+    // https://github.com/Vanilagy/mediabunny/issues/105
+    const sampleIterator = audio.sampleSink.samples(isMatroska ? 0 : Math.max(0, timeInSeconds - extraThreshold), timeInSeconds + durationInSeconds);
+    const samples = [];
+    for await (const sample of sampleIterator) {
+        const realTimestamp = actualMatroskaTimestamps.getRealTimestamp(sample.timestamp);
+        if (realTimestamp !== null && realTimestamp !== sample.timestamp) {
+            sample.setTimestamp(realTimestamp);
+        }
+        actualMatroskaTimestamps.observeTimestamp(sample.timestamp);
+        actualMatroskaTimestamps.observeTimestamp(sample.timestamp + sample.duration);
+        if (sample.timestamp + sample.duration - 0.0000000001 <= timeInSeconds) {
+            continue;
+        }
+        if (sample.timestamp >= timeInSeconds + durationInSeconds - 0.0000000001) {
+            continue;
+        }
+        samples.push(sample);
+    }
+    const audioDataArray = [];
+    for (let i = 0; i < samples.length; i++) {
+        const sample = samples[i];
+        // Less than 1 sample would be included - we did not need it after all!
+        if (Math.abs(sample.timestamp - (timeInSeconds + durationInSeconds)) *
+            sample.sampleRate <
+            1) {
+            sample.close();
+            continue;
+        }
+        // Less than 1 sample would be included - we did not need it after all!
+        if (sample.timestamp + sample.duration <= timeInSeconds) {
+            sample.close();
+            continue;
+        }
+        const isFirstSample = i === 0;
+        const isLastSample = i === samples.length - 1;
+        const audioDataRaw = sample.toAudioData();
+        // amount of samples to shave from start and end
+        let trimStartInSeconds = 0;
+        let trimEndInSeconds = 0;
+        // TODO: Apply playback rate
+        // TODO: Apply tone frequency
+        if (isFirstSample) {
+            trimStartInSeconds = timeInSeconds - sample.timestamp;
+        }
+        if (isLastSample) {
+            trimEndInSeconds =
+                // clamp to 0 in case the audio ends early
+                Math.max(0, sample.timestamp +
+                    sample.duration -
+                    (timeInSeconds + durationInSeconds));
+        }
+        const audioData = convertAudioData({
+            audioData: audioDataRaw,
+            newSampleRate: TARGET_SAMPLE_RATE,
+            trimStartInSeconds,
+            trimEndInSeconds,
+            targetNumberOfChannels: TARGET_NUMBER_OF_CHANNELS,
+            volume,
+        });
+        audioDataRaw.close();
+        if (audioData.numberOfFrames === 0) {
+            sample.close();
+            continue;
+        }
+        audioDataArray.push(audioData);
+        sample.close();
+    }
+    if (audioDataArray.length === 0) {
+        return null;
+    }
+    const combined = combineAudioDataAndClosePrevious(audioDataArray);
+    return combined;
+};

package/dist/get-frames-since-keyframe.d.ts

@@ -0,0 +1,22 @@
+import type { EncodedPacket } from 'mediabunny';
+import { AudioSampleSink, EncodedPacketSink, VideoSampleSink } from 'mediabunny';
+export declare const getSinks: (src: string) => Promise<{
+    video: {
+        sampleSink: VideoSampleSink;
+        packetSink: EncodedPacketSink;
+    };
+    audio: {
+        sampleSink: AudioSampleSink;
+    } | null;
+    actualMatroskaTimestamps: {
+        observeTimestamp: (startTime: number) => void;
+        getRealTimestamp: (observedTimestamp: number) => number | null;
+    };
+    isMatroska: boolean;
+}>;
+export type GetSink = Awaited<ReturnType<typeof getSinks>>;
+export declare const getFramesSinceKeyframe: ({ packetSink, videoSampleSink, startPacket, }: {
+    packetSink: EncodedPacketSink;
+    videoSampleSink: VideoSampleSink;
+    startPacket: EncodedPacket;
+}) => Promise<any>;

package/dist/get-frames-since-keyframe.js

@@ -0,0 +1,41 @@
+import { ALL_FORMATS, AudioSampleSink, EncodedPacketSink, Input, MATROSKA, UrlSource, VideoSampleSink, } from 'mediabunny';
+import { makeKeyframeBank } from './keyframe-bank';
+import { rememberActualMatroskaTimestamps } from './remember-actual-matroska-timestamps';
+export const getSinks = async (src) => {
+    const input = new Input({
+        formats: ALL_FORMATS,
+        source: new UrlSource(src),
+    });
+    const format = await input.getFormat();
+    const videoTrack = await input.getPrimaryVideoTrack();
+    if (!videoTrack) {
+        throw new Error(`No video track found for ${src}`);
+    }
+    const audioTrack = await input.getPrimaryAudioTrack();
+    const isMatroska = format === MATROSKA;
+    return {
+        video: {
+            sampleSink: new VideoSampleSink(videoTrack),
+            packetSink: new EncodedPacketSink(videoTrack),
+        },
+        audio: audioTrack
+            ? {
+                sampleSink: new AudioSampleSink(audioTrack),
+            }
+            : null,
+        actualMatroskaTimestamps: rememberActualMatroskaTimestamps(isMatroska),
+        isMatroska,
+    };
+};
+export const getFramesSinceKeyframe = async ({ packetSink, videoSampleSink, startPacket, }) => {
+    const nextKeyPacket = await packetSink.getNextKeyPacket(startPacket, {
+        verifyKeyPackets: false,
+    });
+    const sampleIterator = videoSampleSink.samples(startPacket.timestamp, nextKeyPacket ? nextKeyPacket.timestamp : Infinity);
+    const keyframeBank = makeKeyframeBank({
+        startTimestampInSeconds: startPacket.timestamp,
+        endTimestampInSeconds: nextKeyPacket ? nextKeyPacket.timestamp : Infinity,
+        sampleIterator,
+    });
+    return keyframeBank;
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { Audio as experimental_Audio } from './audio/audio';
+export { AudioProps } from './audio/props';
+export { VideoProps } from './video/props';
+export { Video as experimental_Video } from './video/video';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { Audio as experimental_Audio } from './audio/audio';
+export { Video as experimental_Video } from './video/video';

package/dist/keyframe-bank.d.ts

@@ -0,0 +1,25 @@
+import type { VideoSample } from 'mediabunny';
+import type { LogLevel } from './log';
+export type KeyframeBank = {
+    startTimestampInSeconds: number;
+    endTimestampInSeconds: number;
+    getFrameFromTimestamp: (timestamp: number) => Promise<VideoSample | null>;
+    prepareForDeletion: () => Promise<void>;
+    deleteFramesBeforeTimestamp: ({ logLevel, src, timestampInSeconds, }: {
+        timestampInSeconds: number;
+        logLevel: LogLevel;
+        src: string;
+    }) => void;
+    hasTimestampInSecond: (timestamp: number) => Promise<boolean>;
+    addFrame: (frame: VideoSample) => void;
+    getOpenFrameCount: () => {
+        size: number;
+        timestamps: number[];
+    };
+    getLastUsed: () => number;
+};
+export declare const makeKeyframeBank: ({ startTimestampInSeconds, endTimestampInSeconds, sampleIterator, }: {
+    startTimestampInSeconds: number;
+    endTimestampInSeconds: number;
+    sampleIterator: AsyncGenerator<VideoSample, void, unknown>;
+}) => KeyframeBank;

package/dist/keyframe-bank.js

@@ -0,0 +1,120 @@
+import { Log } from './log';
+// Round to only 4 digits, because WebM has a timescale of 1_000, e.g. framer.webm
+const roundTo4Digits = (timestamp) => {
+    return Math.round(timestamp * 1000) / 1000;
+};
+export const makeKeyframeBank = ({ startTimestampInSeconds, endTimestampInSeconds, sampleIterator, }) => {
+    const frames = {};
+    const frameTimestamps = [];
+    let lastUsed = Date.now();
+    let alloctionSize = 0;
+    const hasDecodedEnoughForTimestamp = (timestamp) => {
+        const lastFrameTimestamp = frameTimestamps[frameTimestamps.length - 1];
+        if (!lastFrameTimestamp) {
+            return false;
+        }
+        const lastFrame = frames[lastFrameTimestamp];
+        // Don't decode more, will probably have to re-decode everything
+        if (!lastFrame) {
+            return true;
+        }
+        return (roundTo4Digits(lastFrame.timestamp + lastFrame.duration) >
+            roundTo4Digits(timestamp));
+    };
+    const addFrame = (frame) => {
+        frames[frame.timestamp] = frame;
+        frameTimestamps.push(frame.timestamp);
+        alloctionSize += frame.allocationSize();
+        lastUsed = Date.now();
+    };
+    const ensureEnoughFramesForTimestamp = async (timestamp) => {
+        while (!hasDecodedEnoughForTimestamp(timestamp)) {
+            const sample = await sampleIterator.next();
+            if (sample.value) {
+                addFrame(sample.value);
+            }
+            if (sample.done) {
+                break;
+            }
+        }
+        lastUsed = Date.now();
+    };
+    const getFrameFromTimestamp = async (timestampInSeconds) => {
+        lastUsed = Date.now();
+        if (timestampInSeconds < startTimestampInSeconds) {
+            return Promise.reject(new Error(`Timestamp is before start timestamp (requested: ${timestampInSeconds}sec, start: ${startTimestampInSeconds})`));
+        }
+        if (timestampInSeconds > endTimestampInSeconds) {
+            return Promise.reject(new Error(`Timestamp is after end timestamp (requested: ${timestampInSeconds}sec, end: ${endTimestampInSeconds})`));
+        }
+        await ensureEnoughFramesForTimestamp(timestampInSeconds);
+        for (let i = frameTimestamps.length - 1; i >= 0; i--) {
+            const sample = frames[frameTimestamps[i]];
+            if (!sample) {
+                return null;
+            }
+            if (roundTo4Digits(sample.timestamp) <= roundTo4Digits(timestampInSeconds)) {
+                return sample;
+            }
+        }
+        throw new Error('No frame found for timestamp ' + timestampInSeconds);
+    };
+    const hasTimestampInSecond = async (timestamp) => {
+        return (await getFrameFromTimestamp(timestamp)) !== null;
+    };
+    const prepareForDeletion = async () => {
+        // Cleanup frames that have been extracted that might not have been retrieved yet
+        const { value } = await sampleIterator.return();
+        if (value) {
+            value.close();
+        }
+        for (const frameTimestamp of frameTimestamps) {
+            if (!frames[frameTimestamp]) {
+                continue;
+            }
+            alloctionSize -= frames[frameTimestamp].allocationSize();
+            frames[frameTimestamp].close();
+            delete frames[frameTimestamp];
+        }
+        frameTimestamps.length = 0;
+    };
+    const deleteFramesBeforeTimestamp = ({ logLevel, src, timestampInSeconds, }) => {
+        for (const frameTimestamp of frameTimestamps) {
+            const isLast = frameTimestamp === frameTimestamps[frameTimestamps.length - 1];
+            // Don't delete the last frame, since it may be the last one in the video!
+            if (isLast) {
+                continue;
+            }
+            if (frameTimestamp < timestampInSeconds) {
+                if (!frames[frameTimestamp]) {
+                    continue;
+                }
+                alloctionSize -= frames[frameTimestamp].allocationSize();
+                frames[frameTimestamp].close();
+                delete frames[frameTimestamp];
+                Log.verbose(logLevel, `[Video] Deleted frame ${frameTimestamp} for src ${src}`);
+            }
+        }
+    };
+    const getOpenFrameCount = () => {
+        return {
+            size: alloctionSize,
+            timestamps: frameTimestamps,
+        };
+    };
+    const getLastUsed = () => {
+        return lastUsed;
+    };
+    const keyframeBank = {
+        startTimestampInSeconds,
+        endTimestampInSeconds,
+        getFrameFromTimestamp,
+        prepareForDeletion,
+        hasTimestampInSecond,
+        addFrame,
+        deleteFramesBeforeTimestamp,
+        getOpenFrameCount,
+        getLastUsed,
+    };
+    return keyframeBank;
+};

package/dist/keyframe-manager.d.ts

@@ -0,0 +1,23 @@
+import type { EncodedPacketSink, VideoSampleSink } from 'mediabunny';
+import { type KeyframeBank } from './keyframe-bank';
+import type { LogLevel } from './log';
+export declare const makeKeyframeManager: () => {
+    requestKeyframeBank: ({ packetSink, timestamp, videoSampleSink, src, logLevel, }: {
+        timestamp: number;
+        packetSink: EncodedPacketSink;
+        videoSampleSink: VideoSampleSink;
+        src: string;
+        logLevel: LogLevel;
+    }) => Promise<KeyframeBank>;
+    addKeyframeBank: ({ src, bank, startTimestampInSeconds, }: {
+        src: string;
+        bank: Promise<KeyframeBank>;
+        startTimestampInSeconds: number;
+    }) => void;
+    getCacheStats: () => Promise<{
+        count: number;
+        totalSize: number;
+    }>;
+    clearAll: () => Promise<void>;
+};
+export type KeyframeManager = Awaited<ReturnType<typeof makeKeyframeManager>>;