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

package/dist/MP4SampleAnalyzer.d.ts

@@ -0,0 +1,59 @@
+import type * as MP4Box from "mp4box";
+export interface KeyframePosition {
+    sampleNumber: number;
+    cts: number;
+}
+/**
+ * Handles MP4 sample analysis and time-to-sample conversion logic.
+ * Provides efficient access to video samples with caching and time-based lookup.
+ */
+export declare class MP4SampleAnalyzer {
+    private readonly mp4boxFile;
+    private readonly defaultVideoTrack;
+    constructor(mp4boxFile: MP4Box.ISOFile, defaultVideoTrack: any);
+    /**
+     * Gets a sample by index with error handling
+     */
+    getSample(index: number): MP4Box.Sample;
+    /**
+     * Gets the timescale for the default video track
+     */
+    get timescale(): number;
+    /**
+     * Gets all video samples for the default track
+     */
+    get samples(): MP4Box.Sample[];
+    /**
+     * Gets samples sorted by composition timestamp (CTS) for display order
+     */
+    get displayOrderedSamples(): MP4Box.Sample[];
+    /**
+     * Finds the sample closest to the given time in seconds
+     */
+    getSampleClosetToTime(seconds: number): MP4Box.Sample;
+    /**
+     * Calculates the edit offset from track edits
+     */
+    get editsOffset(): number;
+    /**
+     * Gets the default video track structure from MP4Box
+     */
+    get defaultVideoTrak(): any;
+    /**
+     * Determines if this segment has multiple keyframes (typical for 30s scrub segments)
+     */
+    hasMultipleKeyframes(): boolean;
+    /**
+     * Gets positions of all keyframes within the segment
+     */
+    getKeyframePositions(): KeyframePosition[];
+    /**
+     * Calculates the average interval between keyframes in timestamp units
+     */
+    getKeyframeInterval(): number;
+    /**
+     * Finds the optimal keyframe to start decoding from for a given target sample.
+     * Returns the keyframe closest to but not after the target.
+     */
+    findOptimalKeyframeForSeek(targetSample: MP4Box.Sample): MP4Box.Sample;
+}

package/dist/MP4SampleAnalyzer.js

@@ -0,0 +1,119 @@
+import { memoize } from "./memoize.js";
+import _decorate from "@oxc-project/runtime/helpers/decorate";
+/**
+* Handles MP4 sample analysis and time-to-sample conversion logic.
+* Provides efficient access to video samples with caching and time-based lookup.
+*/
+var MP4SampleAnalyzer = class {
+	constructor(mp4boxFile, defaultVideoTrack) {
+		this.mp4boxFile = mp4boxFile;
+		this.defaultVideoTrack = defaultVideoTrack;
+	}
+	/**
+	* Gets a sample by index with error handling
+	*/
+	getSample(index) {
+		const sample = this.samples?.[index];
+		if (!sample) throw new Error(`Sample not found at index ${index}`);
+		return sample;
+	}
+	/**
+	* Gets the timescale for the default video track
+	*/
+	get timescale() {
+		if (!this.defaultVideoTrack) throw new Error("No default video track found");
+		return this.defaultVideoTrack.timescale;
+	}
+	/**
+	* Gets all video samples for the default track
+	*/
+	get samples() {
+		if (!this.defaultVideoTrak.samples) throw new Error("No video samples found");
+		return this.defaultVideoTrak.samples;
+	}
+	/**
+	* Gets samples sorted by composition timestamp (CTS) for display order
+	*/
+	get displayOrderedSamples() {
+		return Array.from(this.samples).sort((a, b) => {
+			return a.cts - b.cts;
+		});
+	}
+	/**
+	* Finds the sample closest to the given time in seconds
+	*/
+	getSampleClosetToTime(seconds) {
+		const targetTime = Math.round(seconds * this.timescale + this.editsOffset);
+		const sampleIndex = this.displayOrderedSamples.findIndex((sample) => sample.cts >= targetTime);
+		if (sampleIndex === -1) return this.displayOrderedSamples[this.displayOrderedSamples.length - 1];
+		return this.displayOrderedSamples[sampleIndex];
+	}
+	/**
+	* Calculates the edit offset from track edits
+	*/
+	get editsOffset() {
+		if (!this.defaultVideoTrack?.edits) return 0;
+		return this.defaultVideoTrack.edits.reduce((acc, edit) => {
+			return acc + edit.media_time;
+		}, 0);
+	}
+	/**
+	* Gets the default video track structure from MP4Box
+	*/
+	get defaultVideoTrak() {
+		return this.mp4boxFile.getTrackById(this.defaultVideoTrack?.id ?? -1);
+	}
+	/**
+	* Determines if this segment has multiple keyframes (typical for 30s scrub segments)
+	*/
+	hasMultipleKeyframes() {
+		const keyframes = this.samples.filter((sample) => sample.is_sync);
+		return keyframes.length > 1;
+	}
+	/**
+	* Gets positions of all keyframes within the segment
+	*/
+	getKeyframePositions() {
+		return this.samples.filter((sample) => sample.is_sync).map((sample) => ({
+			sampleNumber: sample.number,
+			cts: sample.cts
+		}));
+	}
+	/**
+	* Calculates the average interval between keyframes in timestamp units
+	*/
+	getKeyframeInterval() {
+		const keyframes = this.getKeyframePositions();
+		if (keyframes.length <= 1) return 0;
+		let totalInterval = 0;
+		for (let i = 1; i < keyframes.length; i++) {
+			const currentKeyframe = keyframes[i];
+			const previousKeyframe = keyframes[i - 1];
+			if (currentKeyframe && previousKeyframe) totalInterval += currentKeyframe.cts - previousKeyframe.cts;
+		}
+		return totalInterval / (keyframes.length - 1);
+	}
+	/**
+	* Finds the optimal keyframe to start decoding from for a given target sample.
+	* Returns the keyframe closest to but not after the target.
+	*/
+	findOptimalKeyframeForSeek(targetSample) {
+		const keyframes = this.getKeyframePositions();
+		if (keyframes.length === 0) throw new Error("No keyframes found for optimal seek");
+		if (targetSample.is_sync) return targetSample;
+		let optimalKeyframe = keyframes[0];
+		if (!optimalKeyframe) throw new Error("No keyframes available");
+		for (const keyframe of keyframes) if (keyframe.cts <= targetSample.cts) optimalKeyframe = keyframe;
+		else break;
+		const sample = this.samples[optimalKeyframe.sampleNumber];
+		if (!sample) throw new Error(`Sample not found at keyframe position ${optimalKeyframe.sampleNumber}`);
+		return sample;
+	}
+};
+_decorate([memoize], MP4SampleAnalyzer.prototype, "timescale", null);
+_decorate([memoize], MP4SampleAnalyzer.prototype, "samples", null);
+_decorate([memoize], MP4SampleAnalyzer.prototype, "displayOrderedSamples", null);
+_decorate([memoize], MP4SampleAnalyzer.prototype, "editsOffset", null);
+_decorate([memoize], MP4SampleAnalyzer.prototype, "defaultVideoTrak", null);
+_decorate([memoize], MP4SampleAnalyzer.prototype, "getKeyframePositions", null);
+export { MP4SampleAnalyzer };

package/dist/Probe.d.ts

@@ -612,6 +612,7 @@ export interface VideoTrackFragmentIndex {
     height: number;
     sample_count: number;
     codec: string;
+    startTimeOffsetMs?: number;
     initSegment: {
         offset: 0;
         size: number;