@remotion/timeline-utils 4.0.460

package/README.md

@@ -0,0 +1,7 @@
+# @remotion/timeline-utils
+
+Internal utilities for rendering Remotion timelines
+
+## Usage
+
+This is an internal package and has no documentation.

package/dist/esm/index.mjs

@@ -0,0 +1,389 @@
+// src/extract-frames.ts
+import {
+  ALL_FORMATS,
+  Input,
+  InputDisposedError,
+  UrlSource,
+  VideoSampleSink
+} from "mediabunny";
+
+// src/get-duration-or-compute.ts
+var getDurationOrCompute = async (input) => {
+  return await input.getDurationFromMetadata(undefined, {
+    skipLiveWait: true
+  }) ?? input.computeDuration(undefined, { skipLiveWait: true });
+};
+
+// src/extract-frames.ts
+async function extractFrames({
+  src,
+  timestampsInSeconds,
+  onVideoSample,
+  signal
+}) {
+  const input = new Input({
+    formats: ALL_FORMATS,
+    source: new UrlSource(src)
+  });
+  const dispose = () => {
+    input.dispose();
+  };
+  if (signal) {
+    signal.addEventListener("abort", dispose, { once: true });
+  }
+  try {
+    const [durationInSeconds, format, videoTrack] = await Promise.all([
+      getDurationOrCompute(input),
+      input.getFormat(),
+      input.getPrimaryVideoTrack()
+    ]);
+    if (!videoTrack) {
+      throw new Error("No video track found in the input");
+    }
+    if (await videoTrack.isLive()) {
+      throw new Error("Live streams are not currently supported by Remotion. Sorry! Source: " + src);
+    }
+    if (await videoTrack.isRelativeToUnixEpoch()) {
+      throw new Error("Streams with UNIX timestamps are not currently supported by Remotion. Sorry! Source: " + src);
+    }
+    const timestamps = typeof timestampsInSeconds === "function" ? await timestampsInSeconds({
+      track: {
+        width: await videoTrack.getDisplayWidth(),
+        height: await videoTrack.getDisplayHeight()
+      },
+      container: format.name,
+      durationInSeconds
+    }) : timestampsInSeconds;
+    if (timestamps.length === 0) {
+      return;
+    }
+    const sink = new VideoSampleSink(videoTrack);
+    const sampleIterator = sink.samplesAtTimestamps(timestamps);
+    try {
+      for await (const videoSample of sampleIterator) {
+        if (signal?.aborted) {
+          videoSample?.close();
+          break;
+        }
+        if (!videoSample) {
+          continue;
+        }
+        onVideoSample(videoSample);
+      }
+    } finally {
+      try {
+        await sampleIterator.return?.();
+      } catch {}
+    }
+  } catch (error) {
+    if (error instanceof InputDisposedError) {
+      return;
+    }
+    throw error;
+  } finally {
+    dispose();
+    if (signal) {
+      signal.removeEventListener("abort", dispose);
+    }
+  }
+}
+// src/frame-database.ts
+var KEY_SEPARATOR = "|";
+var makeFrameDatabaseKey = (src, timestamp) => `${src}${KEY_SEPARATOR}${timestamp}`;
+var getFrameDatabaseKeyPrefix = (src) => {
+  return `${src}${KEY_SEPARATOR}`;
+};
+var MAX_CACHE_SIZE_BYTES = 10 * 1024 * 1024;
+var totalCacheSize = 0;
+var frameDatabase = new Map;
+var aspectRatioCache = new Map;
+var getTimestampFromFrameDatabaseKey = (key) => {
+  const split = key.split(KEY_SEPARATOR);
+  return Number(split[split.length - 1]);
+};
+var getAspectRatioFromCache = (src) => {
+  const cached = aspectRatioCache.get(src);
+  if (cached) {
+    return cached;
+  }
+  return null;
+};
+var evictLRU = () => {
+  while (totalCacheSize > MAX_CACHE_SIZE_BYTES && frameDatabase.size > 0) {
+    let oldestKey;
+    let oldestTime = Infinity;
+    for (const [key, candidate] of frameDatabase) {
+      if (candidate.lastUsed < oldestTime) {
+        oldestTime = candidate.lastUsed;
+        oldestKey = key;
+      }
+    }
+    if (!oldestKey) {
+      break;
+    }
+    const entry = frameDatabase.get(oldestKey);
+    if (entry) {
+      totalCacheSize -= entry.size;
+      entry.frame.close();
+      frameDatabase.delete(oldestKey);
+    }
+  }
+};
+var addFrameToCache = (key, frame) => {
+  const existing = frameDatabase.get(key);
+  if (existing) {
+    totalCacheSize -= existing.size;
+    existing.frame.close();
+  }
+  const size = frame.allocationSize();
+  totalCacheSize += size;
+  frameDatabase.set(key, {
+    frame,
+    lastUsed: Date.now(),
+    size
+  });
+  evictLRU();
+};
+// src/loop-display.ts
+var shouldTileLoopDisplay = (loopDisplay) => {
+  return loopDisplay !== undefined && loopDisplay.numberOfTimes > 1;
+};
+var getLoopDisplayWidth = ({
+  visualizationWidth,
+  loopDisplay
+}) => {
+  if (!shouldTileLoopDisplay(loopDisplay)) {
+    return visualizationWidth;
+  }
+  return visualizationWidth / loopDisplay.numberOfTimes;
+};
+// src/render-frame-strip.ts
+var WEBCODECS_TIMESCALE = 1e6;
+var MAX_TIME_DEVIATION = WEBCODECS_TIMESCALE * 0.05;
+var getDurationOfOneFrame = ({
+  visualizationWidth,
+  aspectRatio,
+  segmentDuration,
+  frameHeight
+}) => {
+  const framesFitInWidthUnrounded = visualizationWidth / (frameHeight * aspectRatio);
+  return segmentDuration / framesFitInWidthUnrounded * WEBCODECS_TIMESCALE;
+};
+var fixRounding = (value) => {
+  if (value % 1 >= 0.49999999) {
+    return Math.ceil(value);
+  }
+  return Math.floor(value);
+};
+var calculateTimestampSlots = ({
+  visualizationWidth,
+  fromSeconds,
+  segmentDuration,
+  aspectRatio,
+  frameHeight
+}) => {
+  const framesFitInWidthUnrounded = visualizationWidth / (frameHeight * aspectRatio);
+  const framesFitInWidth = Math.ceil(framesFitInWidthUnrounded);
+  const durationOfOneFrame = getDurationOfOneFrame({
+    visualizationWidth,
+    aspectRatio,
+    segmentDuration,
+    frameHeight
+  });
+  const timestampTargets = [];
+  for (let i = 0;i < framesFitInWidth + 1; i++) {
+    const target = fromSeconds * WEBCODECS_TIMESCALE + durationOfOneFrame * (i + 0.5);
+    const snappedToDuration = (Math.round(fixRounding(target / durationOfOneFrame)) - 1) * durationOfOneFrame;
+    timestampTargets.push(snappedToDuration);
+  }
+  return timestampTargets;
+};
+var ensureSlots = ({
+  filledSlots,
+  naturalWidth,
+  fromSeconds,
+  toSeconds,
+  aspectRatio,
+  frameHeight
+}) => {
+  const segmentDuration = toSeconds - fromSeconds;
+  const timestampTargets = calculateTimestampSlots({
+    visualizationWidth: naturalWidth,
+    fromSeconds,
+    segmentDuration,
+    aspectRatio,
+    frameHeight
+  });
+  for (const timestamp of timestampTargets) {
+    if (!filledSlots.has(timestamp)) {
+      filledSlots.set(timestamp, undefined);
+    }
+  }
+};
+var drawSlot = ({
+  frame,
+  ctx,
+  filledSlots,
+  visualizationWidth,
+  timestamp,
+  segmentDuration,
+  fromSeconds,
+  devicePixelRatio,
+  frameHeight
+}) => {
+  const durationOfOneFrame = getDurationOfOneFrame({
+    visualizationWidth,
+    aspectRatio: frame.displayWidth / frame.displayHeight,
+    segmentDuration,
+    frameHeight
+  });
+  const relativeTimestamp = timestamp - fromSeconds * WEBCODECS_TIMESCALE;
+  const frameIndex = relativeTimestamp / durationOfOneFrame;
+  const thumbnailWidth = frame.displayWidth / devicePixelRatio;
+  const left = Math.floor(frameIndex * thumbnailWidth);
+  const right = Math.ceil((frameIndex + 1) * thumbnailWidth);
+  ctx.drawImage(frame, left, 0, right - left, frame.displayHeight / devicePixelRatio);
+  filledSlots.set(timestamp, frame.timestamp);
+};
+var fillWithCachedFrames = ({
+  ctx,
+  naturalWidth,
+  filledSlots,
+  src,
+  segmentDuration,
+  fromSeconds,
+  devicePixelRatio,
+  frameHeight
+}) => {
+  const prefix = getFrameDatabaseKeyPrefix(src);
+  const keys = Array.from(frameDatabase.keys()).filter((k) => k.startsWith(prefix));
+  const targets = Array.from(filledSlots.keys());
+  for (const timestamp of targets) {
+    let bestKey;
+    let bestDistance = Infinity;
+    for (const key of keys) {
+      const distance = Math.abs(getTimestampFromFrameDatabaseKey(key) - timestamp);
+      if (distance < bestDistance) {
+        bestDistance = distance;
+        bestKey = key;
+      }
+    }
+    if (!bestKey) {
+      continue;
+    }
+    const frame = frameDatabase.get(bestKey);
+    if (!frame) {
+      continue;
+    }
+    const alreadyFilled = filledSlots.get(timestamp);
+    if (alreadyFilled && Math.abs(alreadyFilled - timestamp) <= Math.abs(frame.frame.timestamp - timestamp)) {
+      continue;
+    }
+    frame.lastUsed = Date.now();
+    drawSlot({
+      ctx,
+      frame: frame.frame,
+      filledSlots,
+      visualizationWidth: naturalWidth,
+      timestamp,
+      segmentDuration,
+      fromSeconds,
+      devicePixelRatio,
+      frameHeight
+    });
+  }
+};
+var fillFrameWhereItFits = ({
+  frame,
+  filledSlots,
+  ctx,
+  visualizationWidth,
+  segmentDuration,
+  fromSeconds,
+  devicePixelRatio,
+  frameHeight
+}) => {
+  const slots = Array.from(filledSlots.keys());
+  for (let i = 0;i < slots.length; i++) {
+    const slot = slots[i];
+    if (Math.abs(slot - frame.timestamp) > MAX_TIME_DEVIATION) {
+      continue;
+    }
+    const filled = filledSlots.get(slot);
+    if (filled && Math.abs(filled - slot) <= Math.abs(filled - frame.timestamp)) {
+      continue;
+    }
+    drawSlot({
+      ctx,
+      frame,
+      filledSlots,
+      visualizationWidth,
+      timestamp: slot,
+      segmentDuration,
+      fromSeconds,
+      devicePixelRatio,
+      frameHeight
+    });
+  }
+};
+// src/resize-video-frame.ts
+var calculateNewDimensionsFromScale = ({
+  width,
+  height,
+  scale
+}) => {
+  const scaledWidth = Math.round(width * scale);
+  const scaledHeight = Math.round(height * scale);
+  return {
+    width: scaledWidth,
+    height: scaledHeight
+  };
+};
+var resizeVideoFrame = ({
+  frame,
+  scale
+}) => {
+  if (scale === 1) {
+    return frame;
+  }
+  const { width, height } = calculateNewDimensionsFromScale({
+    height: frame.displayHeight,
+    width: frame.displayWidth,
+    scale
+  });
+  const canvas = new OffscreenCanvas(width, height);
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    throw new Error("Could not get 2d context");
+  }
+  canvas.width = width;
+  canvas.height = height;
+  ctx.scale(scale, scale);
+  ctx.drawImage(frame, 0, 0);
+  return new VideoFrame(canvas, {
+    displayHeight: height,
+    displayWidth: width,
+    duration: frame.duration ?? undefined,
+    timestamp: frame.timestamp
+  });
+};
+export {
+  shouldTileLoopDisplay,
+  resizeVideoFrame,
+  makeFrameDatabaseKey,
+  getTimestampFromFrameDatabaseKey,
+  getLoopDisplayWidth,
+  getFrameDatabaseKeyPrefix,
+  getDurationOfOneFrame,
+  getAspectRatioFromCache,
+  frameDatabase,
+  fillWithCachedFrames,
+  fillFrameWhereItFits,
+  extractFrames,
+  ensureSlots,
+  drawSlot,
+  calculateTimestampSlots,
+  aspectRatioCache,
+  addFrameToCache,
+  WEBCODECS_TIMESCALE
+};

