@editframe/assets 0.16.7-beta.0 → 0.17.6-beta.0

package/dist/DecoderManager.d.ts

@@ -0,0 +1,62 @@
+import * as MP4Box from "mp4box";
+/**
+ * Manages VideoDecoder lifecycle, configuration, and queue management.
+ * Handles codec configuration, state transitions, and async queue operations.
+ */
+export declare class DecoderManager {
+    private readonly mp4boxFile;
+    private readonly defaultVideoTrack;
+    private readonly decoder;
+    constructor(mp4boxFile: MP4Box.ISOFile, defaultVideoTrack: any, // MP4Box track type
+    onOutput: (frame: VideoFrame) => void, onError: (error: Error) => void);
+    /**
+     * Gets the decoder instance for direct access to decode operations
+     */
+    get videoDecoder(): VideoDecoder;
+    /**
+     * Builds the decoder configuration from MP4 track data
+     */
+    get decoderConfiguration(): VideoDecoderConfig;
+    /**
+     * Configures the video decoder with the appropriate codec, dimensions, and hardware acceleration settings.
+     * If the decoder is already configured, it will be reset before being reconfigured.
+     */
+    configureDecoder(): void;
+    /**
+     * Waits until the video decoder queue is drained (empty).
+     * Uses recursive async pattern to handle multiple pending frames.
+     */
+    waitUntilVideoQueueDrained(): Promise<void>;
+    /**
+     * Gets the current decoder state
+     */
+    get state(): string;
+    /**
+     * Gets the current decode queue size
+     */
+    get decodeQueueSize(): number;
+    /**
+     * Decodes an encoded video chunk
+     */
+    decode(chunk: EncodedVideoChunk): void;
+    /**
+     * Flushes the decoder
+     */
+    flush(): Promise<void>;
+    /**
+     * Resets the decoder
+     */
+    reset(): void;
+    /**
+     * Closes the decoder and releases resources
+     */
+    close(): void;
+    /**
+     * Adds event listener to the decoder
+     */
+    addEventListener(type: string, listener: EventListener, options?: AddEventListenerOptions): void;
+    /**
+     * Removes event listener from the decoder
+     */
+    removeEventListener(type: string, listener: EventListener): void;
+}

package/dist/DecoderManager.js

@@ -0,0 +1,114 @@
+import * as MP4Box from "mp4box";
+/**
+* Manages VideoDecoder lifecycle, configuration, and queue management.
+* Handles codec configuration, state transitions, and async queue operations.
+*/
+var DecoderManager = class {
+	constructor(mp4boxFile, defaultVideoTrack, onOutput, onError) {
+		this.mp4boxFile = mp4boxFile;
+		this.defaultVideoTrack = defaultVideoTrack;
+		this.decoder = new VideoDecoder({
+			output: onOutput,
+			error: onError
+		});
+	}
+	/**
+	* Gets the decoder instance for direct access to decode operations
+	*/
+	get videoDecoder() {
+		return this.decoder;
+	}
+	/**
+	* Builds the decoder configuration from MP4 track data
+	*/
+	get decoderConfiguration() {
+		if (!this.defaultVideoTrack) throw new Error("No default video track found");
+		let description = new Uint8Array();
+		const trak = this.mp4boxFile.getTrackById(this.defaultVideoTrack.id);
+		for (const entry of trak.mdia.minf.stbl.stsd.entries) if (entry.avcC ?? entry.hvcC) {
+			const stream = new MP4Box.DataStream(void 0, 0, MP4Box.DataStream.BIG_ENDIAN);
+			if (entry.avcC) entry.avcC.write(stream);
+			else entry.hvcC.write(stream);
+			description = new Uint8Array(stream.buffer, 8);
+			break;
+		}
+		return {
+			codec: this.defaultVideoTrack.codec,
+			codedWidth: this.defaultVideoTrack.track_width,
+			codedHeight: this.defaultVideoTrack.track_height,
+			optimizeForLatency: true,
+			description
+		};
+	}
+	/**
+	* Configures the video decoder with the appropriate codec, dimensions, and hardware acceleration settings.
+	* If the decoder is already configured, it will be reset before being reconfigured.
+	*/
+	configureDecoder() {
+		if (this.decoder.state === "configured") this.decoder.reset();
+		this.decoder.configure(this.decoderConfiguration);
+	}
+	/**
+	* Waits until the video decoder queue is drained (empty).
+	* Uses recursive async pattern to handle multiple pending frames.
+	*/
+	async waitUntilVideoQueueDrained() {
+		if (this.decoder.decodeQueueSize === 0) return;
+		await new Promise((resolve) => {
+			this.decoder.addEventListener("dequeue", () => {
+				resolve();
+			}, { once: true });
+		});
+		await this.waitUntilVideoQueueDrained();
+	}
+	/**
+	* Gets the current decoder state
+	*/
+	get state() {
+		return this.decoder.state;
+	}
+	/**
+	* Gets the current decode queue size
+	*/
+	get decodeQueueSize() {
+		return this.decoder.decodeQueueSize;
+	}
+	/**
+	* Decodes an encoded video chunk
+	*/
+	decode(chunk) {
+		if (this.decoder.state === "closed") return;
+		this.decoder.decode(chunk);
+	}
+	/**
+	* Flushes the decoder
+	*/
+	async flush() {
+		return this.decoder.flush();
+	}
+	/**
+	* Resets the decoder
+	*/
+	reset() {
+		this.decoder.reset();
+	}
+	/**
+	* Closes the decoder and releases resources
+	*/
+	close() {
+		this.decoder.close();
+	}
+	/**
+	* Adds event listener to the decoder
+	*/
+	addEventListener(type, listener, options) {
+		this.decoder.addEventListener(type, listener, options);
+	}
+	/**
+	* Removes event listener from the decoder
+	*/
+	removeEventListener(type, listener) {
+		this.decoder.removeEventListener(type, listener);
+	}
+};
+export { DecoderManager };

