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

package/dist/MP4File.js

@@ -1,209 +0,0 @@
-import * as MP4Box from "mp4box";
-import debug from "debug";
-const log = debug("ef:av:mp4file");
-var MP4File = class extends MP4Box.ISOFile {
-	constructor(options = {}) {
-		super();
-		this.waitingForSamples = [];
-		this._hasSeenLastSamples = false;
-		this._arrayBufferFileStart = 0;
-		this.readyTimeoutMs = options.readyTimeoutMs ?? 100;
-		this.sampleWaitTimeoutMs = options.sampleWaitTimeoutMs ?? 100;
-		this.readyPromise = new Promise((resolve, reject) => {
-			this.onReady = () => {
-				if (this.timeoutId) {
-					clearTimeout(this.timeoutId);
-					this.timeoutId = void 0;
-				}
-				resolve();
-			};
-			this.onError = (error) => {
-				if (this.timeoutId) {
-					clearTimeout(this.timeoutId);
-					this.timeoutId = void 0;
-				}
-				reject(error);
-			};
-			this.timeoutId = setTimeout(() => {
-				this.timeoutId = void 0;
-				reject(/* @__PURE__ */ new Error("MP4File ready timeout - file may be invalid or incomplete"));
-			}, this.readyTimeoutMs);
-		});
-		this.readyPromise.catch(() => {});
-	}
-	setSegmentOptions(id, user, options) {
-		const trak = this.getTrackById(id);
-		if (trak) {
-			trak.nextSample = 0;
-			this.fragmentedTracks.push({
-				id,
-				user,
-				trak,
-				segmentStream: null,
-				nb_samples: "nbSamples" in options && options.nbSamples || 1e3,
-				rapAlignement: ("rapAlignement" in options && options.rapAlignement) ?? true
-			});
-		}
-	}
-	/**
-	* Fragments all tracks in a file into separate array buffers.
-	*/
-	async fragmentAllTracks() {
-		const trackBuffers = {};
-		try {
-			for await (const segment of this.fragmentIterator()) (trackBuffers[segment.track] ??= []).push(segment.data);
-		} catch (error) {
-			console.warn("fragmentAllTracks failed:", error);
-		}
-		return trackBuffers;
-	}
-	async *fragmentIterator() {
-		try {
-			await this.readyPromise;
-		} catch (error) {
-			console.warn("MP4File not ready:", error);
-			return;
-		}
-		const trackInfo = {};
-		const videoTracks = this.getInfo().videoTracks;
-		const audioTracks = this.getInfo().audioTracks;
-		if (videoTracks.length === 0 && audioTracks.length === 0) {
-			console.warn("No video or audio tracks found in MP4 file");
-			return;
-		}
-		for (const videoTrack of videoTracks) {
-			trackInfo[videoTrack.id] = { index: 0 };
-			this.setSegmentOptions(videoTrack.id, null, { rapAlignement: true });
-		}
-		for (const audioTrack of audioTracks) {
-			trackInfo[audioTrack.id] = { index: 0 };
-			const sampleRate = audioTrack.audio.sample_rate;
-			const probablePacketSize = 1024;
-			const probableFourSecondsOfSamples = Math.ceil(sampleRate / probablePacketSize * 4);
-			this.setSegmentOptions(audioTrack.id, null, { nbSamples: probableFourSecondsOfSamples });
-		}
-		if (this.fragmentedTracks.length === 0) {
-			console.warn("No fragmented tracks set up");
-			return;
-		}
-		const initSegments = this.initializeSegmentation();
-		for (const initSegment of initSegments) yield {
-			track: initSegment.id,
-			segment: "init",
-			data: initSegment.buffer
-		};
-		const fragmentStartSamples = {};
-		let finishedReading = false;
-		do {
-			/**
-			* For each track marked for fragmentation, check if the next sample is
-			* there (i.e. if the sample information is known (i.e. moof has arrived)
-			* and if it has been downloaded) and create a fragment with it
-			*/
-			for (const fragTrak of this.fragmentedTracks) {
-				const trak = fragTrak.trak;
-				if (trak.nextSample === void 0) throw new Error("trak.nextSample is undefined");
-				if (trak.samples === void 0) throw new Error("trak.samples is undefined");
-				log("trak.nextSample", fragTrak.id, trak.nextSample);
-				log("trak.samples.length", fragTrak.id, trak.samples.length);
-				while (trak.nextSample < trak.samples.length) {
-					let result = void 0;
-					const fragTrakNextSample = trak.samples[trak.nextSample];
-					if (fragTrakNextSample) fragmentStartSamples[fragTrak.id] ||= fragTrakNextSample;
-					try {
-						result = this.createFragment(fragTrak.id, trak.nextSample, fragTrak.segmentStream);
-					} catch (error) {
-						console.error("Failed to createFragment", error);
-					}
-					if (result) {
-						fragTrak.segmentStream = result;
-						trak.nextSample++;
-					} else {
-						finishedReading = await this.waitForMoreSamples();
-						break;
-					}
-					const nextSample = trak.samples[trak.nextSample];
-					const emitSegment = fragTrak.rapAlignement === true && nextSample?.is_sync || !fragTrak.rapAlignement && trak.nextSample % fragTrak.nb_samples === 0 || trak.nextSample >= trak.samples.length;
-					if (emitSegment) {
-						const trackInfoForFrag = trackInfo[fragTrak.id];
-						if (!trackInfoForFrag) throw new Error("trackInfoForFrag is undefined");
-						const startSample = fragmentStartSamples[fragTrak.id];
-						const endSample = trak.samples[trak.nextSample - 1];
-						if (!startSample || !endSample) throw new Error("startSample or endSample is undefined");
-						log(`Yielding fragment #${trackInfoForFrag.index} for track=${fragTrak.id}`, `startTime=${startSample.cts}`, `endTime=${endSample.cts + endSample.duration}`);
-						yield {
-							track: fragTrak.id,
-							segment: trackInfoForFrag.index,
-							data: fragTrak.segmentStream.buffer,
-							cts: startSample.cts,
-							dts: startSample.dts,
-							duration: endSample.cts - startSample.cts + endSample.duration
-						};
-						trackInfoForFrag.index += 1;
-						fragTrak.segmentStream = null;
-						delete fragmentStartSamples[fragTrak.id];
-					}
-				}
-			}
-			finishedReading = await this.waitForMoreSamples();
-		} while (!finishedReading);
-		for (const fragTrak of this.fragmentedTracks) {
-			const trak = fragTrak.trak;
-			if (trak.nextSample === void 0) throw new Error("trak.nextSample is undefined");
-			if (trak.samples === void 0) throw new Error("trak.samples is undefined");
-			while (trak.nextSample < trak.samples.length) {
-				let result = void 0;
-				try {
-					result = this.createFragment(fragTrak.id, trak.nextSample, fragTrak.segmentStream);
-				} catch (error) {
-					console.error("Failed to createFragment", error);
-				}
-				if (result) {
-					fragTrak.segmentStream = result;
-					trak.nextSample++;
-				} else {
-					finishedReading = await this.waitForMoreSamples();
-					break;
-				}
-				const nextSample = trak.samples[trak.nextSample];
-				const emitSegment = fragTrak.rapAlignement === true && nextSample?.is_sync || !fragTrak.rapAlignement && trak.nextSample % fragTrak.nb_samples === 0 || trak.nextSample >= trak.samples.length;
-				if (emitSegment) {
-					const trackInfoForFrag = trackInfo[fragTrak.id];
-					if (!trackInfoForFrag) throw new Error("trackInfoForFrag is undefined");
-					const startSample = fragmentStartSamples[fragTrak.id];
-					const endSample = trak.samples[trak.nextSample - 1];
-					if (!startSample || !endSample) throw new Error("startSample or endSample is undefined");
-					log(`Yielding fragment #${trackInfoForFrag.index} for track=${fragTrak.id}`, `startTime=${startSample.cts}`, `endTime=${endSample.cts + endSample.duration}`);
-					yield {
-						track: fragTrak.id,
-						segment: trackInfoForFrag.index,
-						data: fragTrak.segmentStream.buffer,
-						cts: startSample.cts,
-						dts: startSample.dts,
-						duration: endSample.cts - startSample.cts + endSample.duration
-					};
-					trackInfoForFrag.index += 1;
-					fragTrak.segmentStream = null;
-					delete fragmentStartSamples[fragTrak.id];
-				}
-			}
-		}
-	}
-	waitForMoreSamples() {
-		if (this._hasSeenLastSamples) return Promise.resolve(true);
-		return new Promise((resolve) => {
-			this.waitingForSamples.push(resolve);
-			setTimeout(() => {
-				const index = this.waitingForSamples.indexOf(resolve);
-				if (index !== -1) this.waitingForSamples.splice(index, 1);
-				resolve(true);
-			}, this.sampleWaitTimeoutMs);
-		});
-	}
-	processSamples(last) {
-		this._hasSeenLastSamples = last;
-		for (const observer of this.waitingForSamples) observer(last);
-		this.waitingForSamples = [];
-	}
-};
-export { MP4File };

