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

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

@@ -0,0 +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>;

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

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

package/dist/elements/EFMedia/videoTasks/makeVideoInputTask.browsertest.d.ts

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

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

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

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

@@ -0,0 +1,27 @@
+import { BufferedSeekingInput } from "../BufferedSeekingInput.js";
+import { EFMedia } from "../../EFMedia.js";
+import { Task } from "@lit/task";
+const makeVideoInputTask = (host) => {
+	return new Task(host, {
+		args: () => [host.videoInitSegmentFetchTask.value, host.videoSegmentFetchTask.value],
+		onError: (error) => {
+			console.error("videoInputTask error", error);
+		},
+		onComplete: (_value) => {},
+		task: async () => {
+			const initSegment = await host.videoInitSegmentFetchTask.taskComplete;
+			const segment = await host.videoSegmentFetchTask.taskComplete;
+			if (!initSegment || !segment) throw new Error("Init segment or segment is not available");
+			const mediaEngine = await host.mediaEngineTask.taskComplete;
+			const videoRendition = mediaEngine?.videoRendition;
+			const startTimeOffsetMs = videoRendition?.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 { makeVideoInputTask };

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

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

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

@@ -0,0 +1,34 @@
+import { IgnorableError } from "../../EFMedia.js";
+import { Task } from "@lit/task";
+const makeVideoSeekTask = (host) => {
+	return new Task(host, {
+		args: () => [host.desiredSeekTimeMs, host.videoInputTask.value],
+		onError: (error) => {
+			if (error instanceof IgnorableError) console.info("videoSeekTask aborted");
+			console.error("videoSeekTask error", error);
+		},
+		onComplete: (_value) => {},
+		task: async ([targetSeekTimeMs], { signal }) => {
+			await host.mediaEngineTask.taskComplete;
+			signal.throwIfAborted();
+			await host.videoSegmentIdTask.taskComplete;
+			signal.throwIfAborted();
+			await host.videoSegmentFetchTask.taskComplete;
+			signal.throwIfAborted();
+			await host.videoInitSegmentFetchTask.taskComplete;
+			signal.throwIfAborted();
+			const videoInput = await host.videoInputTask.taskComplete;
+			signal.throwIfAborted();
+			if (!videoInput) throw new Error("Video input is not available");
+			const videoTrack = await videoInput.getFirstVideoTrack();
+			if (!videoTrack) throw new Error("Video track is not available");
+			signal.throwIfAborted();
+			const sample = await videoInput.seek(videoTrack.id, targetSeekTimeMs);
+			signal.throwIfAborted();
+			if (sample === void 0 && signal.aborted) return void 0;
+			if (sample === void 0) throw new Error("Video seek failed to find sample");
+			return sample;
+		}
+	});
+};
+export { makeVideoSeekTask };

package/dist/elements/EFMedia/videoTasks/makeVideoSegmentFetchTask.browsertest.d.ts

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

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

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

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

@@ -0,0 +1,28 @@
+import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask.js";
+import { Task } from "@lit/task";
+const makeVideoSegmentFetchTask = (host) => {
+	return new Task(host, {
+		args: () => [host.mediaEngineTask.value, host.videoSegmentIdTask.value],
+		onError: (error) => {
+			console.error("videoSegmentFetchTask error", error);
+		},
+		onComplete: (_value) => {},
+		task: async (_, { signal }) => {
+			const mediaEngine = await getLatestMediaEngine(host, signal);
+			const segmentId = await host.videoSegmentIdTask.taskComplete;
+			if (segmentId === void 0) {
+				const rendition = mediaEngine.videoRendition;
+				const debugInfo = {
+					hasRendition: !!rendition,
+					segmentDurationMs: rendition?.segmentDurationMs,
+					segmentDurationsMs: rendition?.segmentDurationsMs?.length || 0,
+					desiredSeekTimeMs: host.desiredSeekTimeMs,
+					intrinsicDurationMs: host.intrinsicDurationMs
+				};
+				throw new Error(`Segment ID is not available for video. Debug info: ${JSON.stringify(debugInfo)}`);
+			}
+			return mediaEngine.fetchMediaSegment(segmentId, mediaEngine.getVideoRendition(), signal);
+		}
+	});
+};
+export { makeVideoSegmentFetchTask };

package/dist/elements/EFMedia/videoTasks/makeVideoSegmentIdTask.browsertest.d.ts

@@ -0,0 +1,9 @@
+import { EFVideo } from '../../EFVideo';
+declare class TestMediaVideoSegment extends EFVideo {
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "test-media-video-segment": TestMediaVideoSegment;
+    }
+}
+export {};

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

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

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

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

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

@@ -1,5 +1,6 @@
 import { EFMedia } from './EFMedia.js';
 declare class TestMedia extends EFMedia {
+    static styles: import('lit').CSSResult[];
 }
 declare global {
     interface HTMLElementTagNameMap {

package/dist/elements/EFMedia.d.ts

@@ -1,146 +1,98 @@
-import { TrackFragmentIndex, TrackSegment } from '../../../assets/src/index.ts';
-import { VideoAsset } from '../../../assets/src/EncodedAsset.ts';
-import { MP4File } from '../../../assets/src/MP4File.ts';
-import { Task } from '@lit/task';
 import { LitElement, PropertyValueMap } from 'lit';
-import { JitTranscodingClient } from '../JitTranscodingClient.js';
-import type * as MP4Box from "mp4box";
+import { AudioSpan } from '../transcoding/types/index.ts';
+import { UrlGenerator } from '../transcoding/utils/UrlGenerator.ts';
 declare global {
     var EF_FRAMEGEN: import("../EF_FRAMEGEN.js").EFFramegen;
 }
+export declare class IgnorableError extends Error {
+}
 export declare const deepGetMediaElements: (element: Element, medias?: EFMedia[]) => EFMedia[];
 declare const EFMedia_base: (new (...args: any[]) => import('./EFSourceMixin.js').EFSourceMixinInterface) & (new (...args: any[]) => import('./EFTemporal.js').TemporalMixinInterface) & (new (...args: any[]) => import('./FetchMixin.js').FetchMixinInterface) & typeof LitElement;
 export declare class EFMedia extends EFMedia_base {
-    #private;
+    static readonly VIDEO_SAMPLE_BUFFER_SIZE = 30;
+    static readonly AUDIO_SAMPLE_BUFFER_SIZE = 120;
+    static get observedAttributes(): string[];
     static styles: import('lit').CSSResult[];
     currentTimeMs: number;
     /**
-     * Media loading mode - determines how content is loaded and processed
-     * - "asset": Use existing asset-based loading (assetId or fragment-based URLs)
-     * - "jit-transcode": Use JIT transcoding for remote URLs
-     * - "auto": Automatically detect based on URL patterns (default)
+     * Duration in milliseconds for audio buffering ahead of current time
+     * @domAttribute "audio-buffer-duration"
+     */
+    audioBufferDurationMs: number;
+    /**
+     * Maximum number of concurrent audio segment fetches for buffering
+     * @domAttribute "max-audio-buffer-fetches"
      */
-    private _mode;
+    maxAudioBufferFetches: number;
     /**
-     * Get the mode, prioritizing attribute values over property values
+     * Enable/disable audio buffering system
+     * @domAttribute "enable-audio-buffering"
      */
-    get mode(): "asset" | "jit-transcode" | "auto";
-    set mode(value: "asset" | "jit-transcode" | "auto");
-    connectedCallback(): void;
+    enableAudioBuffering: boolean;
     /**
-     * Configuration for JIT transcoding performance optimizations
+     * Mute/unmute the media element
+     * @domAttribute "mute"
      */
-    prefetchSegments: number;
-    cacheSize: number;
-    enablePrefetch: boolean;
+    mute: boolean;
     /**
-     * Loading states for JIT transcoding
+     * FFT size for frequency analysis
+     * @domAttribute "fft-size"
      */
-    jitLoadingState: "idle" | "metadata" | "segments" | "error";
-    jitErrorMessage: string | null;
-    jitCacheStats: {
-        size: number;
-        hitRate: number;
-        efficiency: number;
-    } | null;
+    fftSize: number;
     /**
-     * Detected loading mode based on URL patterns and manual override
+     * FFT decay rate for frequency analysis
+     * @domAttribute "fft-decay"
      */
-    get effectiveMode(): "asset" | "jit-transcode";
-    jitClientTask: Task<readonly [string | undefined, number, boolean, number], JitTranscodingClient>;
+    fftDecay: number;
     /**
-     * JIT transcoding metadata loader
-     * Loads video metadata for JIT transcoded content
+     * FFT gain for frequency analysis
+     * @domAttribute "fft-gain"
      */
-    jitMetadataLoader: Task<readonly [string, JitTranscodingClient | undefined], import('../JitTranscodingClient.js').VideoMetadata | null>;
+    fftGain: number;
+    /**
+     * Enable/disable frequency interpolation
+     * @domAttribute "interpolate-frequencies"
+     */
+    interpolateFrequencies: boolean;
+    get FREQ_WEIGHTS(): Float32Array;
+    get shouldInterpolateFrequencies(): boolean;
+    get urlGenerator(): UrlGenerator;
+    mediaEngineTask: import('@lit/task').Task<readonly [string, string | null], import('../transcoding/types/index.ts').MediaEngine>;
+    audioSegmentIdTask: import('@lit/task').Task<readonly [import('../transcoding/types/index.ts').MediaEngine | undefined, number], number | undefined>;
+    audioInitSegmentFetchTask: import('@lit/task').Task<readonly [import('../transcoding/types/index.ts').MediaEngine | undefined], ArrayBuffer>;
+    audioSegmentFetchTask: import('@lit/task').Task<readonly [import('../transcoding/types/index.ts').MediaEngine | undefined, number | undefined], ArrayBuffer>;
+    audioInputTask: import('./EFMedia/shared/MediaTaskUtils.ts').InputTask;
+    audioSeekTask: import('@lit/task').Task<readonly [number, import('./EFMedia/BufferedSeekingInput.ts').BufferedSeekingInput | undefined], import('mediabunny').VideoSample | undefined>;
+    audioBufferTask: import('@lit/task').Task<readonly [number], import('./EFMedia/audioTasks/makeAudioBufferTask.ts').AudioBufferState>;
+    byteTimeDomainTask: import('@lit/task').Task<readonly [import('@lit/task').TaskStatus, number, number, number, number, boolean], Uint8Array | null>;
+    frequencyDataTask: import('@lit/task').Task<readonly [import('@lit/task').TaskStatus, number, number, number, number, boolean], Uint8Array | null>;
     /**
      * The unique identifier for the media asset.
      * This property can be set programmatically or via the "asset-id" attribute.
      * @domAttribute "asset-id"
      */
-    set assetId(value: string | null);
-    get assetId(): string | null;
-    fragmentIndexPath(): string;
-    fragmentTrackPath(trackId: string): string;
-    get mediaDurationTask(): Task<readonly [Record<number, TrackFragmentIndex> | null | undefined, import('../JitTranscodingClient.js').VideoMetadata | null | undefined], Record<number, TrackFragmentIndex> | null>;
-    get defaultVideoTrackId(): number | undefined;
-    get defaultAudioTrackId(): number | undefined;
+    assetId: string | null;
     get intrinsicDurationMs(): number;
-    audioBufferTask: Task<readonly [Record<string, File> | null | undefined, Record<string, {
-        segment: TrackSegment;
-        track: MP4Box.TrackInfo;
-        nextSegment?: TrackSegment;
-    }> | null | undefined], {
-        buffer: AudioBuffer;
-        startOffsetMs: number;
-    } | undefined>;
-    fetchAudioSpanningTime(fromMs: number, toMs: number): Promise<{
-        blob: Blob;
-        startMs: number;
-        endMs: number;
-    } | undefined>;
-    /**
-     * Encode an AudioBuffer to a WAV blob
-     */
-    private encodeWAVBuffer;
-    set fftSize(value: number);
-    set fftDecay(value: number);
-    get fftSize(): number;
-    get fftDecay(): number;
-    set interpolateFrequencies(value: boolean);
-    get interpolateFrequencies(): boolean;
-    get shouldInterpolateFrequencies(): boolean;
-    private static readonly DECAY_WEIGHT;
-    get FREQ_WEIGHTS(): Float32Array;
-    byteTimeDomainTask: Task<readonly [import('@lit/task').TaskStatus, number, number, number, number, boolean], Uint8Array | null>;
-    frequencyDataTask: Task<readonly [import('@lit/task').TaskStatus, number, number, number, number, boolean], Uint8Array | null>;
-    set fftGain(value: number);
-    get fftGain(): number;
-    private synthesizeFragmentIndex;
-    private calculateAssetSegmentKeys;
-    private calculateJitSegmentKeys;
-    private calculateAssetSeekResult;
-    private calculateJitSeekResult;
-    private createTrackInfo;
     protected updated(changedProperties: PropertyValueMap<any> | Map<PropertyKey, unknown>): void;
     get hasOwnDuration(): boolean;
-    videoAssetTask: Task<readonly ["asset" | "jit-transcode", Record<string, File> | null | undefined], VideoAsset | undefined>;
     private _desiredSeekTimeMs;
     get desiredSeekTimeMs(): number;
     set desiredSeekTimeMs(value: number);
     protected executeSeek(seekToMs: number): Promise<void>;
-    assetIndexLoader: Task<readonly [string | null, typeof fetch], Record<number, TrackFragmentIndex> | null>;
-    assetSegmentKeysTask: Task<readonly [Record<number, TrackFragmentIndex> | null | undefined, number], Record<string, {
-        startTimeMs: number;
-        trackId: string;
-    }> | null>;
-    assetInitSegmentsTask: Task<readonly [Record<number, TrackFragmentIndex> | null | undefined, typeof fetch], {
-        trackId: string;
-        buffer: MP4Box.MP4ArrayBuffer;
-        mp4File: MP4File;
-    }[] | null>;
-    assetSegmentLoader: Task<readonly [Record<number, TrackFragmentIndex> | null | undefined, Record<string, {
-        startTimeMs: number;
-        trackId: string;
-    }> | null | undefined, {
-        trackId: string;
-        buffer: MP4Box.MP4ArrayBuffer;
-        mp4File: MP4File;
-    }[] | null | undefined, typeof fetch], Record<string, File> | null>;
-    jitSegmentKeysTask: Task<readonly [import('../JitTranscodingClient.js').VideoMetadata | null | undefined, number], Record<string, {
-        startTimeMs: number;
-        trackId: string;
-    }> | null>;
-    jitSegmentLoader: Task<readonly [string, Record<string, {
-        startTimeMs: number;
-        trackId: string;
-    }> | null | undefined, import('../JitTranscodingClient.js').VideoMetadata | null | undefined], Record<string, File> | null>;
-    fragmentIndexTask: Task<readonly [Record<number, TrackFragmentIndex> | null | undefined, import('../JitTranscodingClient.js').VideoMetadata | null | undefined], Record<number, TrackFragmentIndex> | null>;
-    mediaSegmentsTask: Task<readonly [Record<string, File> | null | undefined, Record<string, File> | null | undefined], Record<string, File> | null>;
-    seekTask: Task<readonly [Record<number, TrackFragmentIndex> | null | undefined, Record<string, File> | null | undefined, number], Record<string, {
-        segment: TrackSegment;
-        track: MP4Box.TrackInfo;
-        nextSegment?: TrackSegment;
-    }> | null>;
+    /**
+     * Main integration method for EFTimegroup audio playback
+     * Now powered by clean, testable utility functions
+     */
+    fetchAudioSpanningTime(fromMs: number, toMs: number, signal?: AbortSignal): Promise<AudioSpan>;
+    /**
+     * Check if an audio segment is cached in the unified buffer system
+     * Now uses the same caching approach as video for consistency
+     */
+    getCachedAudioSegment(segmentId: number): boolean;
+    /**
+     * Get cached audio segments from the unified buffer system
+     * Now uses the same caching approach as video for consistency
+     */
+    getCachedAudioSegments(segmentIds: number[]): Set<number>;
 }
 export {};