@editframe/assets 0.18.3-beta.0 → 0.18.7-beta.0

package/dist/EncodedAsset.js

@@ -1,443 +0,0 @@
-import { MP4File } from "./MP4File.js";
-import { memoize } from "./memoize.js";
-import { FrameBuffer } from "./FrameBuffer.js";
-import { SeekStrategy } from "./SeekStrategy.js";
-import { MP4SampleAnalyzer } from "./MP4SampleAnalyzer.js";
-import { DecoderManager } from "./DecoderManager.js";
-import debug from "debug";
-import _decorate from "@oxc-project/runtime/helpers/decorate";
-const log = debug("ef:av");
-const BUFFER_SIZE = 30;
-var AssetNotAvailableLocally = class extends Error {};
-var FileAsset = class {
-	constructor(localName, file) {
-		this.localName = localName;
-		this.file = file;
-	}
-	async arrayBuffer() {
-		return this.file.arrayBuffer();
-	}
-	get byteSize() {
-		return this.file.size;
-	}
-	get fileExtension() {
-		return this.file.name.split(".").pop();
-	}
-	slice(start, end) {
-		return this.file.slice(start, end);
-	}
-};
-var ISOFileAsset = class extends FileAsset {
-	constructor(localName, file, mp4boxFile) {
-		super(localName, file);
-		this.localName = localName;
-		this.file = file;
-		this.mp4boxFile = mp4boxFile;
-	}
-	get fileInfo() {
-		return this.mp4boxFile.getInfo();
-	}
-	get containerFormat() {
-		return "mp4";
-	}
-};
-_decorate([memoize], ISOFileAsset.prototype, "fileInfo", null);
-var VideoAsset = class VideoAsset extends ISOFileAsset {
-	static async createFromReadableStream(id, stream, file, options = {}) {
-		let fileStart = 0;
-		const inputFile = new MP4File();
-		const reader = stream.getReader();
-		const processChunk = ({ done, value }) => {
-			if (done) return;
-			if (!value) return;
-			const mp4buffer = value.buffer;
-			mp4buffer.fileStart = fileStart;
-			const isLast = file.size === fileStart + value.byteLength;
-			inputFile.appendBuffer(mp4buffer, isLast);
-			fileStart += value.byteLength;
-			return reader.read().then(processChunk);
-		};
-		await reader.read().then(processChunk);
-		const asset = new VideoAsset(id, inputFile, file);
-		asset.startTimeOffsetMs = options.startTimeOffsetMs;
-		return asset;
-	}
-	/**
-	* Creates a VideoAsset from a complete MP4 file (like JIT transcoded segments).
-	* 
-	* This is used for JIT transcoded segments which are complete MP4 files that always
-	* start on keyframes, unlike fragmented MP4s used in the asset pipeline.
-	*/
-	static async createFromCompleteMP4(id, file, options = {}) {
-		const fileBuffer = await file.arrayBuffer();
-		const inputFile = new MP4File();
-		const mp4buffer = fileBuffer;
-		mp4buffer.fileStart = 0;
-		inputFile.appendBuffer(mp4buffer, true);
-		inputFile.flush();
-		await inputFile.readyPromise;
-		const asset = new VideoAsset(id, inputFile, file);
-		asset.isJitSegment = true;
-		asset.startTimeOffsetMs = options.startTimeOffsetMs;
-		return asset;
-	}
-	/**
-	* **Only use this function in tests to reset a VideoAsset to its initial state.**
-	*
-	* @deprecated
-	*/
-	async TEST_ONLY_RESET() {
-		if (this.decoderManager.state !== "closed") await this.decoderManager.flush();
-		this.decoderManager.configureDecoder();
-		this.requestedSampleNumber = 0;
-		this.outCursor = 0;
-		this.sampleCursor = 0;
-		this.frameBuffer.clear();
-		this.lastDecodedSample = void 0;
-		this.lastSoughtFrame?.close();
-		this.lastSoughtFrame = void 0;
-	}
-	addEventListener(type, callback) {
-		this.eventListeners[type] ||= /* @__PURE__ */ new Set();
-		this.eventListeners[type]?.add(callback);
-	}
-	removeEventListener(type, callback) {
-		this.eventListeners[type]?.delete(callback);
-	}
-	emit(type, ...args) {
-		for (const listener of this.eventListeners[type] ?? []) listener(...args);
-	}
-	constructor(localName, mp4boxFile, file) {
-		super(localName, file, mp4boxFile);
-		this.requestedSampleNumber = 0;
-		this.outCursor = 0;
-		this.sampleCursor = 0;
-		this.latestSeekCts = 0;
-		this.isJitSegment = false;
-		this.isBeingReplaced = false;
-		this.eventListeners = {};
-		this.frameBuffer = new FrameBuffer(BUFFER_SIZE);
-		this.sampleAnalyzer = new MP4SampleAnalyzer(mp4boxFile, this.defaultVideoTrack);
-		this.seekStrategy = new SeekStrategy();
-		this.decoderManager = new DecoderManager(mp4boxFile, this.defaultVideoTrack, (decodedFrame) => {
-			const clone = decodedFrame.clone();
-			this.frameBuffer.add(clone);
-			decodedFrame.close();
-			this.outCursor = this.samples.findIndex((sample) => sample.cts === decodedFrame.timestamp);
-			this.emit("frame", clone);
-		}, (e) => {
-			console.error("Video Decoder Error", e);
-			throw e;
-		});
-		this.decoderManager.configureDecoder();
-	}
-	get videoDecoder() {
-		return this.decoderManager.videoDecoder;
-	}
-	get decodedFrames() {
-		return this.frameBuffer.frames;
-	}
-	set decodedFrames(frames) {
-		this.frameBuffer.clear();
-		frames.forEach((frame) => this.frameBuffer.add(frame));
-	}
-	get videoCodec() {
-		if (!this.defaultVideoTrack) throw new Error("No default video track found");
-		return this.defaultVideoTrack?.codec;
-	}
-	get fragmentInfo() {
-		const fragments = [];
-		const [first, ...samples] = this.samples;
-		if (!first) return fragments;
-		let currentFragment = {
-			offset: first.offset,
-			size: first.size,
-			start_ms: first.cts,
-			duration_ms: 0
-		};
-		for (const sample of samples) if (sample.is_sync) {
-			if (currentFragment) {
-				currentFragment.duration_ms = sample.cts - currentFragment.start_ms;
-				fragments.push(currentFragment);
-			}
-			currentFragment = {
-				offset: sample.offset,
-				size: sample.size,
-				start_ms: sample.cts,
-				duration_ms: 0
-			};
-		} else currentFragment.size += sample.size;
-		return fragments;
-	}
-	pruneBuffer() {}
-	get editsOffset() {
-		return this.sampleAnalyzer.editsOffset;
-	}
-	async waitUntilVideoQueueDrained() {
-		return this.decoderManager.waitUntilVideoQueueDrained();
-	}
-	get canDecodeNextSample() {
-		return this.sampleCursor < this.samples.length;
-	}
-	async decodeNextSample() {
-		if (!this.canDecodeNextSample) throw new Error("No more samples to decode");
-		await this.decodeSlice(this.sampleCursor, this.sampleCursor);
-		this.sampleCursor++;
-	}
-	async decodeSlice(start, end) {
-		const samples = this.samples.slice(start, end + 1);
-		const firstSample = samples[0];
-		const lastSample = samples[samples.length - 1];
-		if (!firstSample || !lastSample) throw new Error("Samples not found");
-		const sliceStart = firstSample.offset;
-		const sliceEnd = lastSample.offset + lastSample.size;
-		const buffer = await this.file.slice(sliceStart, sliceEnd).arrayBuffer();
-		const firstSampleOffset = firstSample.offset;
-		for (let i = start; i <= end; i++) {
-			await this.waitUntilVideoQueueDrained();
-			const sample = this.getSample(i);
-			log("Decoding sample #", i, `cts=${sample.cts}`);
-			const sampleStart = sample.offset - firstSampleOffset;
-			const sampleEnd = sample.offset + sample.size - firstSampleOffset;
-			const chunk = new EncodedVideoChunk({
-				data: buffer.slice(sampleStart, sampleEnd),
-				timestamp: sample.cts,
-				duration: sample.duration,
-				type: sample.is_sync ? "key" : "delta"
-			});
-			this.decoderManager.decode(chunk);
-			const nextSample = this.defaultVideoTrak?.samples?.[i + 1];
-			if (nextSample === void 0) {
-				log("ENDFLUSH");
-				await this.decoderManager.flush();
-			}
-		}
-	}
-	get decoderConfiguration() {
-		return this.decoderManager.decoderConfiguration;
-	}
-	configureDecoder() {
-		this.decoderManager.configureDecoder();
-	}
-	getSample(index = -1) {
-		return this.sampleAnalyzer.getSample(index);
-	}
-	get timescale() {
-		return this.sampleAnalyzer.timescale;
-	}
-	get samples() {
-		return this.sampleAnalyzer.samples;
-	}
-	get displayOrderedSamples() {
-		return this.sampleAnalyzer.displayOrderedSamples;
-	}
-	getSampleClosetToTime(seconds) {
-		return this.sampleAnalyzer.getSampleClosetToTime(seconds);
-	}
-	seekingWillEmitNewFrame(seconds) {
-		if (!this.lastSoughtFrame) return true;
-		if (this.seekingWillGoBackwards(seconds)) return true;
-		const nextCts = this.getSampleClosetToTime(seconds).cts;
-		return nextCts > this.lastSoughtFrame.timestamp;
-	}
-	seekingWillSkipPictureGroup(seconds) {
-		const targetSample = this.getSampleClosetToTime(seconds);
-		const state = {
-			sampleCursor: this.sampleCursor,
-			outCursor: this.outCursor,
-			frameBuffer: this.frameBuffer
-		};
-		return this.seekStrategy.seekingWillSkipPictureGroup(state, targetSample, this.samples);
-	}
-	seekingWillGoBackwards(seconds) {
-		const targetSample = this.getSampleClosetToTime(seconds);
-		const state = {
-			sampleCursor: this.sampleCursor,
-			outCursor: this.outCursor,
-			frameBuffer: this.frameBuffer
-		};
-		return this.seekStrategy.seekingWillGoBackwards(state, targetSample, this.displayOrderedSamples);
-	}
-	/**
-	* Optimized flush decision for JIT segments that always start on keyframes.
-	* JIT segments have better keyframe distribution and shorter duration,
-	* so we can be less aggressive about flushing.
-	*/
-	shouldFlushForJitSegment(seconds, _shouldFlushPictureGroup, shouldFlushBackwards) {
-		if (shouldFlushBackwards) {
-			const targetSample = this.getSampleClosetToTime(seconds);
-			const targetInCache = this.frameBuffer.findByTimestamp(targetSample.cts);
-			if (!targetInCache) {
-				const currentPosition = this.outCursor;
-				const targetPosition = this.samples.findIndex((s) => s.cts === targetSample.cts);
-				const jumpDistance = currentPosition - targetPosition;
-				if (jumpDistance > 10) return true;
-				return false;
-			}
-		}
-		return false;
-	}
-	/**
-	* Finds the optimal sample cursor position for segments with keyframes.
-	* Uses optimal keyframe selection for both single and multi-keyframe segments.
-	*/
-	findOptimalSampleCursorForJitSeek(targetSample) {
-		let syncSampleNumber = targetSample.number;
-		while (!this.getSample(syncSampleNumber).is_sync) {
-			syncSampleNumber--;
-			if (syncSampleNumber < 0) throw new Error("No sync sample found when traversing backwards");
-		}
-		return syncSampleNumber;
-	}
-	/**
-	* Marks this VideoAsset as being replaced, which will abort any ongoing seek operations
-	*/
-	markAsBeingReplaced() {
-		this.isBeingReplaced = true;
-		if (this.activeSeekAbortController) this.activeSeekAbortController.abort("VideoAsset being replaced");
-	}
-	async seekToTime(seconds) {
-		seconds += (this.startTimeOffsetMs ?? 0) / 1e3;
-		const correctedSeconds = seconds;
-		this.activeSeekAbortController = new AbortController();
-		const abortSignal = this.activeSeekAbortController.signal;
-		if (this.isBeingReplaced) throw new Error("VideoAsset seek aborted - VideoAsset being replaced");
-		const sample = this.getSampleClosetToTime(correctedSeconds);
-		const cts = sample.cts;
-		this.latestSeekCts = cts;
-		const alreadyDecodedFrame = this.frameBuffer.findByTimestamp(cts);
-		if (alreadyDecodedFrame) return alreadyDecodedFrame;
-		const shouldFlushPictureGroup = this.seekingWillSkipPictureGroup(seconds);
-		const shouldFlushBackwards = this.seekingWillGoBackwards(seconds);
-		const shouldFlush = this.isJitSegment ? this.shouldFlushForJitSegment(seconds, shouldFlushPictureGroup, shouldFlushBackwards) : shouldFlushPictureGroup || shouldFlushBackwards;
-		if (shouldFlush) {
-			if (this.isBeingReplaced) throw new Error("VideoAsset seek aborted - VideoAsset being replaced");
-			if (this.decoderManager.state === "closed") throw new Error("VideoAsset decoder closed - recreation in progress");
-			try {
-				await this.decoderManager.flush();
-			} catch (error) {
-				if (error instanceof Error && error.name === "InvalidStateError" && error.message.includes("closed codec")) throw new Error("VideoAsset decoder closed during flush - recreation in progress");
-				throw error;
-			}
-			this.sampleCursor = this.findOptimalSampleCursorForJitSeek(sample);
-		}
-		let frame;
-		const maybeFrame = (_frame) => {
-			if (frame) return;
-			log("Maybe frame", _frame.timestamp, cts);
-			if (_frame.timestamp === cts) {
-				this.removeEventListener("frame", maybeFrame);
-				frame = _frame;
-			}
-		};
-		this.addEventListener("frame", maybeFrame);
-		while (frame === void 0 && this.canDecodeNextSample) {
-			if (abortSignal.aborted) {
-				this.removeEventListener("frame", maybeFrame);
-				throw new Error("VideoAsset seek aborted - VideoAsset being replaced");
-			}
-			if (this.isBeingReplaced) {
-				this.removeEventListener("frame", maybeFrame);
-				throw new Error("VideoAsset seek aborted - VideoAsset being replaced");
-			}
-			if (this.decoderManager.state === "closed") {
-				this.removeEventListener("frame", maybeFrame);
-				throw new Error("VideoAsset decoder closed during seek - recreation in progress");
-			}
-			try {
-				await this.decodeNextSample();
-			} catch (error) {
-				if (error instanceof Error && error.name === "InvalidStateError" && error.message.includes("closed codec")) {
-					console.log("🎬 VideoAsset: Decoder was closed during decode - VideoAsset being replaced");
-					this.removeEventListener("frame", maybeFrame);
-					throw new Error("VideoAsset decoder closed during decode - recreation in progress");
-				}
-				throw error;
-			}
-		}
-		this.removeEventListener("frame", maybeFrame);
-		this.activeSeekAbortController = void 0;
-		if (frame) {
-			if (this.lastSoughtFrame && !this.frameBuffer.frames.includes(this.lastSoughtFrame)) try {
-				this.lastSoughtFrame.close();
-			} catch (error) {}
-			this.lastSoughtFrame = frame;
-		}
-		return frame;
-	}
-	get defaultVideoTrack() {
-		return this.fileInfo.videoTracks?.[0];
-	}
-	get defaultVideoTrak() {
-		return this.mp4boxFile.getTrackById(this.defaultVideoTrack?.id ?? -1);
-	}
-	get duration() {
-		return this.fileInfo.duration / this.fileInfo.timescale;
-	}
-};
-_decorate([memoize], VideoAsset.prototype, "editsOffset", null);
-_decorate([memoize], VideoAsset.prototype, "timescale", null);
-_decorate([memoize], VideoAsset.prototype, "samples", null);
-_decorate([memoize], VideoAsset.prototype, "displayOrderedSamples", null);
-_decorate([memoize], VideoAsset.prototype, "defaultVideoTrack", null);
-_decorate([memoize], VideoAsset.prototype, "defaultVideoTrak", null);
-_decorate([memoize], VideoAsset.prototype, "duration", null);
-var AudioAsset = class AudioAsset extends ISOFileAsset {
-	static async createFromReadableStream(id, stream, file) {
-		let fileStart = 0;
-		const inputFile = new MP4File();
-		const reader = stream.getReader();
-		const processChunk = ({ done, value }) => {
-			if (done) return;
-			if (!value) return;
-			const mp4buffer = value.buffer;
-			mp4buffer.fileStart = fileStart;
-			fileStart += value.byteLength;
-			inputFile.appendBuffer(mp4buffer);
-			return reader.read().then(processChunk);
-		};
-		await reader.read().then(processChunk);
-		return new AudioAsset(id, file, inputFile);
-	}
-	get defaultAudioTrack() {
-		return this.fileInfo.audioTracks[0];
-	}
-	get defaultAudioTrak() {
-		return this.mp4boxFile.getTrackById(this.defaultAudioTrack?.id ?? -1);
-	}
-	get audioCodec() {
-		if (!this.defaultAudioTrack) throw new Error("No default audio track found");
-		return this.defaultAudioTrack.codec;
-	}
-	get samplerate() {
-		if (!this.defaultAudioTrack) throw new Error("No default audio track found");
-		return this.defaultAudioTrack.audio.sample_rate;
-	}
-	get channelCount() {
-		if (!this.defaultAudioTrack) throw new Error("No default audio track found");
-		return this.defaultAudioTrack.audio.channel_count;
-	}
-};
-_decorate([memoize], AudioAsset.prototype, "defaultAudioTrack", null);
-_decorate([memoize], AudioAsset.prototype, "defaultAudioTrak", null);
-_decorate([memoize], AudioAsset.prototype, "audioCodec", null);
-_decorate([memoize], AudioAsset.prototype, "samplerate", null);
-_decorate([memoize], AudioAsset.prototype, "channelCount", null);
-var ImageAsset = class ImageAsset extends FileAsset {
-	static async createFromReadableStream(id, file) {
-		if (file.size === 0) throw new AssetNotAvailableLocally();
-		return new ImageAsset(id, file);
-	}
-	get objectUrl() {
-		return URL.createObjectURL(this.file);
-	}
-	get format() {
-		return this.fileExtension;
-	}
-	get type() {
-		return `image/${this.format}`;
-	}
-};
-_decorate([memoize], ImageAsset.prototype, "objectUrl", null);
-_decorate([memoize], ImageAsset.prototype, "format", null);
-export { AssetNotAvailableLocally, AudioAsset, FileAsset, ISOFileAsset, ImageAsset, VideoAsset };

