@editframe/elements 0.26.3-beta.0 → 0.26.4-beta.0

package/src/elements/EFMedia/shared/AudioSpanUtils.ts

@@ -1,129 +0,0 @@
-import type {
-  AudioSpan,
-  MediaEngine,
-  SegmentTimeRange,
-} from "../../../transcoding/types";
-import type { EFMedia } from "../../EFMedia";
-
-/**
- * Fetch audio segment data using MediaEngine
- * Pure function with explicit dependencies
- */
-const fetchAudioSegmentData = async (
-  segmentIds: number[],
-  mediaEngine: MediaEngine,
-  signal: AbortSignal,
-): Promise<Map<number, ArrayBuffer>> => {
-  const audioRendition = mediaEngine.audioRendition;
-  if (!audioRendition) {
-    throw new Error("Audio rendition not available");
-  }
-
-  const segmentData = new Map<number, ArrayBuffer>();
-
-  // Fetch all segments - MediaEngine handles deduplication internally
-  const fetchPromises = segmentIds.map(async (segmentId) => {
-    const arrayBuffer = await mediaEngine.fetchMediaSegment(
-      segmentId,
-      audioRendition,
-      signal,
-    );
-    return [segmentId, arrayBuffer] as [number, ArrayBuffer];
-  });
-
-  const fetchedSegments = await Promise.all(fetchPromises);
-  signal.throwIfAborted();
-
-  for (const [segmentId, arrayBuffer] of fetchedSegments) {
-    segmentData.set(segmentId, arrayBuffer);
-  }
-
-  return segmentData;
-};
-
-/**
- * Create audio span blob from init segment and media segments
- * Pure function for blob creation
- */
-const createAudioSpanBlob = (
-  initSegment: ArrayBuffer,
-  mediaSegments: ArrayBuffer[],
-): Blob => {
-  const chunks = [initSegment, ...mediaSegments];
-  return new Blob(chunks, { type: "audio/mp4" });
-};
-
-/**
- * Fetch audio spanning a time range
- * Main function that orchestrates segment calculation, fetching, and blob creation
- */
-export const fetchAudioSpanningTime = async (
-  host: EFMedia,
-  fromMs: number,
-  toMs: number,
-  signal: AbortSignal,
-): Promise<AudioSpan | undefined> => {
-  // Validate inputs
-  if (fromMs >= toMs || fromMs < 0) {
-    throw new Error(`Invalid time range: fromMs=${fromMs}, toMs=${toMs}`);
-  }
-
-  // Get dependencies from host
-  const mediaEngine = await host.mediaEngineTask.taskComplete;
-  const initSegment = await host.audioInitSegmentFetchTask.taskComplete;
-
-  // Return undefined if no audio rendition available
-  if (!mediaEngine?.audioRendition) {
-    return undefined;
-  }
-
-  if (!initSegment) {
-    return undefined;
-  }
-
-  // Calculate segments needed using the media engine's method
-  const segmentRanges = mediaEngine.calculateAudioSegmentRange(
-    fromMs,
-    toMs,
-    mediaEngine.audioRendition,
-    host.intrinsicDurationMs || 10000,
-  );
-
-  if (segmentRanges.length === 0) {
-    throw new Error(`No segments found for time range ${fromMs}-${toMs}ms`);
-  }
-
-  // Fetch segment data
-  const segmentIds = segmentRanges.map((r: SegmentTimeRange) => r.segmentId);
-  const segmentData = await fetchAudioSegmentData(
-    segmentIds,
-    mediaEngine,
-    signal,
-  );
-
-  // Create ordered array of segments
-  const orderedSegments = segmentIds.map((id: number) => {
-    const segment = segmentData.get(id);
-    if (!segment) {
-      throw new Error(`Missing segment data for segment ID ${id}`);
-    }
-    return segment;
-  });
-
-  // Create blob
-  const blob = createAudioSpanBlob(initSegment, orderedSegments);
-
-  // Calculate actual time boundaries
-  const actualStartMs = Math.min(
-    ...segmentRanges.map((r: SegmentTimeRange) => r.startMs),
-  );
-  const actualEndMs = Math.max(
-    ...segmentRanges.map((r: SegmentTimeRange) => r.endMs),
-  );
-
-  return {
-    startMs: actualStartMs,
-    endMs: actualEndMs,
-    blob,
-  };
-};