package/dist/extract-frames.d.ts

@@ -0,0 +1,18 @@
+import type { VideoSample } from 'mediabunny';
+type Options = {
+    track: {
+        width: number;
+        height: number;
+    };
+    container: string;
+    durationInSeconds: number | null;
+};
+export type ExtractFramesTimestampsInSecondsFn = (options: Options) => Promise<number[]> | number[];
+export type ExtractFramesProps = {
+    src: string;
+    timestampsInSeconds: number[] | ExtractFramesTimestampsInSecondsFn;
+    onVideoSample: (sample: VideoSample) => void;
+    signal?: AbortSignal;
+};
+export declare function extractFrames({ src, timestampsInSeconds, onVideoSample, signal }: ExtractFramesProps): Promise<void>;
+export {};

package/dist/extract-frames.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFrames = extractFrames;
+const mediabunny_1 = require("mediabunny");
+const get_duration_or_compute_1 = require("./get-duration-or-compute");
+async function extractFrames({ src, timestampsInSeconds, onVideoSample, signal, }) {
+    var _a;
+    const input = new mediabunny_1.Input({
+        formats: mediabunny_1.ALL_FORMATS,
+        source: new mediabunny_1.UrlSource(src),
+    });
+    const dispose = () => {
+        input.dispose();
+    };
+    if (signal) {
+        signal.addEventListener('abort', dispose, { once: true });
+    }
+    try {
+        const [durationInSeconds, format, videoTrack] = await Promise.all([
+            (0, get_duration_or_compute_1.getDurationOrCompute)(input),
+            input.getFormat(),
+            input.getPrimaryVideoTrack(),
+        ]);
+        if (!videoTrack) {
+            throw new Error('No video track found in the input');
+        }
+        if (await videoTrack.isLive()) {
+            throw new Error('Live streams are not currently supported by Remotion. Sorry! Source: ' +
+                src);
+        }
+        if (await videoTrack.isRelativeToUnixEpoch()) {
+            throw new Error('Streams with UNIX timestamps are not currently supported by Remotion. Sorry! Source: ' +
+                src);
+        }
+        const timestamps = typeof timestampsInSeconds === 'function'
+            ? await timestampsInSeconds({
+                track: {
+                    width: await videoTrack.getDisplayWidth(),
+                    height: await videoTrack.getDisplayHeight(),
+                },
+                container: format.name,
+                durationInSeconds,
+            })
+            : timestampsInSeconds;
+        if (timestamps.length === 0) {
+            return;
+        }
+        const sink = new mediabunny_1.VideoSampleSink(videoTrack);
+        const sampleIterator = sink.samplesAtTimestamps(timestamps);
+        try {
+            for await (const videoSample of sampleIterator) {
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                    videoSample === null || videoSample === void 0 ? void 0 : videoSample.close();
+                    break;
+                }
+                if (!videoSample) {
+                    continue;
+                }
+                onVideoSample(videoSample);
+            }
+        }
+        finally {
+            // When input.dispose() causes the iterator to throw InputDisposedError,
+            // for-await does not call .return() on the iterator.
+            try {
+                await ((_a = sampleIterator.return) === null || _a === void 0 ? void 0 : _a.call(sampleIterator));
+            }
+            catch (_b) {
+                // Iterator already done or input disposed
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof mediabunny_1.InputDisposedError) {
+            return;
+        }
+        throw error;
+    }
+    finally {
+        dispose();
+        if (signal) {
+            signal.removeEventListener('abort', dispose);
+        }
+    }
+}