package/dist/FrameBuffer.d.ts

@@ -1,62 +0,0 @@
-/**
- * FrameBuffer manages a collection of decoded VideoFrames with automatic LRU eviction.
- *
- * This class extracts the frame buffering logic from VideoAsset to improve
- * testability and separation of concerns while maintaining the exact same
- * memory management behavior.
- */
-export declare class FrameBuffer {
-    private _frames;
-    private readonly _maxSize;
-    /**
-     * Creates a new FrameBuffer with the specified maximum size.
-     *
-     * @param maxSize Maximum number of frames to keep in buffer (default: 30)
-     */
-    constructor(maxSize?: number);
-    /**
-     * Gets the maximum size of the buffer.
-     */
-    get maxSize(): number;
-    /**
-     * Gets the current number of frames in the buffer.
-     */
-    get size(): number;
-    /**
-     * Gets a copy of the frames array for compatibility.
-     * Note: Returns a shallow copy to prevent external modification while allowing access.
-     */
-    get frames(): VideoFrame[];
-    /**
-     * Adds a frame to the buffer. If the buffer exceeds maxSize after adding,
-     * the oldest frames will be automatically pruned and closed.
-     *
-     * @param frame The VideoFrame to add to the buffer
-     */
-    add(frame: VideoFrame): void;
-    /**
-     * Finds a frame in the buffer by its timestamp.
-     *
-     * @param timestamp The timestamp to search for
-     * @returns The VideoFrame with matching timestamp, or undefined if not found
-     */
-    findByTimestamp(timestamp: number): VideoFrame | undefined;
-    /**
-     * Checks if the buffer contains the specified frame instance.
-     *
-     * @param frame The VideoFrame instance to check for
-     * @returns true if the frame is in the buffer, false otherwise
-     */
-    includes(frame: VideoFrame): boolean;
-    /**
-     * Removes all frames from the buffer and closes them to free memory.
-     * This method is safe to call even if some frames are already closed.
-     */
-    clear(): void;
-    /**
-     * Prunes the buffer to the maximum size by removing and closing the oldest frames.
-     * This maintains the LRU (Least Recently Used) eviction policy where oldest
-     * frames are removed first.
-     */
-    pruneToSize(): void;
-}