package/src/elements/EFMedia/shared/BufferUtils.ts

@@ -1,342 +0,0 @@
-import type {
-  AudioRendition,
-  VideoRendition,
-} from "../../../transcoding/types";
-
-/**
- * State interface for media buffering - orchestration only, no data storage
- */
-export interface MediaBufferState {
-  currentSeekTimeMs: number;
-  requestedSegments: Set<number>; // Segments we've requested for buffering
-  activeRequests: Set<number>; // Segments currently being fetched
-  requestQueue: number[]; // Segments queued to be requested
-}
-
-/**
- * Configuration interface for media buffering - generic for both audio and video
- */
-export interface MediaBufferConfig {
-  bufferDurationMs: number;
-  maxParallelFetches: number;
-  enableBuffering: boolean;
-  enableContinuousBuffering?: boolean;
-  bufferThresholdMs?: number; // Timeline-aware buffering threshold (default: 30000ms)
-}
-
-/**
- * Dependencies interface for media buffering - integrates with BaseMediaEngine
- */
-export interface MediaBufferDependencies<
-  T extends AudioRendition | VideoRendition,
-> {
-  computeSegmentId: (
-    timeMs: number,
-    rendition: T,
-  ) => Promise<number | undefined>;
-  prefetchSegment: (segmentId: number, rendition: T) => Promise<void>; // Just trigger prefetch, don't return data
-  isSegmentCached: (segmentId: number, rendition: T) => boolean; // Check BaseMediaEngine cache
-  getRendition: () => Promise<T | undefined>;
-  logError: (message: string, error: any) => void;
-}
-
-/**
- * Compute segment range for a time window
- * Pure function - determines which segments are needed for a time range
- */
-export const computeSegmentRange = <T extends AudioRendition | VideoRendition>(
-  startTimeMs: number,
-  endTimeMs: number,
-  rendition: T,
-  computeSegmentId: (timeMs: number, rendition: T) => number | undefined,
-): number[] => {
-  const segments: number[] = [];
-  const segmentDurationMs = (rendition as any).segmentDurationMs || 1000;
-
-  // Calculate segment indices that overlap with [startTimeMs, endTimeMs]
-  const startSegmentIndex = Math.floor(startTimeMs / segmentDurationMs);
-  const endSegmentIndex = Math.floor(endTimeMs / segmentDurationMs);
-
-  for (let i = startSegmentIndex; i <= endSegmentIndex; i++) {
-    const segmentId = computeSegmentId(i * segmentDurationMs, rendition);
-    if (segmentId !== undefined) {
-      segments.push(segmentId);
-    }
-  }
-
-  return segments.filter((id, index, arr) => arr.indexOf(id) === index); // Remove duplicates
-};
-
-/**
- * Async version of computeSegmentRange for when computeSegmentId is async
- */
-export const computeSegmentRangeAsync = async <
-  T extends AudioRendition | VideoRendition,
->(
-  startTimeMs: number,
-  endTimeMs: number,
-  durationMs: number,
-  rendition: T,
-  computeSegmentId: (
-    timeMs: number,
-    rendition: T,
-  ) => Promise<number | undefined>,
-): Promise<number[]> => {
-  const segments: number[] = [];
-  const segmentDurationMs = (rendition as any).segmentDurationMs || 1000;
-
-  // Calculate segment indices that overlap with [startTimeMs, endTimeMs]
-  const startSegmentIndex = Math.floor(startTimeMs / segmentDurationMs);
-  const endSegmentIndex = Math.floor(
-    Math.min(endTimeMs, durationMs) / segmentDurationMs,
-  );
-
-  for (let i = startSegmentIndex; i <= endSegmentIndex; i++) {
-    const timeMs = i * segmentDurationMs;
-    if (timeMs < durationMs) {
-      const segmentId = await computeSegmentId(timeMs, rendition);
-      if (segmentId !== undefined) {
-        segments.push(segmentId);
-      }
-    }
-  }
-
-  return segments.filter((id, index, arr) => arr.indexOf(id) === index); // Remove duplicates
-};
-
-/**
- * Compute buffer queue based on desired segments and what we've already requested
- * Pure function - determines what new segments should be prefetched
- */
-export const computeBufferQueue = (
-  desiredSegments: number[],
-  requestedSegments: Set<number>,
-): number[] => {
-  return desiredSegments.filter(
-    (segmentId) => !requestedSegments.has(segmentId),
-  );
-};
-
-/**
- * Handle seek time change and recompute buffer queue
- * Pure function - computes new queue when seek time changes
- */
-export const handleSeekTimeChange = <T extends AudioRendition | VideoRendition>(
-  newSeekTimeMs: number,
-  bufferDurationMs: number,
-  rendition: T,
-  currentState: MediaBufferState,
-  computeSegmentId: (timeMs: number, rendition: T) => number | undefined,
-): { newQueue: number[]; overlappingRequests: number[] } => {
-  const endTimeMs = newSeekTimeMs + bufferDurationMs;
-  const desiredSegments = computeSegmentRange(
-    newSeekTimeMs,
-    endTimeMs,
-    rendition,
-    computeSegmentId,
-  );
-
-  // Find segments that are already being requested
-  const overlappingRequests = desiredSegments.filter((segmentId) =>
-    currentState.requestedSegments.has(segmentId),
-  );
-
-  const newQueue = computeBufferQueue(
-    desiredSegments,
-    currentState.requestedSegments,
-  );
-
-  return { newQueue, overlappingRequests };
-};
-
-/**
- * Check if a segment has been requested for buffering
- * Pure function for checking buffer orchestration state
- */
-export const isSegmentRequested = (
-  segmentId: number,
-  bufferState: MediaBufferState | undefined,
-): boolean => {
-  return bufferState?.requestedSegments.has(segmentId) ?? false;
-};
-
-/**
- * Get requested segments from a list of segment IDs
- * Pure function that returns which segments have been requested for buffering
- */
-export const getRequestedSegments = (
-  segmentIds: number[],
-  bufferState: MediaBufferState | undefined,
-): Set<number> => {
-  if (!bufferState) {
-    return new Set();
-  }
-  return new Set(
-    segmentIds.filter((id) => bufferState.requestedSegments.has(id)),
-  );
-};
-
-/**
- * Get unrequested segments from a list of segment IDs
- * Pure function that returns which segments haven't been requested yet
- */
-export const getUnrequestedSegments = (
-  segmentIds: number[],
-  bufferState: MediaBufferState | undefined,
-): number[] => {
-  if (!bufferState) {
-    return segmentIds;
-  }
-  return segmentIds.filter((id) => !bufferState.requestedSegments.has(id));
-};
-
-/**
- * Calculate distance from element to playhead position
- * Returns 0 if element is currently active, otherwise returns distance in milliseconds
- */
-export const calculatePlayheadDistance = (
-  element: { startTimeMs: number; endTimeMs: number },
-  playheadMs: number,
-): number => {
-  // Element hasn't started yet
-  if (playheadMs < element.startTimeMs) {
-    return element.startTimeMs - playheadMs;
-  }
-  // Element already finished
-  if (playheadMs > element.endTimeMs) {
-    return playheadMs - element.endTimeMs;
-  }
-  // Element is currently active
-  return 0;
-};
-
-/**
- * Core media buffering orchestration logic - prefetch only, no data storage
- * Integrates with BaseMediaEngine's existing caching and request deduplication
- */
-export const manageMediaBuffer = async <
-  T extends AudioRendition | VideoRendition,
->(
-  seekTimeMs: number,
-  config: MediaBufferConfig,
-  currentState: MediaBufferState,
-  durationMs: number,
-  signal: AbortSignal,
-  deps: MediaBufferDependencies<T>,
-  timelineContext?: {
-    elementStartMs: number;
-    elementEndMs: number;
-    playheadMs: number;
-  },
-): Promise<MediaBufferState> => {
-  if (!config.enableBuffering) {
-    return currentState;
-  }
-
-  // Timeline-aware buffering: skip if element is too far from playhead
-  if (timelineContext && config.bufferThresholdMs !== undefined) {
-    const distance = calculatePlayheadDistance(
-      {
-        startTimeMs: timelineContext.elementStartMs,
-        endTimeMs: timelineContext.elementEndMs,
-      },
-      timelineContext.playheadMs,
-    );
-
-    if (distance > config.bufferThresholdMs) {
-      // Element is too far from playhead, skip buffering
-      return currentState;
-    }
-  }
-
-  const rendition = await deps.getRendition();
-  if (!rendition) {
-    // Cannot buffer without a rendition
-    return currentState;
-  }
-  const endTimeMs = seekTimeMs + config.bufferDurationMs;
-
-  const desiredSegments = await computeSegmentRangeAsync(
-    seekTimeMs,
-    endTimeMs,
-    durationMs,
-    rendition,
-    deps.computeSegmentId,
-  );
-  // Filter out segments already cached by BaseMediaEngine
-  const uncachedSegments = desiredSegments.filter(
-    (segmentId) => !deps.isSegmentCached(segmentId, rendition),
-  );
-
-  const newQueue = computeBufferQueue(
-    uncachedSegments,
-    currentState.requestedSegments,
-  );
-
-  // Shared state for concurrency control - prevents race conditions
-  const newRequestedSegments = new Set(currentState.requestedSegments);
-  const newActiveRequests = new Set(currentState.activeRequests);
-  const remainingQueue = [...newQueue];
-
-  // Thread-safe function to start next segment when slot becomes available
-  const startNextSegment = (): void => {
-    // Check if we have capacity and segments to fetch
-    if (
-      newActiveRequests.size >= config.maxParallelFetches ||
-      remainingQueue.length === 0 ||
-      signal.aborted
-    ) {
-      return;
-    }
-
-    const nextSegmentId = remainingQueue.shift();
-    if (nextSegmentId === undefined) return;
-
-    // Skip if already requested or now cached
-    if (
-      newRequestedSegments.has(nextSegmentId) ||
-      deps.isSegmentCached(nextSegmentId, rendition)
-    ) {
-      startNextSegment(); // Try next segment immediately
-      return;
-    }
-
-    newRequestedSegments.add(nextSegmentId);
-    newActiveRequests.add(nextSegmentId);
-
-    // Start the prefetch request
-    deps
-      .prefetchSegment(nextSegmentId, rendition)
-      .then(() => {
-        if (signal.aborted) return;
-        newActiveRequests.delete(nextSegmentId);
-        // Start next segment if continuous buffering is enabled
-        if (config.enableContinuousBuffering ?? true) {
-          startNextSegment();
-        }
-      })
-      .catch((error) => {
-        if (signal.aborted) return;
-        newActiveRequests.delete(nextSegmentId);
-        deps.logError(`Failed to prefetch segment ${nextSegmentId}`, error);
-        // Continue even after error if continuous buffering is enabled
-        if (config.enableContinuousBuffering ?? true) {
-          startNextSegment();
-        }
-      });
-  };
-
-  // Start initial batch of requests up to maxParallelFetches limit
-  const initialBatchSize = Math.min(config.maxParallelFetches, newQueue.length);
-  for (let i = 0; i < initialBatchSize; i++) {
-    startNextSegment();
-  }
-
-  const result = {
-    currentSeekTimeMs: seekTimeMs,
-    requestedSegments: newRequestedSegments,
-    activeRequests: newActiveRequests,
-    requestQueue: remainingQueue, // What's left in the queue
-  };
-  return result;
-};