package/dist/frame-database.d.ts

@@ -0,0 +1,16 @@
+export type FrameDatabaseKey = string & {
+    __brand: 'FrameDatabaseKey';
+};
+export declare const makeFrameDatabaseKey: (src: string, timestamp: number) => FrameDatabaseKey;
+export declare const getFrameDatabaseKeyPrefix: (src: string) => string;
+type VideoFrameAndLastUsed = {
+    frame: VideoFrame;
+    lastUsed: number;
+    size: number;
+};
+export declare const frameDatabase: Map<FrameDatabaseKey, VideoFrameAndLastUsed>;
+export declare const aspectRatioCache: Map<string, number>;
+export declare const getTimestampFromFrameDatabaseKey: (key: FrameDatabaseKey) => number;
+export declare const getAspectRatioFromCache: (src: string) => number | null;
+export declare const addFrameToCache: (key: FrameDatabaseKey, frame: VideoFrame) => void;
+export {};

package/dist/frame-database.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addFrameToCache = exports.getAspectRatioFromCache = exports.getTimestampFromFrameDatabaseKey = exports.aspectRatioCache = exports.frameDatabase = exports.getFrameDatabaseKeyPrefix = exports.makeFrameDatabaseKey = void 0;
+const KEY_SEPARATOR = '|';
+const makeFrameDatabaseKey = (src, timestamp) => `${src}${KEY_SEPARATOR}${timestamp}`;
+exports.makeFrameDatabaseKey = makeFrameDatabaseKey;
+const getFrameDatabaseKeyPrefix = (src) => {
+    return `${src}${KEY_SEPARATOR}`;
+};
+exports.getFrameDatabaseKeyPrefix = getFrameDatabaseKeyPrefix;
+const MAX_CACHE_SIZE_BYTES = 10 * 1024 * 1024;
+let totalCacheSize = 0;
+exports.frameDatabase = new Map();
+exports.aspectRatioCache = new Map();
+const getTimestampFromFrameDatabaseKey = (key) => {
+    const split = key.split(KEY_SEPARATOR);
+    return Number(split[split.length - 1]);
+};
+exports.getTimestampFromFrameDatabaseKey = getTimestampFromFrameDatabaseKey;
+const getAspectRatioFromCache = (src) => {
+    const cached = exports.aspectRatioCache.get(src);
+    if (cached) {
+        return cached;
+    }
+    return null;
+};
+exports.getAspectRatioFromCache = getAspectRatioFromCache;
+const evictLRU = () => {
+    while (totalCacheSize > MAX_CACHE_SIZE_BYTES && exports.frameDatabase.size > 0) {
+        let oldestKey;
+        let oldestTime = Infinity;
+        for (const [key, candidate] of exports.frameDatabase) {
+            if (candidate.lastUsed < oldestTime) {
+                oldestTime = candidate.lastUsed;
+                oldestKey = key;
+            }
+        }
+        if (!oldestKey) {
+            break;
+        }
+        const entry = exports.frameDatabase.get(oldestKey);
+        if (entry) {
+            totalCacheSize -= entry.size;
+            entry.frame.close();
+            exports.frameDatabase.delete(oldestKey);
+        }
+    }
+};
+const addFrameToCache = (key, frame) => {
+    const existing = exports.frameDatabase.get(key);
+    if (existing) {
+        totalCacheSize -= existing.size;
+        existing.frame.close();
+    }
+    const size = frame.allocationSize();
+    totalCacheSize += size;
+    exports.frameDatabase.set(key, {
+        frame,
+        lastUsed: Date.now(),
+        size,
+    });
+    evictLRU();
+};
+exports.addFrameToCache = addFrameToCache;