package/dist/FrameBuffer.js

@@ -1,89 +0,0 @@
-/**
-* FrameBuffer manages a collection of decoded VideoFrames with automatic LRU eviction.
-* 
-* This class extracts the frame buffering logic from VideoAsset to improve 
-* testability and separation of concerns while maintaining the exact same
-* memory management behavior.
-*/
-var FrameBuffer = class {
-	/**
-	* Creates a new FrameBuffer with the specified maximum size.
-	* 
-	* @param maxSize Maximum number of frames to keep in buffer (default: 30)
-	*/
-	constructor(maxSize = 30) {
-		this._frames = [];
-		this._maxSize = maxSize;
-	}
-	/**
-	* Gets the maximum size of the buffer.
-	*/
-	get maxSize() {
-		return this._maxSize;
-	}
-	/**
-	* Gets the current number of frames in the buffer.
-	*/
-	get size() {
-		return this._frames.length;
-	}
-	/**
-	* Gets a copy of the frames array for compatibility.
-	* Note: Returns a shallow copy to prevent external modification while allowing access.
-	*/
-	get frames() {
-		return [...this._frames];
-	}
-	/**
-	* Adds a frame to the buffer. If the buffer exceeds maxSize after adding,
-	* the oldest frames will be automatically pruned and closed.
-	* 
-	* @param frame The VideoFrame to add to the buffer
-	*/
-	add(frame) {
-		this._frames.push(frame);
-		this.pruneToSize();
-	}
-	/**
-	* Finds a frame in the buffer by its timestamp.
-	* 
-	* @param timestamp The timestamp to search for
-	* @returns The VideoFrame with matching timestamp, or undefined if not found
-	*/
-	findByTimestamp(timestamp) {
-		return this._frames.find((frame) => frame.timestamp === timestamp);
-	}
-	/**
-	* Checks if the buffer contains the specified frame instance.
-	* 
-	* @param frame The VideoFrame instance to check for
-	* @returns true if the frame is in the buffer, false otherwise
-	*/
-	includes(frame) {
-		return this._frames.includes(frame);
-	}
-	/**
-	* Removes all frames from the buffer and closes them to free memory.
-	* This method is safe to call even if some frames are already closed.
-	*/
-	clear() {
-		for (const frame of this._frames) try {
-			frame.close();
-		} catch (error) {}
-		this._frames = [];
-	}
-	/**
-	* Prunes the buffer to the maximum size by removing and closing the oldest frames.
-	* This maintains the LRU (Least Recently Used) eviction policy where oldest
-	* frames are removed first.
-	*/
-	pruneToSize() {
-		while (this._frames.length > this._maxSize) {
-			const oldestFrame = this._frames.shift();
-			if (oldestFrame) try {
-				oldestFrame.close();
-			} catch (error) {}
-		}
-	}
-};
-export { FrameBuffer };

