@editframe/elements 0.17.6-beta.0 → 0.18.3-beta.0

package/dist/elements/EFMedia/BufferedSeekingInput.js

@@ -0,0 +1,159 @@
+import { SampleBuffer } from "../SampleBuffer.js";
+import { AudioSampleSink, BufferSource, Input, MP4, VideoSampleSink } from "mediabunny";
+const defaultOptions = {
+	videoBufferSize: 30,
+	audioBufferSize: 100,
+	startTimeOffsetMs: 0
+};
+var NoSample = class extends RangeError {};
+var BufferedSeekingInput = class {
+	constructor(arrayBuffer, options) {
+		this.trackIterators = /* @__PURE__ */ new Map();
+		this.trackBuffers = /* @__PURE__ */ new Map();
+		this.trackIteratorCreationPromises = /* @__PURE__ */ new Map();
+		this.trackSeekPromises = /* @__PURE__ */ new Map();
+		const bufferSource = new BufferSource(arrayBuffer);
+		const input = new Input({
+			source: bufferSource,
+			formats: [MP4]
+		});
+		this.input = input;
+		this.options = {
+			...defaultOptions,
+			...options
+		};
+		this.startTimeOffsetMs = this.options.startTimeOffsetMs ?? 0;
+	}
+	getBufferSize(trackId) {
+		const buffer = this.trackBuffers.get(trackId);
+		return buffer ? buffer.length : 0;
+	}
+	getBufferContents(trackId) {
+		const buffer = this.trackBuffers.get(trackId);
+		return buffer ? Object.freeze([...buffer.getContents()]) : [];
+	}
+	getBufferTimestamps(trackId) {
+		const contents = this.getBufferContents(trackId);
+		return contents.map((sample) => sample.timestamp || 0);
+	}
+	clearBuffer(trackId) {
+		const buffer = this.trackBuffers.get(trackId);
+		if (buffer) buffer.clear();
+	}
+	computeDuration() {
+		return this.input.computeDuration();
+	}
+	async getTrack(trackId) {
+		const tracks = await this.input.getTracks();
+		const track = tracks.find((track$1) => track$1.id === trackId);
+		if (!track) throw new Error(`Track ${trackId} not found`);
+		return track;
+	}
+	async getAudioTrack(trackId) {
+		const tracks = await this.input.getAudioTracks();
+		const track = tracks.find((track$1) => track$1.id === trackId && track$1.type === "audio");
+		if (!track) throw new Error(`Track ${trackId} not found`);
+		return track;
+	}
+	async getVideoTrack(trackId) {
+		const tracks = await this.input.getVideoTracks();
+		const track = tracks.find((track$1) => track$1.id === trackId && track$1.type === "video");
+		if (!track) throw new Error(`Track ${trackId} not found`);
+		return track;
+	}
+	async getFirstVideoTrack() {
+		const tracks = await this.input.getVideoTracks();
+		return tracks[0];
+	}
+	async getFirstAudioTrack() {
+		const tracks = await this.input.getAudioTracks();
+		return tracks[0];
+	}
+	async getTrackIterator(trackId) {
+		if (this.trackIterators.has(trackId)) return this.trackIterators.get(trackId);
+		const existingIteratorCreation = this.trackIteratorCreationPromises.get(trackId);
+		if (existingIteratorCreation) {
+			await existingIteratorCreation;
+			if (this.trackIterators.has(trackId)) return this.trackIterators.get(trackId);
+		}
+		const creationPromise = this.createIteratorSafe(trackId);
+		this.trackIteratorCreationPromises.set(trackId, creationPromise);
+		try {
+			const iterator = await creationPromise;
+			return iterator;
+		} finally {
+			this.trackIteratorCreationPromises.delete(trackId);
+		}
+	}
+	async createIteratorSafe(trackId) {
+		const track = await this.getTrack(trackId);
+		if (track.type === "audio") {
+			const track$1 = await this.getAudioTrack(trackId);
+			const sampleSink = new AudioSampleSink(track$1);
+			const iterator = sampleSink.samples();
+			this.trackIterators.set(trackId, iterator);
+			return iterator;
+		}
+		{
+			const track$1 = await this.getVideoTrack(trackId);
+			const sampleSink = new VideoSampleSink(track$1);
+			const iterator = sampleSink.samples();
+			this.trackIterators.set(trackId, iterator);
+			return iterator;
+		}
+	}
+	async createTrackBuffer(trackId) {
+		const track = await this.getTrack(trackId);
+		if (track.type === "audio") {
+			const bufferSize = this.options.audioBufferSize;
+			this.trackBuffers.set(trackId, new SampleBuffer(bufferSize));
+		} else {
+			const bufferSize = this.options.videoBufferSize;
+			this.trackBuffers.set(trackId, new SampleBuffer(bufferSize));
+		}
+	}
+	async seek(trackId, timeMs) {
+		const correctedTimeMs = timeMs + this.startTimeOffsetMs;
+		const existingSeek = this.trackSeekPromises.get(trackId);
+		if (existingSeek) await existingSeek;
+		const seekPromise = this.seekSafe(trackId, correctedTimeMs);
+		this.trackSeekPromises.set(trackId, seekPromise);
+		try {
+			return await seekPromise;
+		} finally {
+			this.trackSeekPromises.delete(trackId);
+		}
+	}
+	async resetIterator(trackId) {
+		const trackBuffer = this.trackBuffers.get(trackId);
+		trackBuffer?.clear();
+		const ongoingIteratorCreation = this.trackIteratorCreationPromises.get(trackId);
+		if (ongoingIteratorCreation) await ongoingIteratorCreation;
+		const iterator = this.trackIterators.get(trackId);
+		if (iterator) try {
+			await iterator.return?.();
+		} catch (_error) {}
+		this.trackIterators.delete(trackId);
+	}
+	async seekSafe(trackId, timeMs) {
+		if (!this.trackBuffers.has(trackId)) await this.createTrackBuffer(trackId);
+		const trackBuffer = this.trackBuffers.get(trackId);
+		if (timeMs < trackBuffer.firstTimestamp * 1e3) await this.resetIterator(trackId);
+		const alreadyInBuffer = trackBuffer.find(timeMs);
+		const track = await this.getTrack(trackId);
+		const firstTimestampMs = await track.getFirstTimestamp() * 1e3;
+		const lastSampleEndMs = await track.computeDuration() * 1e3;
+		if (timeMs < firstTimestampMs || timeMs >= lastSampleEndMs) throw new NoSample(`Seek time ${timeMs}ms is outside track range [${firstTimestampMs}ms, ${lastSampleEndMs}ms]`);
+		if (alreadyInBuffer) return alreadyInBuffer;
+		const iterator = await this.getTrackIterator(trackId);
+		while (true) {
+			const { done, value: decodedSample } = await iterator.next();
+			if (decodedSample) trackBuffer.push(decodedSample);
+			const foundSample = trackBuffer.find(timeMs);
+			if (foundSample) return foundSample;
+			if (done) break;
+		}
+		throw new NoSample(`Sample not found for time ${timeMs} in ${track.type} track ${trackId}`);
+	}
+};
+export { BufferedSeekingInput };

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