package/dist/get-duration-or-compute.d.ts

@@ -0,0 +1,2 @@
+import type { Input } from 'mediabunny';
+export declare const getDurationOrCompute: (input: Input<import("mediabunny").Source>) => Promise<number>;

package/dist/get-duration-or-compute.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDurationOrCompute = void 0;
+const getDurationOrCompute = async (input) => {
+    var _a;
+    return ((_a = (await input.getDurationFromMetadata(undefined, {
+        skipLiveWait: true,
+    }))) !== null && _a !== void 0 ? _a : input.computeDuration(undefined, { skipLiveWait: true }));
+};
+exports.getDurationOrCompute = getDurationOrCompute;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { extractFrames } from './extract-frames';
+export type { ExtractFramesProps, ExtractFramesTimestampsInSecondsFn, } from './extract-frames';
+export { addFrameToCache, aspectRatioCache, frameDatabase, getAspectRatioFromCache, getFrameDatabaseKeyPrefix, getTimestampFromFrameDatabaseKey, makeFrameDatabaseKey, } from './frame-database';
+export type { FrameDatabaseKey } from './frame-database';
+export { getLoopDisplayWidth, shouldTileLoopDisplay } from './loop-display';
+export type { TimelineLoopDisplay } from './loop-display';
+export { calculateTimestampSlots, drawSlot, ensureSlots, fillFrameWhereItFits, fillWithCachedFrames, getDurationOfOneFrame, WEBCODECS_TIMESCALE, } from './render-frame-strip';
+export { resizeVideoFrame } from './resize-video-frame';

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resizeVideoFrame = exports.WEBCODECS_TIMESCALE = exports.getDurationOfOneFrame = exports.fillWithCachedFrames = exports.fillFrameWhereItFits = exports.ensureSlots = exports.drawSlot = exports.calculateTimestampSlots = exports.shouldTileLoopDisplay = exports.getLoopDisplayWidth = exports.makeFrameDatabaseKey = exports.getTimestampFromFrameDatabaseKey = exports.getFrameDatabaseKeyPrefix = exports.getAspectRatioFromCache = exports.frameDatabase = exports.aspectRatioCache = exports.addFrameToCache = exports.extractFrames = void 0;
+const extract_frames_1 = require("./extract-frames");
+Object.defineProperty(exports, "extractFrames", { enumerable: true, get: function () { return extract_frames_1.extractFrames; } });
+const frame_database_1 = require("./frame-database");
+Object.defineProperty(exports, "addFrameToCache", { enumerable: true, get: function () { return frame_database_1.addFrameToCache; } });
+Object.defineProperty(exports, "aspectRatioCache", { enumerable: true, get: function () { return frame_database_1.aspectRatioCache; } });
+Object.defineProperty(exports, "frameDatabase", { enumerable: true, get: function () { return frame_database_1.frameDatabase; } });
+Object.defineProperty(exports, "getAspectRatioFromCache", { enumerable: true, get: function () { return frame_database_1.getAspectRatioFromCache; } });
+Object.defineProperty(exports, "getFrameDatabaseKeyPrefix", { enumerable: true, get: function () { return frame_database_1.getFrameDatabaseKeyPrefix; } });
+Object.defineProperty(exports, "getTimestampFromFrameDatabaseKey", { enumerable: true, get: function () { return frame_database_1.getTimestampFromFrameDatabaseKey; } });
+Object.defineProperty(exports, "makeFrameDatabaseKey", { enumerable: true, get: function () { return frame_database_1.makeFrameDatabaseKey; } });
+const loop_display_1 = require("./loop-display");
+Object.defineProperty(exports, "getLoopDisplayWidth", { enumerable: true, get: function () { return loop_display_1.getLoopDisplayWidth; } });
+Object.defineProperty(exports, "shouldTileLoopDisplay", { enumerable: true, get: function () { return loop_display_1.shouldTileLoopDisplay; } });
+const render_frame_strip_1 = require("./render-frame-strip");
+Object.defineProperty(exports, "calculateTimestampSlots", { enumerable: true, get: function () { return render_frame_strip_1.calculateTimestampSlots; } });
+Object.defineProperty(exports, "drawSlot", { enumerable: true, get: function () { return render_frame_strip_1.drawSlot; } });
+Object.defineProperty(exports, "ensureSlots", { enumerable: true, get: function () { return render_frame_strip_1.ensureSlots; } });
+Object.defineProperty(exports, "fillFrameWhereItFits", { enumerable: true, get: function () { return render_frame_strip_1.fillFrameWhereItFits; } });
+Object.defineProperty(exports, "fillWithCachedFrames", { enumerable: true, get: function () { return render_frame_strip_1.fillWithCachedFrames; } });
+Object.defineProperty(exports, "getDurationOfOneFrame", { enumerable: true, get: function () { return render_frame_strip_1.getDurationOfOneFrame; } });
+Object.defineProperty(exports, "WEBCODECS_TIMESCALE", { enumerable: true, get: function () { return render_frame_strip_1.WEBCODECS_TIMESCALE; } });
+const resize_video_frame_1 = require("./resize-video-frame");
+Object.defineProperty(exports, "resizeVideoFrame", { enumerable: true, get: function () { return resize_video_frame_1.resizeVideoFrame; } });

