@editframe/elements 0.18.22-beta.0 → 0.18.26-beta.0

package/dist/elements/EFMedia/AssetMediaEngine.d.ts

@@ -1,5 +1,5 @@
 import { TrackFragmentIndex } from '../../../../assets/src/index.ts';
-import { AudioRendition, InitSegmentPaths, MediaEngine, SegmentTimeRange } from '../../transcoding/types';
+import { AudioRendition, InitSegmentPaths, MediaEngine, SegmentTimeRange, VideoRendition } from '../../transcoding/types';
 import { UrlGenerator } from '../../transcoding/utils/UrlGenerator';
 import { EFMedia } from '../EFMedia';
 import { BaseMediaEngine } from './BaseMediaEngine';
@@ -41,4 +41,5 @@ export declare class AssetMediaEngine extends BaseMediaEngine implements MediaEn
      */
     calculateAudioSegmentRange(fromMs: number, toMs: number, rendition: AudioRendition, _durationMs: number): SegmentTimeRange[];
     computeSegmentId(seekTimeMs: number, rendition: MediaRendition): number;
+    getScrubVideoRendition(): VideoRendition | undefined;
 }

package/dist/elements/EFMedia/AssetMediaEngine.js

@@ -142,5 +142,8 @@ var AssetMediaEngine = class AssetMediaEngine extends BaseMediaEngine {
 		}
 		return nearestSegmentIndex;
 	}
+	getScrubVideoRendition() {
+		return this.videoRendition;
+	}
 };
 export { AssetMediaEngine };

package/dist/elements/EFMedia/BaseMediaEngine.d.ts

@@ -71,4 +71,13 @@ export declare abstract class BaseMediaEngine {
      * Each media engine implements this based on their segment structure
      */
     calculateAudioSegmentRange(fromMs: number, toMs: number, rendition: AudioRendition, durationMs: number): SegmentTimeRange[];
+    /**
+     * Check if a segment is cached for a given rendition
+     * This needs to check the URL-based cache since that's where segments are actually stored
+     */
+    isSegmentCached(segmentId: number, rendition: AudioRendition | VideoRendition): boolean;
+    /**
+     * Get cached segment IDs from a list for a given rendition
+     */
+    getCachedSegments(segmentIds: number[], rendition: AudioRendition | VideoRendition): Set<number>;
 }

package/dist/elements/EFMedia/BaseMediaEngine.js

@@ -163,5 +163,36 @@ var BaseMediaEngine = class {
 		}
 		return segments;
 	}
+	/**
+	* Check if a segment is cached for a given rendition
+	* This needs to check the URL-based cache since that's where segments are actually stored
+	*/
+	isSegmentCached(segmentId, rendition) {
+		try {
+			const maybeJitEngine = this;
+			if (maybeJitEngine.urlGenerator && typeof maybeJitEngine.urlGenerator.generateSegmentUrl === "function") {
+				if (!rendition.id) {
+					console.log(`🎬 BaseMediaEngine: No rendition ID for segment ${segmentId}`);
+					return false;
+				}
+				const segmentUrl = maybeJitEngine.urlGenerator.generateSegmentUrl(segmentId, rendition.id, maybeJitEngine);
+				const urlIsCached = mediaCache.has(segmentUrl);
+				return urlIsCached;
+			}
+			const cacheKey = `${rendition.src}-${rendition.id || "default"}-${segmentId}-${rendition.trackId}`;
+			const isCached = mediaCache.has(cacheKey);
+			console.log(`🎬 BaseMediaEngine: Non-JIT engine, using segment key: "${cacheKey}", result: ${isCached}`);
+			return isCached;
+		} catch (error) {
+			console.warn(`🎬 BaseMediaEngine: Error checking if segment ${segmentId} is cached:`, error);
+			return false;
+		}
+	}
+	/**
+	* Get cached segment IDs from a list for a given rendition
+	*/
+	getCachedSegments(segmentIds, rendition) {
+		return new Set(segmentIds.filter((id) => this.isSegmentCached(id, rendition)));
+	}
 };
 export { BaseMediaEngine };