package/dist/MP4SampleAnalyzer.d.ts

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

@@ -1,119 +0,0 @@
-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/SeekStrategy.d.ts

@@ -1,82 +0,0 @@
-import type * as MP4Box from "mp4box";
-/**
- * Interface for the minimal FrameBuffer API needed by SeekStrategy
- */
-interface FrameBufferLike {
-    findByTimestamp(timestamp: number): VideoFrame | undefined;
-}
-/**
- * State information needed for seeking decisions
- */
-export interface SeekState {
-    /** Current position in the samples array for decoding */
-    sampleCursor: number;
-    /** Position of the last successfully decoded frame output */
-    outCursor: number;
-    /** Optional frame buffer for checking cached frames */
-    frameBuffer?: FrameBufferLike;
-}
-/**
- * SeekStrategy encapsulates the critical seeking decision logic extracted from VideoAsset.
- *
- * **CRITICAL**: This class preserves the exact seeking behavior and decoder flush conditions
- * from the original VideoAsset implementation to maintain "warm" decoder state performance.
- *
- * The logic here directly controls when the decoder must be flushed, which is the most
- * performance-critical aspect of frame-accurate seeking.
- */
-export declare class SeekStrategy {
-    /**
-     * Determines if seeking will skip picture groups (GOPs), requiring a decoder flush.
-     *
-     * This is an EXACT extraction of the original `seekingWillSkipPictureGroup` logic.
-     *
-     * @param state Current seek state with cursor positions
-     * @param targetSample The sample we want to seek to
-     * @param allSamples All samples in display order
-     * @returns true if seeking will cross more than one sync frame (GOP boundary)
-     */
-    seekingWillSkipPictureGroup(state: SeekState, targetSample: MP4Box.Sample, allSamples: MP4Box.Sample[]): boolean;
-    /**
-     * Determines if seeking will go backwards in time, requiring a decoder flush.
-     *
-     * This is an EXACT extraction of the original `seekingWillGoBackwards` logic.
-     *
-     * @param state Current seek state with cursor positions and frame buffer
-     * @param targetSample The sample we want to seek to
-     * @param displayOrderedSamples Samples sorted by composition timestamp
-     * @returns true if seeking backwards and target frame is not cached
-     */
-    seekingWillGoBackwards(state: SeekState, targetSample: MP4Box.Sample, displayOrderedSamples: MP4Box.Sample[]): boolean;
-    /**
-     * Finds the sync sample at or before the target sample number.
-     *
-     * This is an EXACT extraction of the sync sample finding logic from the original
-     * `seekToTime` method. Used when decoder flush is required to find optimal restart point.
-     *
-     * @param targetSample The sample we want to seek to
-     * @param allSamples All samples in the video
-     * @returns The sample number of the sync frame to start decoding from
-     * @throws Error if no sync sample found when traversing backwards
-     */
-    findSyncSampleBefore(targetSample: MP4Box.Sample, allSamples: MP4Box.Sample[]): number;
-    /**
-     * The master decision function that determines if the decoder should be flushed.
-     *
-     * This consolidates the EXACT flush decision logic from the original VideoAsset.seekToTime().
-     * The decoder is flushed ONLY when:
-     * 1. Seeking will skip picture groups (crosses multiple GOP boundaries), OR
-     * 2. Seeking backwards and target frame is not in cache
-     *
-     * **CRITICAL**: This preserves the sophisticated flush minimization that keeps
-     * the decoder "warm" for optimal performance.
-     *
-     * @param state Current seek state
-     * @param targetSample The sample we want to seek to
-     * @param allSamples All samples in the video
-     * @param displayOrderedSamples Samples sorted by composition timestamp
-     * @returns true if decoder should be flushed before seeking
-     */
-    shouldFlushDecoder(state: SeekState, targetSample: MP4Box.Sample, allSamples: MP4Box.Sample[], displayOrderedSamples?: MP4Box.Sample[]): boolean;
-}
-export {};

