@editframe/assets 0.6.0-beta.15 → 0.6.0-beta.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@editframe/assets",
-  "version": "0.6.0-beta.15",
+  "version": "0.6.0-beta.17",
   "description": "",
   "exports": {
     ".": {

package/src/tasks/cacheImage.ts

@@ -0,0 +1,22 @@
+import { idempotentTask } from "../idempotentTask";
+import { createReadStream } from "node:fs";
+
+import path from "node:path";
+
+const cacheImageTask = idempotentTask({
+  label: "image",
+  filename: (absolutePath: string) => path.basename(absolutePath),
+  runner: async (absolutePath) => {
+    return createReadStream(absolutePath);
+  },
+});
+
+export const cacheImage = async (cacheRoot: string, absolutePath: string) => {
+  try {
+    return await cacheImageTask(cacheRoot, absolutePath);
+  } catch (error) {
+    console.error(error);
+    console.trace("Error generating track fragment index", error);
+    throw error;
+  }
+};

package/src/tasks/findOrCreateCaptions.ts

@@ -0,0 +1,29 @@
+import { execPromise } from "@/util/execPromise";
+import { idempotentTask } from "../idempotentTask";
+import debug from "debug";
+import { basename } from "node:path";
+
+const log = debug("@ef:generateCaptions");
+
+const generateCaptionData = idempotentTask({
+  label: "captions",
+  filename: (absolutePath) => `${basename(absolutePath)}.captions.json`,
+  runner: async (absolutePath) => {
+    const command = `whisper_timestamped --language en --efficient --output_format vtt ${absolutePath}`;
+    log(`Running command: ${command}`);
+    const { stdout } = await execPromise(command);
+    return stdout;
+  },
+});
+
+export const findOrCreateCaptions = async (
+  cacheRoot: string,
+  absolutePath: string,
+) => {
+  try {
+    return await generateCaptionData(cacheRoot, absolutePath);
+  } catch (error) {
+    console.trace("Error finding or creating captions", error);
+    throw error;
+  }
+};

package/src/tasks/generateTrack.ts

@@ -0,0 +1,61 @@
+import { idempotentTask } from "../idempotentTask";
+import { MP4File } from "@/av/MP4File";
+import debug from "debug";
+import { mp4FileWritable } from "../mp4FileWritable";
+import { PassThrough } from "node:stream";
+import { basename } from "node:path";
+import { Probe } from "../Probe";
+
+const generateTrackTask = idempotentTask({
+  label: "track",
+  filename: (absolutePath: string, trackId: number) =>
+    `${basename(absolutePath)}.track-${trackId}.mp4`,
+  runner: async (absolutePath, trackId: number) => {
+    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);
+    });
+
+    const trackStream = new PassThrough();
+
+    for await (const fragment of mp4File.fragmentIterator()) {
+      if (fragment.track !== trackId) {
+        continue;
+      }
+      trackStream.write(Buffer.from(fragment.data), "binary");
+    }
+    trackStream.end();
+
+    return trackStream;
+  },
+});
+
+export const generateTrack = async (
+  cacheRoot: string,
+  absolutePath: string,
+  url: string,
+) => {
+  try {
+    const trackId = new URL(
+      `http://localhost${url}` ?? "bad-url",
+    ).searchParams.get("trackId");
+    if (trackId === null) {
+      throw new Error(
+        "No trackId provided. IT must be specified in the query string: ?trackId=0",
+      );
+    }
+    return await generateTrackTask(cacheRoot, absolutePath, Number(trackId));
+  } catch (error) {
+    console.error(error);
+    console.trace("Error generating track fragment index", error);
+    throw error;
+  }
+};

package/src/tasks/generateTrackFragmentIndex.ts

@@ -0,0 +1,120 @@
+import { idempotentTask } from "../idempotentTask";
+import { MP4File } from "@/av/MP4File";
+import debug from "debug";
+import { mp4FileWritable } from "../mp4FileWritable";
+import { basename } from "node:path";
+import { Probe, type TrackFragmentIndex } from "../Probe";
+
+const generateTrackFragmentIndexFromPath = async (absolutePath: string) => {
+  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);
+  });
+
+  const trackFragmentIndexes: Record<number, TrackFragmentIndex> = {};
+  const trackByteOffsets: Record<number, number> = {};
+  for await (const fragment of mp4File.fragmentIterator()) {
+    const track = mp4File
+      .getInfo()
+      .tracks.find((track) => track.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) => track.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,
+          duration: 0,
+          initSegment: {
+            offset: 0,
+            size: fragment.data.byteLength,
+          },
+          segments: [],
+        };
+      }
+      if (track?.type === "audio") {
+        const audioTrack = mp4File
+          .getInfo()
+          .audioTracks.find((track) => track.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,
+          duration: 0,
+          initSegment: {
+            offset: 0,
+            size: fragment.data.byteLength,
+          },
+          segments: [],
+        };
+      }
+    } else {
+      const fragmentIndex = trackFragmentIndexes[fragment.track];
+      if (trackByteOffsets[fragment.track] === undefined) {
+        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,
+        // biome-ignore lint/style/noNonNullAssertion: This was checked above
+        offset: trackByteOffsets[fragment.track]!,
+        size: fragment.data.byteLength,
+      });
+      // biome-ignore lint/style/noNonNullAssertion: this was checked above
+      trackByteOffsets[fragment.track]! += fragment.data.byteLength;
+    }
+  }
+  return JSON.stringify(trackFragmentIndexes, null, 2);
+};
+
+const generateTrackFragmentIndexTask = idempotentTask({
+  label: "trackFragmentIndex",
+  filename: (absolutePath) => `${basename(absolutePath)}.tracks.json`,
+  runner: generateTrackFragmentIndexFromPath,
+});
+
+export const generateTrackFragmentIndex = async (
+  cacheRoot: string,
+  absolutePath: string,
+) => {
+  try {
+    return await generateTrackFragmentIndexTask(cacheRoot, absolutePath);
+  } catch (error) {
+    console.trace("Error generating track fragment index", error);
+    throw error;
+  }
+};