package/src/elements/EFMedia/shared/GlobalInputCache.ts

@@ -1,77 +0,0 @@
-import type { Input } from "mediabunny";
-import { LRUCache } from "../../../utils/LRUCache.js";
-
-/**
- * Global cache for MediaBunny Input instances
- * Shared across all MediaEngine instances to prevent duplicate decoding
- * of the same segment data
- */
-class GlobalInputCache {
-  private cache = new LRUCache<string, Input>(50); // 50 Input instances max
-
-  /**
-   * Generate standardized cache key for Input objects
-   * Format: "input:{src}:{segmentId}:{renditionId}"
-   */
-  private generateKey(
-    src: string,
-    segmentId: number,
-    renditionId?: string,
-  ): string {
-    return `input:${src}:${segmentId}:${renditionId || "default"}`;
-  }
-
-  /**
-   * Get cached Input object
-   */
-  get(src: string, segmentId: number, renditionId?: string): Input | undefined {
-    const key = this.generateKey(src, segmentId, renditionId);
-    return this.cache.get(key);
-  }
-
-  /**
-   * Cache Input object
-   */
-  set(
-    src: string,
-    segmentId: number,
-    input: Input,
-    renditionId?: string,
-  ): void {
-    const key = this.generateKey(src, segmentId, renditionId);
-    this.cache.set(key, input);
-  }
-
-  /**
-   * Check if Input is cached
-   */
-  has(src: string, segmentId: number, renditionId?: string): boolean {
-    const key = this.generateKey(src, segmentId, renditionId);
-    return this.cache.has(key);
-  }
-
-  /**
-   * Clear all cached Input objects
-   */
-  clear(): void {
-    this.cache.clear();
-  }
-
-  /**
-   * Get cache statistics for debugging
-   */
-  getStats() {
-    return {
-      size: this.cache.size,
-      cachedKeys: Array.from((this.cache as any).cache.keys()),
-    };
-  }
-}
-
-// Single global instance shared across all MediaEngine instances
-export const globalInputCache = new GlobalInputCache();
-
-// Export for debugging (works in both browser and server)
-(
-  globalThis as typeof globalThis & { debugInputCache: typeof globalInputCache }
-).debugInputCache = globalInputCache;