@@ -0,0 +1,31 @@
+import { AudioRendition, MediaEngine, RenditionId, VideoRendition } from '../../transcoding/types';
+import { ManifestResponse } from '../../transcoding/types/index.js';
+import { UrlGenerator } from '../../transcoding/utils/UrlGenerator';
+import { EFMedia } from '../EFMedia.js';
+import { BaseMediaEngine } from './BaseMediaEngine';
+export declare class JitMediaEngine extends BaseMediaEngine implements MediaEngine {
+    host: EFMedia;
+    private urlGenerator;
+    private data;
+    static fetch(host: EFMedia, urlGenerator: UrlGenerator, url: string): Promise<JitMediaEngine>;
+    constructor(host: EFMedia, urlGenerator: UrlGenerator, data: ManifestResponse);
+    get durationMs(): number;
+    get src(): string;
+    get audioRendition(): AudioRendition | undefined;
+    get videoRendition(): VideoRendition | undefined;
+    get templates(): {
+        initSegment: string;
+        mediaSegment: string;
+    };
+    fetchInitSegment(rendition: {
+        id?: RenditionId;
+        trackId: number | undefined;
+        src: string;
+    }, signal: AbortSignal): Promise<ArrayBuffer>;
+    fetchMediaSegmentImpl(segmentId: number, rendition: {
+        id?: RenditionId;
+        trackId: number | undefined;
+        src: string;
+    }): Promise<ArrayBuffer>;
+    computeSegmentId(desiredSeekTimeMs: number, rendition: VideoRendition | AudioRendition): number;
+}