package/dist/MP4File.d.ts

@@ -1,37 +0,0 @@
-import * as MP4Box from "mp4box";
-export interface MP4FileOptions {
-    readyTimeoutMs?: number;
-    sampleWaitTimeoutMs?: number;
-}
-export declare class MP4File extends MP4Box.ISOFile {
-    private timeoutId?;
-    private readonly readyTimeoutMs;
-    private readonly sampleWaitTimeoutMs;
-    readonly readyPromise: Promise<void>;
-    constructor(options?: MP4FileOptions);
-    setSegmentOptions(id: number, user: any, options: MP4Box.SegmentOptions): void;
-    /**
-     * Fragments all tracks in a file into separate array buffers.
-     */
-    fragmentAllTracks(): Promise<Record<number, ArrayBuffer[]>>;
-    fragmentIterator(): AsyncGenerator<{
-        track: number;
-        segment: "init";
-        data: ArrayBuffer;
-        cts?: undefined;
-        dts?: undefined;
-        duration?: undefined;
-    } | {
-        track: number;
-        segment: number;
-        data: ArrayBuffer;
-        cts: number;
-        dts: number;
-        duration: number;
-    }, void, unknown>;
-    waitingForSamples: Array<(last: boolean) => void>;
-    _hasSeenLastSamples: boolean;
-    waitForMoreSamples(): Promise<boolean>;
-    processSamples(last: boolean): void;
-    _arrayBufferFileStart: number;
-}