package/src/elements/EFMedia/shared/MediaTaskUtils.ts

@@ -1,44 +0,0 @@
-import type { Task } from "@lit/task";
-import type {
-  AudioRendition,
-  MediaEngine,
-  VideoRendition,
-} from "../../../transcoding/types";
-import type { BufferedSeekingInput } from "../BufferedSeekingInput";
-
-/**
- * Generic rendition type that can be either audio or video
- */
-export type MediaRendition = AudioRendition | VideoRendition;
-
-/**
- * Generic task type for init segment fetch
- */
-export type InitSegmentFetchTask = Task<
-  readonly [MediaEngine | undefined],
-  ArrayBuffer
->;
-
-/**
- * Generic task type for segment ID calculation
- */
-export type SegmentIdTask = Task<
-  readonly [MediaEngine | undefined, number],
-  number | undefined
->;
-
-/**
- * Generic task type for segment fetch
- */
-export type SegmentFetchTask = Task<
-  readonly [MediaEngine | undefined, number | undefined],
-  ArrayBuffer
->;
-
-/**
- * Generic task type for input creation
- */
-export type InputTask = Task<
-  readonly [ArrayBuffer, ArrayBuffer],
-  BufferedSeekingInput | undefined
->;

package/src/elements/EFMedia/shared/PrecisionUtils.ts