package/dist/elements/EFMedia/JitMediaEngine.js

@@ -0,0 +1,62 @@
+import { BaseMediaEngine } from "./BaseMediaEngine.js";
+var JitMediaEngine = class JitMediaEngine extends BaseMediaEngine {
+	static async fetch(host, urlGenerator, url) {
+		const response = await host.fetch(url);
+		const data = await response.json();
+		return new JitMediaEngine(host, urlGenerator, data);
+	}
+	constructor(host, urlGenerator, data) {
+		super();
+		this.host = host;
+		this.urlGenerator = urlGenerator;
+		this.data = data;
+	}
+	get durationMs() {
+		return this.data.durationMs;
+	}
+	get src() {
+		return this.data.sourceUrl;
+	}
+	get audioRendition() {
+		const rendition = this.data.audioRenditions[0];
+		if (!rendition) return void 0;
+		return {
+			id: rendition.id,
+			trackId: void 0,
+			src: this.data.sourceUrl,
+			segmentDurationMs: rendition.segmentDurationMs
+		};
+	}
+	get videoRendition() {
+		const rendition = this.data.videoRenditions[0];
+		if (!rendition) return void 0;
+		return {
+			id: rendition.id,
+			trackId: void 0,
+			src: this.data.sourceUrl,
+			segmentDurationMs: rendition.segmentDurationMs
+		};
+	}
+	get templates() {
+		return this.data.endpoints;
+	}
+	async fetchInitSegment(rendition, signal) {
+		if (!rendition.id) throw new Error("Rendition ID is required for JIT metadata");
+		const url = this.urlGenerator.generateSegmentUrl("init", rendition.id, this);
+		const response = await this.host.fetch(url, { signal });
+		const arrayBuffer = await response.arrayBuffer();
+		return arrayBuffer;
+	}
+	async fetchMediaSegmentImpl(segmentId, rendition) {
+		if (!rendition.id) throw new Error("Rendition ID is required for JIT metadata");
+		const url = this.urlGenerator.generateSegmentUrl(segmentId, rendition.id, this);
+		return this.fetchMediaCache(url);
+	}
+	computeSegmentId(desiredSeekTimeMs, rendition) {
+		if (!rendition.segmentDurationMs) throw new Error("Segment duration is required for JIT metadata");
+		const segmentIndex = Math.floor(desiredSeekTimeMs / rendition.segmentDurationMs);
+		if (segmentIndex * rendition.segmentDurationMs >= this.durationMs) return segmentIndex;
+		return segmentIndex + 1;
+	}
+};
+export { JitMediaEngine };

package/dist/elements/EFMedia/audioTasks/makeAudioBufferTask.browsertest.d.ts

@@ -0,0 +1,9 @@
+import { EFMedia } from '../../EFMedia';
+declare class TestMediaAudioBuffer extends EFMedia {
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "test-media-audio-buffer": TestMediaAudioBuffer;
+    }
+}
+export {};

package/dist/elements/EFMedia/audioTasks/makeAudioBufferTask.d.ts