package/dist/SeekStrategy.js

@@ -1,101 +0,0 @@
-/**
-* SeekStrategy encapsulates the critical seeking decision logic extracted from VideoAsset.
-* 
-* **CRITICAL**: This class preserves the exact seeking behavior and decoder flush conditions
-* from the original VideoAsset implementation to maintain "warm" decoder state performance.
-* 
-* The logic here directly controls when the decoder must be flushed, which is the most
-* performance-critical aspect of frame-accurate seeking.
-*/
-var SeekStrategy = class {
-	/**
-	* Determines if seeking will skip picture groups (GOPs), requiring a decoder flush.
-	* 
-	* This is an EXACT extraction of the original `seekingWillSkipPictureGroup` logic.
-	* 
-	* @param state Current seek state with cursor positions
-	* @param targetSample The sample we want to seek to
-	* @param allSamples All samples in display order
-	* @returns true if seeking will cross more than one sync frame (GOP boundary)
-	*/
-	seekingWillSkipPictureGroup(state, targetSample, allSamples) {
-		let start = state.sampleCursor;
-		const end = targetSample.number;
-		let syncFrameCrossings = 0;
-		while (start <= end) {
-			const sample = allSamples[start];
-			if (!sample) break;
-			if (sample.is_sync) {
-				if (syncFrameCrossings > 1) return true;
-				syncFrameCrossings++;
-			}
-			start++;
-		}
-		return false;
-	}
-	/**
-	* Determines if seeking will go backwards in time, requiring a decoder flush.
-	* 
-	* This is an EXACT extraction of the original `seekingWillGoBackwards` logic.
-	* 
-	* @param state Current seek state with cursor positions and frame buffer
-	* @param targetSample The sample we want to seek to  
-	* @param displayOrderedSamples Samples sorted by composition timestamp
-	* @returns true if seeking backwards and target frame is not cached
-	*/
-	seekingWillGoBackwards(state, targetSample, displayOrderedSamples) {
-		const targetIndex = displayOrderedSamples.indexOf(targetSample);
-		const targetInCache = state.frameBuffer?.findByTimestamp(targetSample.cts);
-		const atEnd = state.sampleCursor === displayOrderedSamples.length - 1;
-		if (atEnd) return false;
-		if (targetInCache) return false;
-		return state.outCursor > targetIndex;
-	}
-	/**
-	* Finds the sync sample at or before the target sample number.
-	* 
-	* This is an EXACT extraction of the sync sample finding logic from the original
-	* `seekToTime` method. Used when decoder flush is required to find optimal restart point.
-	* 
-	* @param targetSample The sample we want to seek to
-	* @param allSamples All samples in the video
-	* @returns The sample number of the sync frame to start decoding from
-	* @throws Error if no sync sample found when traversing backwards
-	*/
-	findSyncSampleBefore(targetSample, allSamples) {
-		let syncSampleNumber = targetSample.number;
-		while (syncSampleNumber >= 0) {
-			const sample = allSamples[syncSampleNumber];
-			if (!sample) break;
-			if (sample.is_sync) return syncSampleNumber;
-			syncSampleNumber--;
-		}
-		throw new Error("No sync sample found when traversing backwards");
-	}
-	/**
-	* The master decision function that determines if the decoder should be flushed.
-	* 
-	* This consolidates the EXACT flush decision logic from the original VideoAsset.seekToTime().
-	* The decoder is flushed ONLY when:
-	* 1. Seeking will skip picture groups (crosses multiple GOP boundaries), OR
-	* 2. Seeking backwards and target frame is not in cache
-	* 
-	* **CRITICAL**: This preserves the sophisticated flush minimization that keeps
-	* the decoder "warm" for optimal performance.
-	* 
-	* @param state Current seek state
-	* @param targetSample The sample we want to seek to
-	* @param allSamples All samples in the video
-	* @param displayOrderedSamples Samples sorted by composition timestamp  
-	* @returns true if decoder should be flushed before seeking
-	*/
-	shouldFlushDecoder(state, targetSample, allSamples, displayOrderedSamples) {
-		const targetInCache = state.frameBuffer?.findByTimestamp(targetSample.cts);
-		if (targetInCache) return false;
-		const orderedSamples = displayOrderedSamples || allSamples;
-		if (this.seekingWillSkipPictureGroup(state, targetSample, allSamples)) return true;
-		if (this.seekingWillGoBackwards(state, targetSample, orderedSamples)) return true;
-		return false;
-	}
-};
-export { SeekStrategy };