@@ -1,46 +0,0 @@
-/**
- * Centralized precision utilities for consistent timing calculations across the media pipeline.
- *
- * The key insight is that floating-point precision errors can cause inconsistencies between:
- * 1. Segment selection logic (in AssetMediaEngine.computeSegmentId)
- * 2. Sample finding logic (in SampleBuffer.find)
- * 3. Timeline mapping (in BufferedSeekingInput.seek)
- *
- * All timing calculations must use the same rounding strategy to ensure consistency.
- */
-
-/**
- * Round time to millisecond precision to handle floating-point precision issues.
- * Uses Math.round for consistent behavior across the entire pipeline.
- *
- * This function should be used for ALL time-related calculations that need to be
- * compared between different parts of the system.
- */
-export const roundToMilliseconds = (timeMs: number): number => {
-  // Round to 3 decimal places (microsecond precision)
-  return Math.round(timeMs * 1000) / 1000;
-};
-
-/**
- * Convert media time (in seconds) to scaled time units using consistent rounding.
- * This is used in segment selection to convert from milliseconds to timescale units.
- */
-export const convertToScaledTime = (
-  timeMs: number,
-  timescale: number,
-): number => {
-  const scaledTime = (timeMs / 1000) * timescale;
-  return Math.round(scaledTime);
-};
-
-/**
- * Convert scaled time units back to media time (in milliseconds) using consistent rounding.
- * This is the inverse of convertToScaledTime.
- */
-export const convertFromScaledTime = (
-  scaledTime: number,
-  timescale: number,
-): number => {
-  const timeMs = (scaledTime / timescale) * 1000;
-  return roundToMilliseconds(timeMs);
-};