package/dist/elements/EFMedia/JitMediaEngine.d.ts

@@ -26,4 +26,5 @@ export declare class JitMediaEngine extends BaseMediaEngine implements MediaEngi
         src: string;
     }): Promise<ArrayBuffer>;
     computeSegmentId(desiredSeekTimeMs: number, rendition: VideoRendition | AudioRendition): number | undefined;
+    getScrubVideoRendition(): VideoRendition | undefined;
 }

package/dist/elements/EFMedia/JitMediaEngine.js

@@ -77,5 +77,17 @@ var JitMediaEngine = class JitMediaEngine extends BaseMediaEngine {
 		if (segmentStartMs >= this.durationMs) return void 0;
 		return segmentIndex + 1;
 	}
+	getScrubVideoRendition() {
+		if (!this.data.videoRenditions) return void 0;
+		const scrubManifestRendition = this.data.videoRenditions.find((r) => r.id === "scrub");
+		if (!scrubManifestRendition) return this.videoRendition;
+		return {
+			id: scrubManifestRendition.id,
+			trackId: void 0,
+			src: this.src,
+			segmentDurationMs: scrubManifestRendition.segmentDurationMs,
+			segmentDurationsMs: scrubManifestRendition.segmentDurationsMs
+		};
+	}
 };
 export { JitMediaEngine };

package/dist/elements/EFMedia/audioTasks/makeAudioBufferTask.js