@@ -0,0 +1,16 @@
+import { Task } from '@lit/task';
+import { EFMedia } from '../../EFMedia';
+import { MediaBufferConfig, MediaBufferState } from '../shared/BufferUtils';
+/**
+ * Configuration for audio buffering - extends the generic interface
+ */
+export interface AudioBufferConfig extends MediaBufferConfig {
+}
+/**
+ * State of the audio buffer - uses the generic interface
+ */
+export interface AudioBufferState extends MediaBufferState {
+}
+type AudioBufferTask = Task<readonly [number], AudioBufferState>;
+export declare const makeAudioBufferTask: (host: EFMedia) => AudioBufferTask;
+export {};

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

@@ -0,0 +1,48 @@
+import { EF_INTERACTIVE } from "../../../EF_INTERACTIVE.js";
+import { EF_RENDERING } from "../../../EF_RENDERING.js";
+import { manageMediaBuffer } from "../shared/BufferUtils.js";
+import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask.js";
+import { Task } from "@lit/task";
+const makeAudioBufferTask = (host) => {
+	let currentState = {
+		currentSeekTimeMs: 0,
+		activeRequests: /* @__PURE__ */ new Set(),
+		cachedSegments: /* @__PURE__ */ new Set(),
+		requestQueue: []
+	};
+	return new Task(host, {
+		autoRun: EF_INTERACTIVE,
+		args: () => [host.desiredSeekTimeMs],
+		onError: (error) => {
+			console.error("audioBufferTask error", error);
+		},
+		onComplete: (value) => {
+			currentState = value;
+		},
+		task: async ([seekTimeMs], { signal }) => {
+			const currentConfig = {
+				bufferDurationMs: host.audioBufferDurationMs,
+				maxParallelFetches: host.maxAudioBufferFetches,
+				enableBuffering: host.enableAudioBuffering && !EF_RENDERING
+			};
+			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) => {
+					const mediaEngine = await getLatestMediaEngine(host, signal);
+					return mediaEngine.fetchMediaSegment(segmentId, rendition);
+				},
+				getRendition: async () => {
+					const mediaEngine = await getLatestMediaEngine(host, signal);
+					const audioRendition = mediaEngine.audioRendition;
+					if (!audioRendition) throw new Error("Audio rendition not available");
+					return audioRendition;
+				},
+				logError: console.error
+			});
+		}
+	});
+};
+export { makeAudioBufferTask };

package/dist/elements/EFMedia/audioTasks/makeAudioFrequencyAnalysisTask.d.ts

@@ -0,0 +1,3 @@
+import { Task } from '@lit/task';
+import { EFMedia } from '../../EFMedia.js';
+export declare function makeAudioFrequencyAnalysisTask(element: EFMedia): Task<readonly [import('@lit/task').TaskStatus, number, number, number, number, boolean], Uint8Array | null>;

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

