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

package/dist/generateTrackMediabunny.js

@@ -0,0 +1,69 @@
+import { Probe } from "./Probe.js";
+import { idempotentTask } from "./idempotentTask.js";
+import { generateTrackFragmentIndexMediabunny } from "./generateTrackFragmentIndexMediabunny.js";
+import debug from "debug";
+import { basename } from "node:path";
+import { PassThrough } from "node:stream";
+const log = debug("ef:generateTrackMediabunny");
+const generateTrackFromPathMediabunny = async (absolutePath, trackId) => {
+	log(`Generating track ${trackId} for ${absolutePath}`);
+	const probe = await Probe.probePath(absolutePath);
+	const streamIndex = trackId - 1;
+	if (streamIndex < 0 || streamIndex >= probe.streams.length) throw new Error(`Track ${trackId} not found (valid tracks: 1-${probe.streams.length})`);
+	const trackStream = probe.createTrackReadstream(streamIndex);
+	const outputStream = new PassThrough();
+	const indexStream = new PassThrough();
+	trackStream.pipe(outputStream, { end: false });
+	trackStream.pipe(indexStream);
+	let sourceStreamEnded = false;
+	trackStream.on("end", () => {
+		sourceStreamEnded = true;
+	});
+	trackStream.on("error", (error) => {
+		outputStream.destroy(error);
+		indexStream.destroy(error);
+	});
+	const trackIdMapping = { 1: trackId };
+	const fragmentIndexPromise = generateTrackFragmentIndexMediabunny(indexStream, void 0, trackIdMapping);
+	fragmentIndexPromise.then(() => {
+		if (sourceStreamEnded) outputStream.end();
+		else trackStream.once("end", () => {
+			outputStream.end();
+		});
+	}).catch((error) => {
+		outputStream.destroy(error);
+	});
+	return {
+		stream: outputStream,
+		fragmentIndex: fragmentIndexPromise
+	};
+};
+const generateTrackTaskMediabunny = idempotentTask({
+	label: "track-mediabunny",
+	filename: (absolutePath, trackId) => `${basename(absolutePath)}.track-${trackId}.mp4`,
+	runner: async (absolutePath, trackId) => {
+		const result = await generateTrackFromPathMediabunny(absolutePath, trackId);
+		const finalStream = new PassThrough();
+		let streamEnded = false;
+		let fragmentIndexCompleted = false;
+		const checkCompletion = () => {
+			if (streamEnded && fragmentIndexCompleted) finalStream.end();
+		};
+		result.stream.pipe(finalStream, { end: false });
+		result.stream.on("end", () => {
+			streamEnded = true;
+			checkCompletion();
+		});
+		result.stream.on("error", (error) => {
+			finalStream.destroy(error);
+		});
+		result.fragmentIndex.then(() => {
+			fragmentIndexCompleted = true;
+			checkCompletion();
+		}).catch((error) => {
+			finalStream.destroy(error);
+		});
+		return finalStream;
+	}
+});
+export { generateTrackFromPathMediabunny };

package/dist/idempotentTask.js

@@ -1,11 +1,20 @@
 import { md5FilePath } from "./md5.js";
-import debug from "debug";
 import { createWriteStream, existsSync } from "node:fs";