package/dist/EncodedAsset.d.ts

@@ -1,5 +1,7 @@
 import { ReadableStream as ReadableStreamNode } from 'node:stream/web';
-import * as MP4Box from "mp4box";
+import { MP4SampleAnalyzer } from './MP4SampleAnalyzer.js';
+import { DecoderManager } from './DecoderManager.js';
+import type * as MP4Box from "mp4box";
 type AnyReadableStream = ReadableStream<Uint8Array> | ReadableStreamNode<Uint8Array>;
 type FrameCallback = (frame: VideoFrame) => void;
 export interface FetchContext {
@@ -26,14 +28,47 @@ export declare class ISOFileAsset extends FileAsset {
     get containerFormat(): "mp4";
 }
 export declare class VideoAsset extends ISOFileAsset {
-    static createFromReadableStream(id: string, stream: AnyReadableStream, file: File): Promise<VideoAsset>;
-    videoDecoder: VideoDecoder;
+    static createFromReadableStream(id: string, stream: AnyReadableStream, file: File, options?: {
+        startTimeOffsetMs?: number;
+    }): Promise<VideoAsset>;
+    /**
+     * 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 createFromCompleteMP4(id: string, file: File, options?: {
+        startTimeOffsetMs?: number;
+    }): Promise<VideoAsset>;
+    private readonly frameBuffer;
+    private readonly seekStrategy;
+    readonly sampleAnalyzer: MP4SampleAnalyzer;
+    readonly decoderManager: DecoderManager;
     lastDecodedSample?: MP4Box.Sample;
     lastSoughtFrame?: VideoFrame;
-    decodedFrames: VideoFrame[];
     requestedSampleNumber: number;
     outCursor: number;
     sampleCursor: number;
+    latestSeekCts: number;
+    /**
+     * Indicates this is a JIT segment that always starts on a keyframe.
+     * Used to optimize seeking behavior for JIT transcoded segments.
+     */
+    isJitSegment: boolean;
+    /**
+     * Flag to track if this VideoAsset is being replaced
+     * Used to gracefully abort ongoing operations during recreation
+     */
+    private isBeingReplaced;
+    /**
+     * Active seek operations that should be aborted if VideoAsset is replaced
+     */
+    private activeSeekAbortController?;
+    /**
+     * FFmpeg start_time offset in milliseconds from the processed video.
+     * Applied during seeking to correct for timing shifts introduced by FFmpeg processing.
+     */
+    startTimeOffsetMs?: number;
     /**
      * **Only use this function in tests to reset a VideoAsset to its initial state.**
      *
@@ -45,6 +80,9 @@ export declare class VideoAsset extends ISOFileAsset {
     removeEventListener(type: "frame", callback: FrameCallback): void;
     emit(type: "frame", frame: VideoFrame): void;
     constructor(localName: string, mp4boxFile: MP4Box.ISOFile, file: File);
+    get videoDecoder(): VideoDecoder;
+    get decodedFrames(): VideoFrame[];
+    set decodedFrames(frames: VideoFrame[]);
     get videoCodec(): string;
     get fragmentInfo(): {
         offset: number;
@@ -58,17 +96,7 @@ export declare class VideoAsset extends ISOFileAsset {
     get canDecodeNextSample(): boolean;
     decodeNextSample(): Promise<void>;
     decodeSlice(start: number, end: number): Promise<void>;
-    get decoderConfiguration(): {
-        codec: string;
-        codedWidth: number;
-        codedHeight: number;
-        optimizeForLatency: true;
-        description: Uint8Array;
-    };
-    /**
-     * Configures the video decoder with the appropriate codec, dimensions, and hardware acceleration settings.
-     * If the decoder is already configured, it will be reset before being reconfigured.
-     */
+    get decoderConfiguration(): VideoDecoderConfig;
     configureDecoder(): void;
     getSample(index?: number): MP4Box.Sample;
     get timescale(): number;
@@ -78,7 +106,21 @@ export declare class VideoAsset extends ISOFileAsset {
     seekingWillEmitNewFrame(seconds: number): boolean;
     seekingWillSkipPictureGroup(seconds: number): boolean;
     seekingWillGoBackwards(seconds: number): boolean;
-    latestSeekCts: number;
+    /**
+     * 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: number, _shouldFlushPictureGroup: boolean, shouldFlushBackwards: boolean): boolean;
+    /**
+     * Finds the optimal sample cursor position for segments with keyframes.
+     * Uses optimal keyframe selection for both single and multi-keyframe segments.
+     */
+    findOptimalSampleCursorForJitSeek(targetSample: MP4Box.Sample): number;
+    /**
+     * Marks this VideoAsset as being replaced, which will abort any ongoing seek operations
+     */
+    markAsBeingReplaced(): void;
     seekToTime(seconds: number): Promise<VideoFrame | undefined>;
     get defaultVideoTrack(): MP4Box.VideoTrackInfo | undefined;
     get defaultVideoTrak(): MP4Box.TrakBox;