package/dist/memoize.js

@@ -1,11 +0,0 @@
-/** method decorator to memoize the value of a getter */
-const memoize = (_target, _propertyKey, descriptor) => {
-	const get = descriptor.get;
-	if (!get) return;
-	const memoized = /* @__PURE__ */ new WeakMap();
-	descriptor.get = function() {
-		if (!memoized.has(this)) memoized.set(this, get.call(this));
-		return memoized.get(this);
-	};
-};
-export { memoize };

package/dist/mp4FileWritable.d.ts

@@ -1,3 +0,0 @@
-import { Writable } from 'node:stream';
-import { MP4File } from './MP4File.js';
-export declare const mp4FileWritable: (mp4File: MP4File) => Writable;

package/dist/mp4FileWritable.js

@@ -1,19 +0,0 @@
-import { Writable } from "node:stream";
-const mp4FileWritable = (mp4File) => {
-	let arrayBufferStart = 0;
-	return new Writable({
-		write: (chunk, _encoding, callback) => {
-			const mp4BoxBuffer = chunk.buffer;
-			mp4BoxBuffer.fileStart = arrayBufferStart;
-			arrayBufferStart += chunk.length;
-			mp4File.appendBuffer(mp4BoxBuffer, false);
-			callback();
-		},
-		final: (callback) => {
-			mp4File.flush();
-			mp4File.processSamples(true);
-			callback();
-		}
-	});
-};
-export { mp4FileWritable };