-import { mkdir, writeFile } from "node:fs/promises";
+import debug from "debug";
+import { mkdir, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { Readable } from "node:stream";
 const idempotentTask = ({ label, filename, runner }) => {
 	const tasks = {};
+	const downloadTasks = {};
+	const isValidCacheFile = async (filePath, allowEmpty = false) => {
+		try {
+			const stats = await stat(filePath);
+			return allowEmpty || stats.size > 0;
+		} catch {
+			return false;
+		}
+	};
 	return async (rootDir, absolutePath, ...args) => {
 		const log = debug(`ef:${label}`);
 		const cacheDirRoot = path.join(rootDir, ".cache");
@@ -13,22 +22,42 @@ const idempotentTask = ({ label, filename, runner }) => {
 		log(`Running ef:${label} task for ${absolutePath} in ${rootDir}`);
 		if (absolutePath.includes("http")) {
 			const safePath = absolutePath.replace(/[^a-zA-Z0-9]/g, "_");
-			const cachePath$1 = path.join(rootDir, ".cache", `${safePath}.file`);
-			if (existsSync(absolutePath)) log(`Already cached ${absolutePath}`);
-			else {
-				const response = await fetch(absolutePath);
-				const stream = response.body;
-				if (response.ok && stream) {
-					const writeStream = createWriteStream(cachePath$1);
-					const readable = Readable.fromWeb(stream);
-					readable.pipe(writeStream);
-					await new Promise((resolve, reject) => {
-						readable.on("error", reject);
-						writeStream.on("error", reject);
-						writeStream.on("finish", resolve);
-					});
-					absolutePath = cachePath$1;
-				} else throw new Error(`Failed to fetch file from URL ${absolutePath}`);
+			const downloadCachePath = path.join(rootDir, ".cache", `${safePath}.file`);
+			if (existsSync(downloadCachePath) && await isValidCacheFile(downloadCachePath, true)) {
+				log(`Already cached ${absolutePath}`);
+				absolutePath = downloadCachePath;
+			} else {
+				const downloadKey = absolutePath;
+				if (!downloadTasks[downloadKey]) {
+					log(`Starting download for ${absolutePath}`);
+					downloadTasks[downloadKey] = (async () => {
+						try {
+							const response = await fetch(absolutePath);
+							if (!response.ok) throw new Error(`Failed to fetch file from URL ${absolutePath}: ${response.status} ${response.statusText}`);
+							const stream = response.body;
+							if (!stream) throw new Error(`No response body for URL ${absolutePath}`);
+							const tempPath = `${downloadCachePath}.tmp`;
+							const writeStream = createWriteStream(tempPath);
+							const readable = Readable.fromWeb(stream);
+							readable.pipe(writeStream);
+							await new Promise((resolve, reject) => {
+								readable.on("error", reject);
+								writeStream.on("error", reject);
+								writeStream.on("finish", resolve);
+							});
+							const { rename } = await import("node:fs/promises");
+							await rename(tempPath, downloadCachePath);
+							log(`Download completed for ${absolutePath}`);
+							return downloadCachePath;
+						} catch (error) {
+							log(`Download failed for ${absolutePath}: ${error}`);
+							delete downloadTasks[downloadKey];
+							throw error;
+						}
+					})();
+				}
+				absolutePath = await downloadTasks[downloadKey];
+				delete downloadTasks[downloadKey];
 			}
 		}
 		const md5 = await md5FilePath(absolutePath);
@@ -37,7 +66,7 @@ const idempotentTask = ({ label, filename, runner }) => {
 		await mkdir(cacheDir, { recursive: true });
 		const cachePath = path.join(cacheDir, filename(absolutePath, ...args));
 		const key = cachePath;
-		if (existsSync(cachePath)) {
+		if (existsSync(cachePath) && await isValidCacheFile(cachePath)) {
 			log(`Returning cached ef:${label} task for ${key}`);
 			return {
 				cachePath,
@@ -47,37 +76,41 @@ const idempotentTask = ({ label, filename, runner }) => {
 		const maybeTask = tasks[key];
 		if (maybeTask) {
 			log(`Returning existing ef:${label} task for ${key}`);
-			await maybeTask;
-			return {
-				cachePath,
-				md5Sum: md5
-			};
+			return await maybeTask;
 		}
 		log(`Creating new ef:${label} task for ${key}`);
-		const task = runner(absolutePath, ...args);
-		tasks[key] = task;
-		log(`Awaiting task for ${key}`);
-		const result = await task;
-		if (result instanceof Readable) {
-			log(`Piping task for ${key} to cache`);
-			const writeStream = createWriteStream(cachePath);
-			result.pipe(writeStream);
-			await new Promise((resolve, reject) => {
-				result.on("error", reject);
-				writeStream.on("error", reject);
-				writeStream.on("finish", resolve);
-			});
-			return {
-				cachePath,
-				md5Sum: md5
-			};
-		}
-		log(`Writing to ${cachePath}`);
-		await writeFile(cachePath, result);
-		return {
-			md5Sum: md5,
-			cachePath
-		};
+		const fullTask = (async () => {
+			try {
+				log(`Awaiting task for ${key}`);
+				const result = await runner(absolutePath, ...args);
+				if (result instanceof Readable) {
+					log(`Piping task for ${key} to cache`);
+					const tempPath = `${cachePath}.tmp`;
+					const writeStream = createWriteStream(tempPath);
+					result.pipe(writeStream);
+					await new Promise((resolve, reject) => {
+						result.on("error", reject);
+						writeStream.on("error", reject);
+						writeStream.on("finish", resolve);
+					});
+					const { rename } = await import("node:fs/promises");
+					await rename(tempPath, cachePath);
+				} else {
+					log(`Writing to ${cachePath}`);
+					await writeFile(cachePath, result);
+				}
+				delete tasks[key];
+				return {
+					md5Sum: md5,
+					cachePath
+				};
+			} catch (error) {
+				delete tasks[key];
+				throw error;
+			}
+		})();
+		tasks[key] = fullTask;
+		return await fullTask;
 	};
 };
 export { idempotentTask };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export type { StreamSchema, AudioStreamSchema, VideoStreamSchema, TrackSegment, TrackFragmentIndex, AudioTrackFragmentIndex, VideoTrackFragmentIndex, } from './Probe.js';
-export { Probe } from './Probe.js';
+export type { StreamSchema, AudioStreamSchema, VideoStreamSchema, ProbeSchema, PacketProbeSchema, TrackSegment, TrackFragmentIndex, AudioTrackFragmentIndex, VideoTrackFragmentIndex, } from './Probe.js';
+export { Probe, PacketProbe } from './Probe.js';
 export { md5FilePath, md5Directory, md5ReadStream, md5Buffer } from './md5.js';
 export { generateTrackFragmentIndex, generateTrackFragmentIndexFromPath, } from './tasks/generateTrackFragmentIndex.js';
 export { generateTrack, generateTrackFromPath } from './tasks/generateTrack.js';

package/dist/index.js

@@ -1,8 +1,8 @@
-import { Probe } from "./Probe.js";
+import { PacketProbe, Probe } from "./Probe.js";
 import { md5Buffer, md5Directory, md5FilePath, md5ReadStream } from "./md5.js";
 import { generateTrackFragmentIndex, generateTrackFragmentIndexFromPath } from "./tasks/generateTrackFragmentIndex.js";
 import { generateTrack, generateTrackFromPath } from "./tasks/generateTrack.js";
 import { findOrCreateCaptions, generateCaptionDataFromPath } from "./tasks/findOrCreateCaptions.js";
 import { cacheImage } from "./tasks/cacheImage.js";
 import { VideoRenderOptions } from "./VideoRenderOptions.js";
-export { Probe, VideoRenderOptions, cacheImage, findOrCreateCaptions, generateCaptionDataFromPath, generateTrack, generateTrackFragmentIndex, generateTrackFragmentIndexFromPath, generateTrackFromPath, md5Buffer, md5Directory, md5FilePath, md5ReadStream };
+export { PacketProbe, Probe, VideoRenderOptions, cacheImage, findOrCreateCaptions, generateCaptionDataFromPath, generateTrack, generateTrackFragmentIndex, generateTrackFragmentIndexFromPath, generateTrackFromPath, md5Buffer, md5Directory, md5FilePath, md5ReadStream };

package/dist/tasks/cacheRemoteAsset.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tasks/findOrCreateCaptions.js

@@ -1,7 +1,7 @@
 import { idempotentTask } from "../idempotentTask.js";
-import debug from "debug";
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
+import debug from "debug";
 import { basename } from "node:path";
 const execPromise = promisify(exec);
 const log = debug("ef:generateCaptions");

package/dist/tasks/generateTrack.d.ts

@@ -1,4 +1,3 @@
-import { PassThrough } from 'node:stream';
-export declare const generateTrackFromPath: (absolutePath: string, trackId: number) => Promise<PassThrough>;
+export declare const generateTrackFromPath: (absolutePath: string, trackId: number) => Promise<import('stream').PassThrough>;
 export declare const generateTrackTask: (rootDir: string, absolutePath: string, trackId: number) => Promise<import('../idempotentTask.js').TaskResult>;
 export declare const generateTrack: (cacheRoot: string, absolutePath: string, url: string) => Promise<import('../idempotentTask.js').TaskResult>;

package/dist/tasks/generateTrack.js

@@ -1,39 +1,12 @@
-import { MP4File } from "../MP4File.js";
-import { Probe } from "../Probe.js";
 import { idempotentTask } from "../idempotentTask.js";
-import { mp4FileWritable } from "../mp4FileWritable.js";
+import { generateTrackFromPathMediabunny } from "../generateTrackMediabunny.js";
 import debug from "debug";
 import { basename } from "node:path";
-import { PassThrough } from "node:stream";
 const generateTrackFromPath = async (absolutePath, trackId) => {
 	const log = debug("ef:generateTrackFragment");
-	const probe = await Probe.probePath(absolutePath);
-	const readStream = probe.createConformingReadstream();
-	const mp4File = new MP4File();
-	const trackStream = new PassThrough();
-	log(`Generating track for ${absolutePath}`);
-	readStream.pipe(mp4FileWritable(mp4File));
-	(async () => {
-		try {
-			let bytesWritten = 0;
-			for await (const fragment of mp4File.fragmentIterator()) {
-				log("Writing fragment", fragment);
-				if (fragment.track === trackId) {
-					const written = trackStream.write(Buffer.from(fragment.data), "binary");
-					if (!written) {
-						log(`Waiting for drain for track ${trackId}`);
-						await new Promise((resolve) => trackStream.once("drain", resolve));
-					}
-					bytesWritten += fragment.data.byteLength;
-				}
-				if (!readStream.readableEnded) await Promise.race([new Promise((resolve) => readStream.once("end", resolve)), new Promise((resolve) => readStream.once("data", resolve))]);
-			}
-			trackStream.end();
-		} catch (error) {
-			trackStream.destroy(error);
-		}
-	})();
-	return trackStream;
+	log(`Generating track ${trackId} for ${absolutePath} using Mediabunny`);
+	const result = await generateTrackFromPathMediabunny(absolutePath, trackId);
+	return result.stream;
 };
 const generateTrackTask = idempotentTask({
 	label: "track",
@@ -43,7 +16,7 @@ const generateTrackTask = idempotentTask({
 const generateTrack = async (cacheRoot, absolutePath, url) => {
 	try {
 		const trackId = new URL(`http://localhost${url}`).searchParams.get("trackId");
-		if (trackId === null) throw new Error("No trackId provided. IT must be specified in the query string: ?trackId=0");
+		if (trackId === null) throw new Error("No trackId provided. It must be specified in the query string: ?trackId=1 (for video) or ?trackId=2 (for audio)");
 		return await generateTrackTask(cacheRoot, absolutePath, Number(trackId));
 	} catch (error) {
 		console.error(error);

package/dist/tasks/generateTrackFragmentIndex.js

@@ -1,80 +1,33 @@
-import { MP4File } from "../MP4File.js";
 import { Probe } from "../Probe.js";
 import { idempotentTask } from "../idempotentTask.js";
-import { mp4FileWritable } from "../mp4FileWritable.js";
+import { generateTrackFragmentIndexMediabunny } from "../generateTrackFragmentIndexMediabunny.js";
 import debug from "debug";
 import { basename } from "node:path";
 const generateTrackFragmentIndexFromPath = async (absolutePath) => {
 	const log = debug("ef:generateTrackFragment");
 	const probe = await Probe.probePath(absolutePath);
-	const readStream = probe.createConformingReadstream();
-	const mp4File = new MP4File();
-	log(`Generating track fragment index for ${absolutePath}`);
-	readStream.pipe(mp4FileWritable(mp4File));
-	await new Promise((resolve, reject) => {
-		readStream.on("end", resolve);
-		readStream.on("error", reject);
-	});
+	let startTimeOffsetMs;
+	if (probe.format.start_time && Number(probe.format.start_time) !== 0) {
+		startTimeOffsetMs = Number(probe.format.start_time) * 1e3;
+		log(`Extracted format start_time offset: ${probe.format.start_time}s (${startTimeOffsetMs}ms)`);
+	} else {
+		const videoStream = probe.streams.find((stream) => stream.codec_type === "video");
+		if (videoStream && videoStream.start_time && Number(videoStream.start_time) !== 0) {
+			startTimeOffsetMs = Number(videoStream.start_time) * 1e3;
+			log(`Extracted video stream start_time offset: ${videoStream.start_time}s (${startTimeOffsetMs}ms)`);
+		} else log("No format/stream timing offset found - will detect from composition time");
+	}
+	log(`Generating track fragment index for ${absolutePath} using single-track approach`);
 	const trackFragmentIndexes = {};
-	const trackByteOffsets = {};
-	for await (const fragment of mp4File.fragmentIterator()) {
-		const track = mp4File.getInfo().tracks.find((track$1) => track$1.id === fragment.track);
-		if (!track) throw new Error("Track not found");
-		if (fragment.segment === "init") {
-			trackByteOffsets[fragment.track] = fragment.data.byteLength;
-			if (track?.type === "video") {
-				const videoTrack = mp4File.getInfo().videoTracks.find((track$1) => track$1.id === fragment.track);
-				if (!videoTrack) throw new Error("Video track not found");
-				trackFragmentIndexes[fragment.track] = {
-					track: fragment.track,
-					type: "video",
-					width: videoTrack.video.width,
-					height: videoTrack.video.height,
-					timescale: track.timescale,
-					sample_count: videoTrack.nb_samples,
-					codec: videoTrack.codec,
-					duration: videoTrack.duration,
-					initSegment: {
-						offset: 0,
-						size: fragment.data.byteLength
-					},
-					segments: []
-				};
-			}
-			if (track?.type === "audio") {
-				const audioTrack = mp4File.getInfo().audioTracks.find((track$1) => track$1.id === fragment.track);
-				if (!audioTrack) throw new Error("Audio track not found");
-				trackFragmentIndexes[fragment.track] = {
-					track: fragment.track,
-					type: "audio",
-					channel_count: audioTrack.audio.channel_count,
-					sample_rate: audioTrack.audio.sample_rate,
-					sample_size: audioTrack.audio.sample_size,
-					sample_count: audioTrack.nb_samples,
-					timescale: track.timescale,
-					codec: audioTrack.codec,
-					duration: audioTrack.duration,
-					initSegment: {
-						offset: 0,
-						size: fragment.data.byteLength
-					},
-					segments: []
-				};
-			}
-		} else {
-			const fragmentIndex = trackFragmentIndexes[fragment.track];
-			if (trackByteOffsets[fragment.track] === void 0) throw new Error("Fragment index not found");
-			if (!fragmentIndex) throw new Error("Fragment index not found");
-			fragmentIndex.duration += fragment.duration;
-			fragmentIndex.segments.push({
-				cts: fragment.cts,
-				dts: fragment.dts,
-				duration: fragment.duration,
-				offset: trackByteOffsets[fragment.track],
-				size: fragment.data.byteLength
-			});
-			trackByteOffsets[fragment.track] += fragment.data.byteLength;
-		}
+	for (let streamIndex = 0; streamIndex < probe.streams.length; streamIndex++) {
+		const stream = probe.streams[streamIndex];
+		if (stream.codec_type !== "audio" && stream.codec_type !== "video") continue;
+		const trackId = streamIndex + 1;
+		log(`Processing track ${trackId} (${stream.codec_type})`);
+		const trackStream = probe.createTrackReadstream(streamIndex);
+		const trackIdMapping = { 1: trackId };
+		const singleTrackIndexes = await generateTrackFragmentIndexMediabunny(trackStream, startTimeOffsetMs, trackIdMapping);
+		Object.assign(trackFragmentIndexes, singleTrackIndexes);
 	}
 	return trackFragmentIndexes;
 };

package/dist/truncateDecimal.d.ts

@@ -0,0 +1 @@
+export declare function truncateDecimal(num: number, decimals: number): number;

package/dist/truncateDecimal.js

@@ -0,0 +1,5 @@
+function truncateDecimal(num, decimals) {
+	const factor = 10 ** decimals;
+	return Math.trunc(num * factor) / factor;
+}
+export { truncateDecimal };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@editframe/assets",
-  "version": "0.17.6-beta.0",
+  "version": "0.18.7-beta.0",
   "description": "",
   "exports": {
     ".": {
@@ -9,18 +9,6 @@
         "default": "./dist/index.js"
       }
     },
-    "./EncodedAsset.js": {
-      "import": {
-        "types": "./dist/EncodedAsset.d.ts",
-        "default": "./dist/EncodedAsset.js"
-      }
-    },
-    "./MP4File.js": {
-      "import": {
-        "types": "./dist/MP4File.d.ts",
-        "default": "./dist/MP4File.js"
-      }
-    },
     "./types.json": {
       "import": {
         "default": "./types.json"
@@ -38,7 +26,7 @@
   "license": "UNLICENSED",
   "dependencies": {
     "debug": "^4.3.5",
-    "mp4box": "^0.5.2",
+    "mediabunny": "^1.5.0",
     "ora": "^8.0.1",
     "zod": "^3.23.8"
   },

package/src/tasks/generateTrack.test.ts

@@ -0,0 +1,90 @@
+import { test, describe, assert } from "vitest";
+import { generateTrackFromPath } from "./generateTrack";
+import { Writable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+
+describe("generateTrack (updated with Mediabunny)", () => {
+  test("should generate video track using Mediabunny backend", async () => {
+    const trackStream = await generateTrackFromPath("test-assets/10s-bars.mp4", 1);
+
+    // Collect the generated track data
+    const chunks: Buffer[] = [];
+    const dest = new Writable({
+      write(chunk, _encoding, callback) {
+        chunks.push(chunk);
+        callback();
+      }
+    });
+
+    await pipeline(trackStream, dest);
+
+    // Verify we got MP4 data
+    assert.isAbove(chunks.length, 0, "Should generate MP4 chunks");
+    const totalSize = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    assert.isAbove(totalSize, 1000, "Should generate substantial MP4 data");
+
+    // Verify it's valid MP4 by checking for ftyp box
+    const allData = Buffer.concat(chunks);
+    const ftypIndex = allData.indexOf('ftyp');
+    assert.isAbove(ftypIndex, -1, "Should contain ftyp box (valid MP4)");
+
+    console.log(`Generated ${totalSize} bytes for video track`);
+  }, 15000);
+
+  test("should generate audio track using Mediabunny backend", async () => {
+    const trackStream = await generateTrackFromPath("test-assets/10s-bars.mp4", 2);
+
+    // Collect the generated track data
+    const chunks: Buffer[] = [];
+    const dest = new Writable({
+      write(chunk, _encoding, callback) {
+        chunks.push(chunk);
+        callback();
+      }
+    });
+
+    await pipeline(trackStream, dest);
+
+    // Verify we got MP4 data
+    assert.isAbove(chunks.length, 0, "Should generate MP4 chunks");
+    const totalSize = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    assert.isAbove(totalSize, 1000, "Should generate substantial MP4 data");
+
+    // Verify it's valid MP4 by checking for ftyp box
+    const allData = Buffer.concat(chunks);
+    const ftypIndex = allData.indexOf('ftyp');
+    assert.isAbove(ftypIndex, -1, "Should contain ftyp box (valid MP4)");
+
+    console.log(`Generated ${totalSize} bytes for audio track`);
+  }, 15000);
+
+  test("should handle invalid track IDs gracefully", async () => {
+    try {
+      await generateTrackFromPath("test-assets/frame-count.mp4", 5);
+      assert.fail("Should have thrown for invalid track ID");
+    } catch (error) {
+      assert.instanceOf(error, Error);
+      assert.include(error.message, "Track 5 not found");
+    }
+  });
+
+  test("should work with single track files", async () => {
+    const trackStream = await generateTrackFromPath("test-assets/frame-count.mp4", 1);
+
+    const chunks: Buffer[] = [];
+    const dest = new Writable({
+      write(chunk, _encoding, callback) {
+        chunks.push(chunk);
+        callback();
+      }
+    });
+
+    await pipeline(trackStream, dest);
+
+    const totalSize = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    assert.isAbove(totalSize, 1000, "Should generate data for single track file");
+
+    console.log(`Generated ${totalSize} bytes for single track file`);
+  }, 15000);
+});
+

package/src/tasks/generateTrack.ts

@@ -1,61 +1,20 @@
 import { idempotentTask } from "../idempotentTask.js";
-import { MP4File } from "../MP4File.js";
 import debug from "debug";
-import { mp4FileWritable } from "../mp4FileWritable.js";
-import { PassThrough } from "node:stream";
 import { basename } from "node:path";
-import { Probe } from "../Probe.js";
+import { generateTrackFromPathMediabunny } from "../generateTrackMediabunny.js";
 
 export const generateTrackFromPath = async (
   absolutePath: string,
   trackId: number,
 ) => {
   const log = debug("ef:generateTrackFragment");
-  const probe = await Probe.probePath(absolutePath);
-  const readStream = probe.createConformingReadstream();
-  const mp4File = new MP4File();
-  const trackStream = new PassThrough();
+  log(`Generating track ${trackId} for ${absolutePath} using Mediabunny`);
 
-  log(`Generating track for ${absolutePath}`);
+  // Use the new Mediabunny-based implementation
+  const result = await generateTrackFromPathMediabunny(absolutePath, trackId);
 
-  // Set up pipe and processing of fragments
-  readStream.pipe(mp4FileWritable(mp4File));
-
-  // Process fragments as they become available
-  (async () => {
-    try {
-      let bytesWritten = 0;
-      for await (const fragment of mp4File.fragmentIterator()) {
-        log("Writing fragment", fragment);
-        if (fragment.track === trackId) {
-          const written = trackStream.write(
-            Buffer.from(fragment.data),
-            "binary",
-          );
-          if (!written) {
-            log(`Waiting for drain for track ${trackId}`);
-            await new Promise((resolve) => trackStream.once("drain", resolve));
-          }
-          bytesWritten += fragment.data.byteLength;
-        }
-        // There is a race condition where the mp4file writable doesn't correctly wait for the whole readSTream
-        // Waiting for data/end events seems to fix it
-        // FIXME: This is a hack, we should fix the root issue in MP4File
-        if (!readStream.readableEnded) {
-          await Promise.race([
-            new Promise((resolve) => readStream.once("end", resolve)),
-            new Promise((resolve) => readStream.once("data", resolve)),
-          ]);
-        }
-      }
-
-      trackStream.end();
-    } catch (error) {
-      trackStream.destroy(error as Error);
-    }
-  })();
-
-  return trackStream;
+  // Return just the stream for compatibility with existing API
+  return result.stream;
 };
 
 export const generateTrackTask = idempotentTask({
@@ -76,7 +35,7 @@ export const generateTrack = async (
     );
     if (trackId === null) {
       throw new Error(
-        "No trackId provided. IT must be specified in the query string: ?trackId=0",
+        "No trackId provided. It must be specified in the query string: ?trackId=1 (for video) or ?trackId=2 (for audio)",
       );
     }
     return await generateTrackTask(cacheRoot, absolutePath, Number(trackId));