package/dist/loop-display.d.ts

@@ -0,0 +1,10 @@
+export type TimelineLoopDisplay = {
+    durationInFrames: number;
+    numberOfTimes: number;
+    startOffset: number;
+};
+export declare const shouldTileLoopDisplay: (loopDisplay: TimelineLoopDisplay | undefined) => loopDisplay is TimelineLoopDisplay;
+export declare const getLoopDisplayWidth: ({ visualizationWidth, loopDisplay, }: {
+    visualizationWidth: number;
+    loopDisplay: TimelineLoopDisplay | undefined;
+}) => number;

package/dist/loop-display.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLoopDisplayWidth = exports.shouldTileLoopDisplay = void 0;
+const shouldTileLoopDisplay = (loopDisplay) => {
+    return loopDisplay !== undefined && loopDisplay.numberOfTimes > 1;
+};
+exports.shouldTileLoopDisplay = shouldTileLoopDisplay;
+const getLoopDisplayWidth = ({ visualizationWidth, loopDisplay, }) => {
+    if (!(0, exports.shouldTileLoopDisplay)(loopDisplay)) {
+        return visualizationWidth;
+    }
+    return visualizationWidth / loopDisplay.numberOfTimes;
+};
+exports.getLoopDisplayWidth = getLoopDisplayWidth;