@@ -0,0 +1,138 @@
+import { EF_INTERACTIVE } from "../../../EF_INTERACTIVE.js";
+import { LRUCache } from "../../../utils/LRUCache.js";
+import { Task } from "@lit/task";
+const DECAY_WEIGHT = .8;
+function processFFTData(fftData, zeroThresholdPercent = .1) {
+	const totalBins = fftData.length;
+	const zeroThresholdCount = Math.floor(totalBins * zeroThresholdPercent);
+	let zeroCount = 0;
+	let cutoffIndex = totalBins;
+	for (let i = totalBins - 1; i >= 0; i--) if (fftData[i] ?? true) zeroCount++;
+	else if (zeroCount >= zeroThresholdCount) {
+		cutoffIndex = i + 1;
+		break;
+	}
+	if (cutoffIndex < zeroThresholdCount) return fftData;
+	const goodData = fftData.slice(0, cutoffIndex);
+	const resampledData = interpolateData(goodData, fftData.length);
+	const attenuationStartIndex = Math.floor(totalBins * .9);
+	for (let i = attenuationStartIndex; i < totalBins; i++) {
+		const attenuationProgress = (i - attenuationStartIndex) / (totalBins - attenuationStartIndex) + .2;
+		const attenuationFactor = Math.max(0, 1 - attenuationProgress);
+		resampledData[i] = Math.floor((resampledData[i] ?? 0) * attenuationFactor);
+	}
+	return resampledData;
+}
+function interpolateData(data, targetSize) {
+	const resampled = new Uint8Array(targetSize);
+	const dataLength = data.length;
+	for (let i = 0; i < targetSize; i++) {
+		const ratio = i / (targetSize - 1) * (dataLength - 1);
+		const index = Math.floor(ratio);
+		const fraction = ratio - index;
+		if (index >= dataLength - 1) resampled[i] = data[dataLength - 1] ?? 0;
+		else resampled[i] = Math.round((data[index] ?? 0) * (1 - fraction) + (data[index + 1] ?? 0) * fraction);
+	}
+	return resampled;
+}
+function makeAudioFrequencyAnalysisTask(element) {
+	const cache = new LRUCache(100);
+	return new Task(element, {
+		autoRun: EF_INTERACTIVE,
+		onError: (error) => {
+			console.error("frequencyDataTask error", error);
+		},
+		args: () => [
+			element.audioBufferTask.status,
+			element.currentSourceTimeMs,
+			element.fftSize,
+			element.fftDecay,
+			element.fftGain,
+			element.shouldInterpolateFrequencies
+		],
+		task: async () => {
+			await element.audioBufferTask.taskComplete;
+			if (!element.audioBufferTask.value) return null;
+			if (element.currentSourceTimeMs < 0) return null;
+			const currentTimeMs = element.currentSourceTimeMs;
+			const analysisWindowMs = 5e3;
+			const fromMs = Math.max(0, currentTimeMs);
+			const toMs = fromMs + analysisWindowMs;
+			const { fetchAudioSpanningTime: fetchAudioSpan } = await import("../shared/AudioSpanUtils.js");
+			const audioSpan = await fetchAudioSpan(element, fromMs, toMs, new AbortController().signal);
+			if (!audioSpan || !audioSpan.blob) {
+				console.warn("Frequency analysis skipped: no audio data available");
+				return null;
+			}
+			const tempAudioContext = new OfflineAudioContext(2, 48e3, 48e3);
+			const arrayBuffer = await audioSpan.blob.arrayBuffer();
+			const audioBuffer = await tempAudioContext.decodeAudioData(arrayBuffer);
+			const startOffsetMs = audioSpan.startMs;
+			const smoothedKey = `${element.shouldInterpolateFrequencies}:${element.fftSize}:${element.fftDecay}:${element.fftGain}:${startOffsetMs}:${currentTimeMs}`;
+			const cachedSmoothedData = cache.get(smoothedKey);
+			if (cachedSmoothedData) return cachedSmoothedData;
+			const framesData = await Promise.all(Array.from({ length: element.fftDecay }, async (_, i) => {
+				const frameOffset = i * (1e3 / 30);
+				const startTime = Math.max(0, (currentTimeMs - frameOffset - startOffsetMs) / 1e3);
+				const cacheKey = `${element.shouldInterpolateFrequencies}:${element.fftSize}:${element.fftGain}:${startOffsetMs}:${startTime}`;
+				const cachedFrame = cache.get(cacheKey);
+				if (cachedFrame) return cachedFrame;
+				const SIZE = 48e3 / 30;
+				let audioContext;
+				try {
+					audioContext = new OfflineAudioContext(2, SIZE, 48e3);
+				} catch (error) {
+					throw new Error(`[EFMedia.frequencyDataTask] Failed to create OfflineAudioContext(2, ${SIZE}, 48000) for frame ${i} at time ${startTime}s: ${error instanceof Error ? error.message : String(error)}. This is for audio frequency analysis.`);
+				}
+				const analyser = audioContext.createAnalyser();
+				analyser.fftSize = element.fftSize;
+				analyser.minDecibels = -90;
+				analyser.maxDecibels = -10;
+				const gainNode = audioContext.createGain();
+				gainNode.gain.value = element.fftGain;
+				const filter = audioContext.createBiquadFilter();
+				filter.type = "bandpass";
+				filter.frequency.value = 15e3;
+				filter.Q.value = .05;
+				const audioBufferSource = audioContext.createBufferSource();
+				audioBufferSource.buffer = audioBuffer;
+				audioBufferSource.connect(filter);
+				filter.connect(gainNode);
+				gainNode.connect(analyser);
+				analyser.connect(audioContext.destination);
+				audioBufferSource.start(0, startTime, 1 / 30);
+				try {
+					await audioContext.startRendering();
+					const frameData = new Uint8Array(element.fftSize / 2);
+					analyser.getByteFrequencyData(frameData);
+					cache.set(cacheKey, frameData);
+					return frameData;
+				} finally {
+					audioBufferSource.disconnect();
+					analyser.disconnect();
+				}
+			}));
+			const frameLength = framesData[0]?.length ?? 0;
+			const smoothedData = new Uint8Array(frameLength);
+			for (let i = 0; i < frameLength; i++) {
+				let weightedSum = 0;
+				let weightSum = 0;
+				framesData.forEach((frame, frameIndex) => {
+					const decayWeight = DECAY_WEIGHT ** frameIndex;
+					weightedSum += (frame[i] ?? 0) * decayWeight;
+					weightSum += decayWeight;
+				});
+				smoothedData[i] = Math.min(255, Math.round(weightedSum / weightSum));
+			}
+			smoothedData.forEach((value, i) => {
+				const freqWeight = element.FREQ_WEIGHTS[i] ?? 0;
+				smoothedData[i] = Math.min(255, Math.round(value * freqWeight));
+			});
+			const slicedData = smoothedData.slice(0, Math.floor(smoothedData.length / 2));
+			const processedData = element.shouldInterpolateFrequencies ? processFFTData(slicedData) : slicedData;
+			cache.set(smoothedKey, processedData);
+			return processedData;
+		}
+	});
+}
+export { makeAudioFrequencyAnalysisTask };