@@ -6,12 +6,12 @@ import { Task } from "@lit/task";
 const makeAudioBufferTask = (host) => {
 	let currentState = {
 		currentSeekTimeMs: 0,
+		requestedSegments: /* @__PURE__ */ new Set(),
 		activeRequests: /* @__PURE__ */ new Set(),
-		cachedSegments: /* @__PURE__ */ new Set(),
 		requestQueue: []
 	};
 	return new Task(host, {
-		autoRun: EF_INTERACTIVE,
+		autoRun: EF_INTERACTIVE && !EF_RENDERING(),
 		args: () => [host.desiredSeekTimeMs],
 		onError: (error) => {
 			console.error("audioBufferTask error", error);
@@ -20,19 +20,25 @@ const makeAudioBufferTask = (host) => {
 			currentState = value;
 		},
 		task: async ([seekTimeMs], { signal }) => {
+			if (EF_RENDERING()) return currentState;
 			const currentConfig = {
 				bufferDurationMs: host.audioBufferDurationMs,
 				maxParallelFetches: host.maxAudioBufferFetches,
-				enableBuffering: host.enableAudioBuffering && !EF_RENDERING
+				enableBuffering: host.enableAudioBuffering
 			};
 			return manageMediaBuffer(seekTimeMs, currentConfig, currentState, host.intrinsicDurationMs || 1e4, signal, {
 				computeSegmentId: async (timeMs, rendition) => {
 					const mediaEngine = await getLatestMediaEngine(host, signal);
 					return mediaEngine.computeSegmentId(timeMs, rendition);
 				},
-				fetchSegment: async (segmentId, rendition) => {
+				prefetchSegment: async (segmentId, rendition) => {
 					const mediaEngine = await getLatestMediaEngine(host, signal);
-					return mediaEngine.fetchMediaSegment(segmentId, rendition);
+					await mediaEngine.fetchMediaSegment(segmentId, rendition);
+				},
+				isSegmentCached: (segmentId, rendition) => {
+					const mediaEngine = host.mediaEngineTask.value;
+					if (!mediaEngine) return false;
+					return mediaEngine.isSegmentCached(segmentId, rendition);
 				},
 				getRendition: async () => {
 					const mediaEngine = await getLatestMediaEngine(host, signal);

package/dist/elements/EFMedia/shared/BufferUtils.d.ts

@@ -1,11 +1,11 @@
 import { AudioRendition, VideoRendition } from '../../../transcoding/types';
 /**
- * State interface for media buffering - generic for both audio and video
+ * State interface for media buffering - orchestration only, no data storage
  */
 export interface MediaBufferState {
     currentSeekTimeMs: number;
+    requestedSegments: Set<number>;
     activeRequests: Set<number>;
-    cachedSegments: Set<number>;
     requestQueue: number[];
 }
 /**
@@ -18,11 +18,12 @@ export interface MediaBufferConfig {
     enableContinuousBuffering?: boolean;
 }
 /**
- * Dependencies interface for media buffering - generic for both audio and video
+ * Dependencies interface for media buffering - integrates with BaseMediaEngine
  */
 export interface MediaBufferDependencies<T extends AudioRendition | VideoRendition> {
     computeSegmentId: (timeMs: number, rendition: T) => Promise<number | undefined>;
-    fetchSegment: (segmentId: number, rendition: T) => Promise<ArrayBuffer>;
+    prefetchSegment: (segmentId: number, rendition: T) => Promise<void>;
+    isSegmentCached: (segmentId: number, rendition: T) => boolean;
     getRendition: () => Promise<T>;
     logError: (message: string, error: any) => void;
 }
@@ -36,10 +37,10 @@ export declare const computeSegmentRange: <T extends AudioRendition | VideoRendi
  */
 export declare const computeSegmentRangeAsync: <T extends AudioRendition | VideoRendition>(startTimeMs: number, endTimeMs: number, durationMs: number, rendition: T, computeSegmentId: (timeMs: number, rendition: T) => Promise<number | undefined>) => Promise<number[]>;
 /**
- * Compute buffer queue based on current state and desired segments
- * Pure function - determines what segments should be fetched
+ * Compute buffer queue based on desired segments and what we've already requested
+ * Pure function - determines what new segments should be prefetched
  */
-export declare const computeBufferQueue: (desiredSegments: number[], activeRequests: Set<number>, cachedSegments: Set<number>) => number[];
+export declare const computeBufferQueue: (desiredSegments: number[], requestedSegments: Set<number>) => number[];
 /**
  * Handle seek time change and recompute buffer queue
  * Pure function - computes new queue when seek time changes
@@ -49,22 +50,22 @@ export declare const handleSeekTimeChange: <T extends AudioRendition | VideoRend
     overlappingRequests: number[];
 };
 /**
- * Check if a specific segment is cached in the buffer
- * Pure function for accessing buffer cache state
+ * Check if a segment has been requested for buffering
+ * Pure function for checking buffer orchestration state
  */
-export declare const getCachedSegment: (segmentId: number, bufferState: MediaBufferState | undefined) => boolean;
+export declare const isSegmentRequested: (segmentId: number, bufferState: MediaBufferState | undefined) => boolean;
 /**
- * Get cached segments from a list of segment IDs
- * Pure function that returns which segments are available in cache
+ * Get requested segments from a list of segment IDs
+ * Pure function that returns which segments have been requested for buffering
  */
-export declare const getCachedSegments: (segmentIds: number[], bufferState: MediaBufferState | undefined) => Set<number>;
+export declare const getRequestedSegments: (segmentIds: number[], bufferState: MediaBufferState | undefined) => Set<number>;
 /**
- * Get missing segments from a list of segment IDs
- * Pure function that returns which segments need to be fetched
+ * Get unrequested segments from a list of segment IDs
+ * Pure function that returns which segments haven't been requested yet
  */
-export declare const getMissingSegments: (segmentIds: number[], bufferState: MediaBufferState | undefined) => number[];
+export declare const getUnrequestedSegments: (segmentIds: number[], bufferState: MediaBufferState | undefined) => number[];
 /**
- * Core media buffering logic with explicit dependencies
- * Generic implementation that works for both audio and video
+ * Core media buffering orchestration logic - prefetch only, no data storage
+ * Integrates with BaseMediaEngine's existing caching and request deduplication
  */
 export declare const manageMediaBuffer: <T extends AudioRendition | VideoRendition>(seekTimeMs: number, config: MediaBufferConfig, currentState: MediaBufferState, durationMs: number, signal: AbortSignal, deps: MediaBufferDependencies<T>) => Promise<MediaBufferState>;

package/dist/elements/EFMedia/shared/BufferUtils.js

@@ -16,74 +16,54 @@ const computeSegmentRangeAsync = async (startTimeMs, endTimeMs, durationMs, rend
 	return segments.filter((id, index, arr) => arr.indexOf(id) === index);
 };
 /**
-* Compute buffer queue based on current state and desired segments
-* Pure function - determines what segments should be fetched
+* Compute buffer queue based on desired segments and what we've already requested
+* Pure function - determines what new segments should be prefetched
 */
-const computeBufferQueue = (desiredSegments, activeRequests, cachedSegments) => {
-	return desiredSegments.filter((segmentId) => !activeRequests.has(segmentId) && !cachedSegments.has(segmentId));
+const computeBufferQueue = (desiredSegments, requestedSegments) => {
+	return desiredSegments.filter((segmentId) => !requestedSegments.has(segmentId));
 };
 /**
-* Core media buffering logic with explicit dependencies
-* Generic implementation that works for both audio and video
+* Core media buffering orchestration logic - prefetch only, no data storage
+* Integrates with BaseMediaEngine's existing caching and request deduplication
 */
 const manageMediaBuffer = async (seekTimeMs, config, currentState, durationMs, signal, deps) => {
 	if (!config.enableBuffering) return currentState;
 	const rendition = await deps.getRendition();
 	const endTimeMs = seekTimeMs + config.bufferDurationMs;
 	const desiredSegments = await computeSegmentRangeAsync(seekTimeMs, endTimeMs, durationMs, rendition, deps.computeSegmentId);
-	const newQueue = computeBufferQueue(desiredSegments, currentState.activeRequests, currentState.cachedSegments);
-	const segmentsToFetch = newQueue.slice(0, config.maxParallelFetches);
+	const uncachedSegments = desiredSegments.filter((segmentId) => !deps.isSegmentCached(segmentId, rendition));
+	const newQueue = computeBufferQueue(uncachedSegments, currentState.requestedSegments);
+	const newRequestedSegments = new Set(currentState.requestedSegments);
 	const newActiveRequests = new Set(currentState.activeRequests);
-	const newCachedSegments = new Set(currentState.cachedSegments);
-	const startNextSegment = (remainingQueue) => {
-		if (remainingQueue.length === 0 || signal.aborted) return;
-		const availableSlots = config.maxParallelFetches - newActiveRequests.size;
-		if (availableSlots <= 0) return;
-		const nextSegmentId = remainingQueue[0];
+	const remainingQueue = [...newQueue];
+	const startNextSegment = () => {
+		if (newActiveRequests.size >= config.maxParallelFetches || remainingQueue.length === 0 || signal.aborted) return;
+		const nextSegmentId = remainingQueue.shift();
 		if (nextSegmentId === void 0) return;
-		if (newActiveRequests.has(nextSegmentId) || newCachedSegments.has(nextSegmentId)) {
-			startNextSegment(remainingQueue.slice(1));
+		if (newRequestedSegments.has(nextSegmentId) || deps.isSegmentCached(nextSegmentId, rendition)) {
+			startNextSegment();
 			return;
 		}
+		newRequestedSegments.add(nextSegmentId);
 		newActiveRequests.add(nextSegmentId);
-		deps.fetchSegment(nextSegmentId, rendition).then(() => {
+		deps.prefetchSegment(nextSegmentId, rendition).then(() => {
 			if (signal.aborted) return;
 			newActiveRequests.delete(nextSegmentId);
-			newCachedSegments.add(nextSegmentId);
-			startNextSegment(remainingQueue.slice(1));
+			if (config.enableContinuousBuffering ?? true) startNextSegment();
 		}).catch((error) => {
 			if (signal.aborted) return;
 			newActiveRequests.delete(nextSegmentId);
-			deps.logError(`Failed to fetch segment ${nextSegmentId}`, error);
-			startNextSegment(remainingQueue.slice(1));
+			deps.logError(`Failed to prefetch segment ${nextSegmentId}`, error);
+			if (config.enableContinuousBuffering ?? true) startNextSegment();
 		});
 	};
-	for (const segmentId of segmentsToFetch) {
-		if (signal.aborted) break;
-		newActiveRequests.add(segmentId);
-		deps.fetchSegment(segmentId, rendition).then(() => {
-			if (signal.aborted) return;
-			newActiveRequests.delete(segmentId);
-			newCachedSegments.add(segmentId);
-			if (config.enableContinuousBuffering ?? true) {
-				const remainingQueue = newQueue.slice(segmentsToFetch.length);
-				startNextSegment(remainingQueue);
-			}
-		}).catch((error) => {
-			if (signal.aborted) return;
-			newActiveRequests.delete(segmentId);
-			deps.logError(`Failed to fetch segment ${segmentId}`, error);
-			if (config.enableContinuousBuffering ?? true) {
-				const remainingQueue = newQueue.slice(segmentsToFetch.length);
-				startNextSegment(remainingQueue);
-			}
-		});
-	}
+	const initialBatchSize = Math.min(config.maxParallelFetches, newQueue.length);
+	for (let i = 0; i < initialBatchSize; i++) startNextSegment();
 	return {
 		currentSeekTimeMs: seekTimeMs,
+		requestedSegments: newRequestedSegments,
 		activeRequests: newActiveRequests,
-		cachedSegments: newCachedSegments,
-		requestQueue: newQueue.slice(segmentsToFetch.length)
+		requestQueue: remainingQueue
 	};
 };
 export { manageMediaBuffer };

package/dist/elements/EFMedia/tasks/makeMediaEngineTask.browsertest.d.ts

@@ -1 +1,9 @@
+import { EFMedia } from '../../EFMedia.js';
+declare class TestMediaEngine extends EFMedia {
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "test-media-engine": TestMediaEngine;
+    }
+}
 export {};

package/dist/elements/EFMedia/tasks/makeMediaEngineTask.js

@@ -29,11 +29,11 @@ const createMediaEngine = (host) => {
 		return Promise.reject(/* @__PURE__ */ new Error("Unsupported media source"));
 	}
 	const lowerSrc = src.toLowerCase();
-	if (lowerSrc.startsWith("http://") || lowerSrc.startsWith("https://")) {
-		const url = urlGenerator.generateManifestUrl(src);
-		return JitMediaEngine.fetch(host, urlGenerator, url);
-	}
-	return AssetMediaEngine.fetch(host, urlGenerator, src);
+	if (!lowerSrc.startsWith("http://") && !lowerSrc.startsWith("https://")) return AssetMediaEngine.fetch(host, urlGenerator, src);
+	const configuration = host.closest("ef-configuration");
+	if (configuration?.mediaEngine === "local") return AssetMediaEngine.fetch(host, urlGenerator, src);
+	const url = urlGenerator.generateManifestUrl(src);
+	return JitMediaEngine.fetch(host, urlGenerator, url);
 };
 /**
 * Handle completion of media engine task - triggers necessary updates.

package/dist/elements/EFMedia/videoTasks/ScrubInputCache.d.ts

@@ -0,0 +1,25 @@
+import { BufferedSeekingInput } from '../BufferedSeekingInput';
+/**
+ * Cache for scrub BufferedSeekingInput instances
+ * Since scrub segments are 30s long, we can reuse the same input for many seeks
+ * within that time range, making scrub seeking very efficient
+ */
+export declare class ScrubInputCache {
+    private cache;
+    private maxCacheSize;
+    /**
+     * Get or create BufferedSeekingInput for a scrub segment
+     */
+    getOrCreateInput(segmentId: number, createInputFn: () => Promise<BufferedSeekingInput | undefined>): Promise<BufferedSeekingInput | undefined>;
+    /**
+     * Clear the entire cache (called when video changes)
+     */
+    clear(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): {
+        size: number;
+        segmentIds: number[];
+    };
+}

package/dist/elements/EFMedia/videoTasks/ScrubInputCache.js

@@ -0,0 +1,42 @@
+/**
+* Cache for scrub BufferedSeekingInput instances
+* Since scrub segments are 30s long, we can reuse the same input for many seeks
+* within that time range, making scrub seeking very efficient
+*/
+var ScrubInputCache = class {
+	constructor() {
+		this.cache = /* @__PURE__ */ new Map();
+		this.maxCacheSize = 5;
+	}
+	/**
+	* Get or create BufferedSeekingInput for a scrub segment
+	*/
+	async getOrCreateInput(segmentId, createInputFn) {
+		const cached = this.cache.get(segmentId);
+		if (cached) return cached;
+		const input = await createInputFn();
+		if (!input) return void 0;
+		this.cache.set(segmentId, input);
+		if (this.cache.size > this.maxCacheSize) {
+			const oldestKey = this.cache.keys().next().value;
+			if (oldestKey !== void 0) this.cache.delete(oldestKey);
+		}
+		return input;
+	}
+	/**
+	* Clear the entire cache (called when video changes)
+	*/
+	clear() {
+		this.cache.clear();
+	}
+	/**
+	* Get cache statistics
+	*/
+	getStats() {
+		return {
+			size: this.cache.size,
+			segmentIds: Array.from(this.cache.keys())
+		};
+	}
+};
+export { ScrubInputCache };

package/dist/elements/EFMedia/videoTasks/makeScrubVideoBufferTask.d.ts

@@ -0,0 +1,8 @@
+import { Task } from '@lit/task';
+import { EFVideo } from '../../EFVideo';
+/**
+ * Scrub video buffer task - aggressively preloads the ENTIRE scrub track
+ * Unlike main video buffering, this loads the full duration with higher concurrency
+ * for instant visual feedback during seeking
+ */
+export declare const makeScrubVideoBufferTask: (host: EFVideo) => Task<readonly [import('../../../transcoding/types').MediaEngine | undefined], unknown>;

package/dist/elements/EFMedia/videoTasks/makeScrubVideoBufferTask.js

@@ -0,0 +1,70 @@
+import { EF_RENDERING } from "../../../EF_RENDERING.js";
+import { manageMediaBuffer } from "../shared/BufferUtils.js";
+import { Task } from "@lit/task";
+/**
+* Scrub video buffer task - aggressively preloads the ENTIRE scrub track
+* Unlike main video buffering, this loads the full duration with higher concurrency
+* for instant visual feedback during seeking
+*/
+const makeScrubVideoBufferTask = (host) => {
+	let currentState = {
+		currentSeekTimeMs: 0,
+		requestedSegments: /* @__PURE__ */ new Set(),
+		activeRequests: /* @__PURE__ */ new Set(),
+		requestQueue: []
+	};
+	return new Task(host, {
+		autoRun: !EF_RENDERING(),
+		args: () => [host.mediaEngineTask.value],
+		onError: (error) => {
+			console.error("scrubVideoBufferTask error", error);
+		},
+		onComplete: (value) => {
+			currentState = value;
+		},
+		task: async ([mediaEngine], { signal }) => {
+			if (EF_RENDERING()) return currentState;
+			if (!host.enableVideoBuffering) return currentState;
+			if (!mediaEngine) return currentState;
+			const scrubRendition = mediaEngine.getScrubVideoRendition();
+			if (!scrubRendition) return currentState;
+			const scrubRenditionWithSrc = {
+				...scrubRendition,
+				src: mediaEngine.src
+			};
+			try {
+				try {
+					await mediaEngine.fetchInitSegment(scrubRenditionWithSrc, signal);
+				} catch (error) {
+					console.warn("ScrubBuffer: Failed to cache scrub init segment:", error);
+				}
+				const newState = await manageMediaBuffer(0, {
+					bufferDurationMs: mediaEngine.durationMs,
+					maxParallelFetches: 10,
+					enableBuffering: true,
+					enableContinuousBuffering: true
+				}, currentState, mediaEngine.durationMs, signal, {
+					computeSegmentId: async (timeMs, rendition) => {
+						return mediaEngine.computeSegmentId(timeMs, rendition);
+					},
+					prefetchSegment: async (segmentId, rendition) => {
+						await mediaEngine.fetchMediaSegment(segmentId, rendition);
+					},
+					isSegmentCached: (segmentId, rendition) => {
+						return mediaEngine.isSegmentCached(segmentId, rendition);
+					},
+					getRendition: async () => scrubRenditionWithSrc,
+					logError: (message, error) => {
+						console.warn(`ScrubBuffer: ${message}`, error);
+					}
+				});
+				return newState;
+			} catch (error) {
+				if (signal.aborted) return currentState;
+				console.warn("ScrubBuffer failed:", error);
+				return currentState;
+			}
+		}
+	});
+};
+export { makeScrubVideoBufferTask };

package/dist/elements/EFMedia/videoTasks/{makeVideoInitSegmentFetchTask.d.ts → makeScrubVideoInitSegmentFetchTask.d.ts}

@@ -1,4 +1,4 @@
 import { Task } from '@lit/task';
 import { MediaEngine } from '../../../transcoding/types';
 import { EFVideo } from '../../EFVideo';
-export declare const makeVideoInitSegmentFetchTask: (host: EFVideo) => Task<readonly [MediaEngine | undefined], ArrayBuffer>;
+export declare const makeScrubVideoInitSegmentFetchTask: (host: EFVideo) => Task<readonly [MediaEngine | undefined], ArrayBuffer>;

package/dist/elements/EFMedia/videoTasks/makeScrubVideoInitSegmentFetchTask.js

@@ -0,0 +1,21 @@
+import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask.js";
+import { Task } from "@lit/task";
+const makeScrubVideoInitSegmentFetchTask = (host) => {
+	return new Task(host, {
+		args: () => [host.mediaEngineTask.value],
+		onError: (error) => {
+			console.error("scrubVideoInitSegmentFetchTask error", error);
+		},
+		onComplete: (_value) => {},
+		task: async ([_mediaEngine], { signal }) => {
+			const mediaEngine = await getLatestMediaEngine(host, signal);
+			const scrubRendition = mediaEngine.getScrubVideoRendition();
+			if (!scrubRendition) throw new Error("No scrub rendition available");
+			return mediaEngine.fetchInitSegment({
+				...scrubRendition,
+				src: mediaEngine.src
+			}, signal);
+		}
+	});
+};
+export { makeScrubVideoInitSegmentFetchTask };

package/dist/elements/EFMedia/videoTasks/{makeVideoInputTask.d.ts → makeScrubVideoInputTask.d.ts}

@@ -1,3 +1,3 @@
 import { EFVideo } from '../../EFVideo';
 import { InputTask } from '../shared/MediaTaskUtils';
-export declare const makeVideoInputTask: (host: EFVideo) => InputTask;
+export declare const makeScrubVideoInputTask: (host: EFVideo) => InputTask;

package/dist/elements/EFMedia/videoTasks/makeScrubVideoInputTask.js

@@ -0,0 +1,27 @@
+import { BufferedSeekingInput } from "../BufferedSeekingInput.js";
+import { EFMedia } from "../../EFMedia.js";
+import { Task } from "@lit/task";
+const makeScrubVideoInputTask = (host) => {
+	return new Task(host, {
+		args: () => [host.scrubVideoInitSegmentFetchTask.value, host.scrubVideoSegmentFetchTask.value],
+		onError: (error) => {
+			console.error("scrubVideoInputTask error", error);
+		},
+		onComplete: (_value) => {},
+		task: async () => {
+			const initSegment = await host.scrubVideoInitSegmentFetchTask.taskComplete;
+			const segment = await host.scrubVideoSegmentFetchTask.taskComplete;
+			if (!initSegment || !segment) throw new Error("Scrub init segment or segment is not available");
+			const mediaEngine = await host.mediaEngineTask.taskComplete;
+			const scrubRendition = mediaEngine.getScrubVideoRendition();
+			const startTimeOffsetMs = scrubRendition?.startTimeOffsetMs;
+			const input = new BufferedSeekingInput(await new Blob([initSegment, segment]).arrayBuffer(), {
+				videoBufferSize: EFMedia.VIDEO_SAMPLE_BUFFER_SIZE,
+				audioBufferSize: EFMedia.AUDIO_SAMPLE_BUFFER_SIZE,
+				startTimeOffsetMs
+			});
+			return input;
+		}
+	});
+};
+export { makeScrubVideoInputTask };

package/dist/elements/EFMedia/videoTasks/makeScrubVideoSeekTask.d.ts

@@ -0,0 +1,6 @@
+import { Task } from '@lit/task';
+import { VideoSample } from 'mediabunny';
+import { EFVideo } from '../../EFVideo';
+type ScrubVideoSeekTask = Task<readonly [number], VideoSample | undefined>;
+export declare const makeScrubVideoSeekTask: (host: EFVideo) => ScrubVideoSeekTask;
+export {};

package/dist/elements/EFMedia/videoTasks/makeScrubVideoSeekTask.js

@@ -0,0 +1,52 @@
+import { ScrubInputCache } from "./ScrubInputCache.js";
+import { Task } from "@lit/task";
+const scrubInputCache = new ScrubInputCache();
+const makeScrubVideoSeekTask = (host) => {
+	return new Task(host, {
+		args: () => [host.desiredSeekTimeMs],
+		onError: (error) => {
+			console.error("scrubVideoSeekTask error", error);
+		},
+		onComplete: (_value) => {},
+		task: async ([desiredSeekTimeMs], { signal }) => {
+			signal.throwIfAborted();
+			const mediaEngine = host.mediaEngineTask.value;
+			if (!mediaEngine) return void 0;
+			const scrubRendition = mediaEngine.getScrubVideoRendition();
+			if (!scrubRendition) return void 0;
+			const scrubRenditionWithSrc = {
+				...scrubRendition,
+				src: mediaEngine.src
+			};
+			const segmentId = mediaEngine.computeSegmentId(desiredSeekTimeMs, scrubRenditionWithSrc);
+			if (segmentId === void 0) return void 0;
+			const isCached = mediaEngine.isSegmentCached(segmentId, scrubRenditionWithSrc);
+			if (!isCached) return void 0;
+			signal.throwIfAborted();
+			try {
+				const scrubInput = await scrubInputCache.getOrCreateInput(segmentId, async () => {
+					const [initSegment, mediaSegment] = await Promise.all([mediaEngine.fetchInitSegment(scrubRenditionWithSrc, signal), mediaEngine.fetchMediaSegment(segmentId, scrubRenditionWithSrc)]);
+					if (!initSegment || !mediaSegment || signal.aborted) return void 0;
+					const { BufferedSeekingInput } = await import("../BufferedSeekingInput.js");
+					const { EFMedia } = await import("../../EFMedia.js");
+					return new BufferedSeekingInput(await new Blob([initSegment, mediaSegment]).arrayBuffer(), {
+						videoBufferSize: EFMedia.VIDEO_SAMPLE_BUFFER_SIZE,
+						audioBufferSize: EFMedia.AUDIO_SAMPLE_BUFFER_SIZE,
+						startTimeOffsetMs: scrubRendition.startTimeOffsetMs
+					});
+				});
+				if (!scrubInput) return void 0;
+				const videoTrack = await scrubInput.getFirstVideoTrack();
+				if (!videoTrack) return void 0;
+				signal.throwIfAborted();
+				const sample = await scrubInput.seek(videoTrack.id, desiredSeekTimeMs);
+				return sample;
+			} catch (error) {
+				if (signal.aborted) return void 0;
+				console.warn("Failed to get scrub video sample:", error);
+				return void 0;
+			}
+		}
+	});
+};
+export { makeScrubVideoSeekTask };

package/dist/elements/EFMedia/videoTasks/makeScrubVideoSegmentFetchTask.d.ts

@@ -0,0 +1,4 @@
+import { Task } from '@lit/task';
+import { MediaEngine } from '../../../transcoding/types';
+import { EFVideo } from '../../EFVideo';
+export declare const makeScrubVideoSegmentFetchTask: (host: EFVideo) => Task<readonly [MediaEngine | undefined, number | undefined], ArrayBuffer>;