package/dist/render-frame-strip.d.ts

@@ -0,0 +1,53 @@
+export declare const WEBCODECS_TIMESCALE = 1000000;
+export declare const getDurationOfOneFrame: ({ visualizationWidth, aspectRatio, segmentDuration, frameHeight, }: {
+    visualizationWidth: number;
+    aspectRatio: number;
+    segmentDuration: number;
+    frameHeight: number;
+}) => number;
+export declare const calculateTimestampSlots: ({ visualizationWidth, fromSeconds, segmentDuration, aspectRatio, frameHeight, }: {
+    visualizationWidth: number;
+    fromSeconds: number;
+    segmentDuration: number;
+    aspectRatio: number;
+    frameHeight: number;
+}) => number[];
+export declare const ensureSlots: ({ filledSlots, naturalWidth, fromSeconds, toSeconds, aspectRatio, frameHeight, }: {
+    filledSlots: Map<number, number | undefined>;
+    naturalWidth: number;
+    fromSeconds: number;
+    toSeconds: number;
+    aspectRatio: number;
+    frameHeight: number;
+}) => void;
+export declare const drawSlot: ({ frame, ctx, filledSlots, visualizationWidth, timestamp, segmentDuration, fromSeconds, devicePixelRatio, frameHeight, }: {
+    frame: VideoFrame;
+    ctx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D;
+    filledSlots: Map<number, number | undefined>;
+    visualizationWidth: number;
+    timestamp: number;
+    segmentDuration: number;
+    fromSeconds: number;
+    devicePixelRatio: number;
+    frameHeight: number;
+}) => void;
+export declare const fillWithCachedFrames: ({ ctx, naturalWidth, filledSlots, src, segmentDuration, fromSeconds, devicePixelRatio, frameHeight, }: {
+    ctx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D;
+    naturalWidth: number;
+    filledSlots: Map<number, number | undefined>;
+    src: string;
+    segmentDuration: number;
+    fromSeconds: number;
+    devicePixelRatio: number;
+    frameHeight: number;
+}) => void;
+export declare const fillFrameWhereItFits: ({ frame, filledSlots, ctx, visualizationWidth, segmentDuration, fromSeconds, devicePixelRatio, frameHeight, }: {
+    frame: VideoFrame;
+    filledSlots: Map<number, number | undefined>;
+    ctx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D;
+    visualizationWidth: number;
+    segmentDuration: number;
+    fromSeconds: number;
+    devicePixelRatio: number;
+    frameHeight: number;
+}) => void;