package/dist/elements/EFMedia/audioTasks/makeAudioInitSegmentFetchTask.browsertest.d.ts

@@ -0,0 +1,9 @@
+import { EFAudio } from '../../EFAudio';
+declare class TestMediaAudioInitSegmentFetch extends EFAudio {
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "test-media-audio-init-segment-fetch": TestMediaAudioInitSegmentFetch;
+    }
+}
+export {};

package/dist/elements/EFMedia/audioTasks/makeAudioInitSegmentFetchTask.d.ts

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

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

@@ -0,0 +1,16 @@
+import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask.js";
+import { Task } from "@lit/task";
+const makeAudioInitSegmentFetchTask = (host) => {
+	return new Task(host, {
+		args: () => [host.mediaEngineTask.value],
+		onError: (error) => {
+			console.error("audioInitSegmentFetchTask error", error);
+		},
+		onComplete: (_value) => {},
+		task: async ([_mediaEngine], { signal }) => {
+			const mediaEngine = await getLatestMediaEngine(host, signal);
+			return mediaEngine.fetchInitSegment(mediaEngine.getAudioRendition(), signal);
+		}
+	});
+};
+export { makeAudioInitSegmentFetchTask };

package/dist/elements/EFMedia/audioTasks/makeAudioInputTask.browsertest.d.ts

@@ -0,0 +1,9 @@
+import { EFAudio } from '../../EFAudio';
+declare class TestMediaAudioInput extends EFAudio {
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "test-media-audio-input": TestMediaAudioInput;
+    }
+}
+export {};

package/dist/elements/EFMedia/audioTasks/makeAudioInputTask.d.ts

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

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

@@ -0,0 +1,22 @@
+import { BufferedSeekingInput } from "../BufferedSeekingInput.js";
+import { EFMedia } from "../../EFMedia.js";
+import { Task } from "@lit/task";
+const makeAudioInputTask = (host) => {
+	return new Task(host, {
+		args: () => [host.audioInitSegmentFetchTask.value, host.audioSegmentFetchTask.value],
+		onError: (error) => {
+			console.error("audioInputTask error", error);
+		},
+		onComplete: (_value) => {},
+		task: async () => {
+			const initSegment = await host.audioInitSegmentFetchTask.taskComplete;
+			const segment = await host.audioSegmentFetchTask.taskComplete;
+			if (!initSegment || !segment) throw new Error("Init segment or segment is not available");
+			return new BufferedSeekingInput(await new Blob([initSegment, segment]).arrayBuffer(), {
+				videoBufferSize: EFMedia.VIDEO_SAMPLE_BUFFER_SIZE,
+				audioBufferSize: EFMedia.AUDIO_SAMPLE_BUFFER_SIZE
+			});
+		}
+	});
+};
+export { makeAudioInputTask };