package/dist/render-frame-strip.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fillFrameWhereItFits = exports.fillWithCachedFrames = exports.drawSlot = exports.ensureSlots = exports.calculateTimestampSlots = exports.getDurationOfOneFrame = exports.WEBCODECS_TIMESCALE = void 0;
+const frame_database_1 = require("./frame-database");
+exports.WEBCODECS_TIMESCALE = 1000000;
+const MAX_TIME_DEVIATION = exports.WEBCODECS_TIMESCALE * 0.05;
+const getDurationOfOneFrame = ({ visualizationWidth, aspectRatio, segmentDuration, frameHeight, }) => {
+    const framesFitInWidthUnrounded = visualizationWidth / (frameHeight * aspectRatio);
+    return (segmentDuration / framesFitInWidthUnrounded) * exports.WEBCODECS_TIMESCALE;
+};
+exports.getDurationOfOneFrame = getDurationOfOneFrame;
+const fixRounding = (value) => {
+    if (value % 1 >= 0.49999999) {
+        return Math.ceil(value);
+    }
+    return Math.floor(value);
+};
+const calculateTimestampSlots = ({ visualizationWidth, fromSeconds, segmentDuration, aspectRatio, frameHeight, }) => {
+    const framesFitInWidthUnrounded = visualizationWidth / (frameHeight * aspectRatio);
+    const framesFitInWidth = Math.ceil(framesFitInWidthUnrounded);
+    const durationOfOneFrame = (0, exports.getDurationOfOneFrame)({
+        visualizationWidth,
+        aspectRatio,
+        segmentDuration,
+        frameHeight,
+    });
+    const timestampTargets = [];
+    for (let i = 0; i < framesFitInWidth + 1; i++) {
+        const target = fromSeconds * exports.WEBCODECS_TIMESCALE + durationOfOneFrame * (i + 0.5);
+        const snappedToDuration = (Math.round(fixRounding(target / durationOfOneFrame)) - 1) *
+            durationOfOneFrame;
+        timestampTargets.push(snappedToDuration);
+    }
+    return timestampTargets;
+};
+exports.calculateTimestampSlots = calculateTimestampSlots;
+const ensureSlots = ({ filledSlots, naturalWidth, fromSeconds, toSeconds, aspectRatio, frameHeight, }) => {
+    const segmentDuration = toSeconds - fromSeconds;
+    const timestampTargets = (0, exports.calculateTimestampSlots)({
+        visualizationWidth: naturalWidth,
+        fromSeconds,
+        segmentDuration,
+        aspectRatio,
+        frameHeight,
+    });
+    for (const timestamp of timestampTargets) {
+        if (!filledSlots.has(timestamp)) {
+            filledSlots.set(timestamp, undefined);
+        }
+    }
+};
+exports.ensureSlots = ensureSlots;
+const drawSlot = ({ frame, ctx, filledSlots, visualizationWidth, timestamp, segmentDuration, fromSeconds, devicePixelRatio, frameHeight, }) => {
+    const durationOfOneFrame = (0, exports.getDurationOfOneFrame)({
+        visualizationWidth,
+        aspectRatio: frame.displayWidth / frame.displayHeight,
+        segmentDuration,
+        frameHeight,
+    });
+    const relativeTimestamp = timestamp - fromSeconds * exports.WEBCODECS_TIMESCALE;
+    const frameIndex = relativeTimestamp / durationOfOneFrame;
+    const thumbnailWidth = frame.displayWidth / devicePixelRatio;
+    const left = Math.floor(frameIndex * thumbnailWidth);
+    const right = Math.ceil((frameIndex + 1) * thumbnailWidth);
+    ctx.drawImage(frame, left, 0, right - left, frame.displayHeight / devicePixelRatio);
+    filledSlots.set(timestamp, frame.timestamp);
+};
+exports.drawSlot = drawSlot;
+const fillWithCachedFrames = ({ ctx, naturalWidth, filledSlots, src, segmentDuration, fromSeconds, devicePixelRatio, frameHeight, }) => {
+    const prefix = (0, frame_database_1.getFrameDatabaseKeyPrefix)(src);
+    const keys = Array.from(frame_database_1.frameDatabase.keys()).filter((k) => k.startsWith(prefix));
+    const targets = Array.from(filledSlots.keys());
+    for (const timestamp of targets) {
+        let bestKey;
+        let bestDistance = Infinity;
+        for (const key of keys) {
+            const distance = Math.abs((0, frame_database_1.getTimestampFromFrameDatabaseKey)(key) - timestamp);
+            if (distance < bestDistance) {
+                bestDistance = distance;
+                bestKey = key;
+            }
+        }
+        if (!bestKey) {
+            continue;
+        }
+        const frame = frame_database_1.frameDatabase.get(bestKey);
+        if (!frame) {
+            continue;
+        }
+        const alreadyFilled = filledSlots.get(timestamp);
+        if (alreadyFilled &&
+            Math.abs(alreadyFilled - timestamp) <=
+                Math.abs(frame.frame.timestamp - timestamp)) {
+            continue;
+        }
+        frame.lastUsed = Date.now();
+        (0, exports.drawSlot)({
+            ctx,
+            frame: frame.frame,
+            filledSlots,
+            visualizationWidth: naturalWidth,
+            timestamp,
+            segmentDuration,
+            fromSeconds,
+            devicePixelRatio,
+            frameHeight,
+        });
+    }
+};
+exports.fillWithCachedFrames = fillWithCachedFrames;
+const fillFrameWhereItFits = ({ frame, filledSlots, ctx, visualizationWidth, segmentDuration, fromSeconds, devicePixelRatio, frameHeight, }) => {
+    const slots = Array.from(filledSlots.keys());
+    for (let i = 0; i < slots.length; i++) {
+        const slot = slots[i];
+        if (Math.abs(slot - frame.timestamp) > MAX_TIME_DEVIATION) {
+            continue;
+        }
+        const filled = filledSlots.get(slot);
+        if (filled &&
+            Math.abs(filled - slot) <= Math.abs(filled - frame.timestamp)) {
+            continue;
+        }
+        (0, exports.drawSlot)({
+            ctx,
+            frame,
+            filledSlots,
+            visualizationWidth,
+            timestamp: slot,
+            segmentDuration,
+            fromSeconds,
+            devicePixelRatio,
+            frameHeight,
+        });
+    }
+};
+exports.fillFrameWhereItFits = fillFrameWhereItFits;

package/dist/resize-video-frame.d.ts

@@ -0,0 +1,4 @@
+export declare const resizeVideoFrame: ({ frame, scale, }: {
+    frame: VideoFrame;
+    scale: number;
+}) => VideoFrame;

package/dist/resize-video-frame.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resizeVideoFrame = void 0;
+const calculateNewDimensionsFromScale = ({ width, height, scale, }) => {
+    const scaledWidth = Math.round(width * scale);
+    const scaledHeight = Math.round(height * scale);
+    return {
+        width: scaledWidth,
+        height: scaledHeight,
+    };
+};
+const resizeVideoFrame = ({ frame, scale, }) => {
+    var _a;
+    if (scale === 1) {
+        return frame;
+    }
+    const { width, height } = calculateNewDimensionsFromScale({
+        height: frame.displayHeight,
+        width: frame.displayWidth,
+        scale,
+    });
+    const canvas = new OffscreenCanvas(width, height);
+    const ctx = canvas.getContext('2d');
+    if (!ctx) {
+        throw new Error('Could not get 2d context');
+    }
+    canvas.width = width;
+    canvas.height = height;
+    ctx.scale(scale, scale);
+    ctx.drawImage(frame, 0, 0);
+    return new VideoFrame(canvas, {
+        displayHeight: height,
+        displayWidth: width,
+        duration: (_a = frame.duration) !== null && _a !== void 0 ? _a : undefined,
+        timestamp: frame.timestamp,
+    });
+};
+exports.resizeVideoFrame = resizeVideoFrame;

package/package.json

@@ -0,0 +1,43 @@
+{
+	"repository": {
+		"url": "https://github.com/remotion-dev/remotion/tree/main/packages/timeline-utils"
+	},
+	"name": "@remotion/timeline-utils",
+	"version": "4.0.460",
+	"description": "Internal utilities for rendering Remotion timelines",
+	"main": "dist/index.js",
+	"sideEffects": false,
+	"scripts": {
+		"formatting": "oxfmt src --check",
+		"format": "oxfmt src",
+		"lint": "eslint src",
+		"make": "tsgo -d && bun --env-file=../.env.bundle bundle.ts"
+	},
+	"types": "dist/index.d.ts",
+	"module": "dist/esm/index.mjs",
+	"author": "Jonny Burger <jonny@remotion.dev>",
+	"license": "MIT",
+	"bugs": {
+		"url": "https://github.com/remotion-dev/remotion/issues"
+	},
+	"dependencies": {
+		"mediabunny": "1.42.0"
+	},
+	"devDependencies": {
+		"@remotion/eslint-config-internal": "4.0.460",
+		"eslint": "9.19.0",
+		"@typescript/native-preview": "7.0.0-dev.20260217.1"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"exports": {
+		"./package.json": "./package.json",
+		".": {
+			"types": "./dist/index.d.ts",
+			"module": "./dist/esm/index.mjs",
+			"import": "./dist/esm/index.mjs",
+			"require": "./dist/index.js"
+		}
+	}
+}