package/dist/elements/EFMedia/audioTasks/makeAudioSeekTask.d.ts

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

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

@@ -0,0 +1,24 @@
+import { IgnorableError } from "../../EFMedia.js";
+import { Task } from "@lit/task";
+const makeAudioSeekTask = (host) => {
+	return new Task(host, {
+		args: () => [host.desiredSeekTimeMs, host.audioInputTask.value],
+		onError: (error) => {
+			if (error instanceof IgnorableError) console.info("audioSeekTask aborted");
+			console.error("audioSeekTask error", error);
+		},
+		onComplete: (_value) => {},
+		task: async (_) => {
+			await host.audioSegmentIdTask.taskComplete;
+			await host.audioSegmentFetchTask.taskComplete;
+			await host.audioInitSegmentFetchTask.taskComplete;
+			const audioInput = await host.audioInputTask.taskComplete;
+			if (!audioInput) throw new Error("Audio input is not available");
+			const audioTrack = await audioInput.getFirstAudioTrack();
+			if (!audioTrack) throw new Error("Audio track is not available");
+			const sample = await audioInput.seek(audioTrack.id, host.desiredSeekTimeMs);
+			return sample;
+		}
+	});
+};
+export { makeAudioSeekTask };

package/dist/elements/EFMedia/audioTasks/makeAudioSegmentFetchTask.d.ts

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

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

@@ -0,0 +1,18 @@
+import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask.js";
+import { Task } from "@lit/task";
+const makeAudioSegmentFetchTask = (host) => {
+	return new Task(host, {
+		args: () => [host.mediaEngineTask.value, host.audioSegmentIdTask.value],
+		onError: (error) => {
+			console.error("audioSegmentFetchTask error", error);
+		},
+		onComplete: (_value) => {},
+		task: async (_, { signal }) => {
+			const mediaEngine = await getLatestMediaEngine(host, signal);
+			const segmentId = await host.audioSegmentIdTask.taskComplete;
+			if (segmentId === void 0) throw new Error("Segment ID is not available");
+			return mediaEngine.fetchMediaSegment(segmentId, mediaEngine.getAudioRendition(), signal);
+		}
+	});
+};
+export { makeAudioSegmentFetchTask };

package/dist/elements/EFMedia/audioTasks/makeAudioSegmentIdTask.d.ts

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

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

@@ -0,0 +1,16 @@
+import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask.js";
+import { Task } from "@lit/task";
+const makeAudioSegmentIdTask = (host) => {
+	return new Task(host, {
+		args: () => [host.mediaEngineTask.value, host.desiredSeekTimeMs],
+		onError: (error) => {
+			console.error("audioSegmentIdTask error", error);
+		},
+		onComplete: (_value) => {},
+		task: async (_, { signal }) => {
+			const mediaEngine = await getLatestMediaEngine(host, signal);
+			return mediaEngine.computeSegmentId(host.desiredSeekTimeMs, mediaEngine.getAudioRendition());
+		}
+	});
+};
+export { makeAudioSegmentIdTask };

package/dist/elements/EFMedia/audioTasks/makeAudioTimeDomainAnalysisTask.d.ts

@@ -0,0 +1,3 @@
+import { Task } from '@lit/task';
+import { EFMedia } from '../../EFMedia.js';
+export declare function makeAudioTimeDomainAnalysisTask(element: EFMedia): Task<readonly [import('@lit/task').TaskStatus, number, number, number, number, boolean], Uint8Array | null>;