@editframe/assets 0.7.0-beta.6 → 0.8.0-beta.1

package/dist/{packages/assets/src/tasks → tasks}/generateTrackFragmentIndex.js

@@ -1,5 +1,5 @@
 import { idempotentTask } from "../idempotentTask.js";
-import { MP4File } from "../../../../lib/av/MP4File.js";
+import { MP4File } from "../MP4File.js";
 import debug from "debug";
 import { mp4FileWritable } from "../mp4FileWritable.js";
 import { basename } from "node:path";
@@ -36,7 +36,8 @@ const generateTrackFragmentIndexFromPath = async (absolutePath) => {
           height: videoTrack.video.height,
           timescale: track.timescale,
           sample_count: videoTrack.nb_samples,
-          duration: 0,
+          codec: videoTrack.codec,
+          duration: videoTrack.duration,
           initSegment: {
             offset: 0,
             size: fragment.data.byteLength
@@ -57,7 +58,8 @@ const generateTrackFragmentIndexFromPath = async (absolutePath) => {
           sample_size: audioTrack.audio.sample_size,
           sample_count: audioTrack.nb_samples,
           timescale: track.timescale,
-          duration: 0,
+          codec: audioTrack.codec,
+          duration: audioTrack.duration,
           initSegment: {
             offset: 0,
             size: fragment.data.byteLength
@@ -85,12 +87,15 @@ const generateTrackFragmentIndexFromPath = async (absolutePath) => {
       trackByteOffsets[fragment.track] += fragment.data.byteLength;
     }
   }
-  return JSON.stringify(trackFragmentIndexes, null, 2);
+  return trackFragmentIndexes;
 };
 const generateTrackFragmentIndexTask = idempotentTask({
   label: "trackFragmentIndex",
   filename: (absolutePath) => `${basename(absolutePath)}.tracks.json`,
-  runner: generateTrackFragmentIndexFromPath
+  runner: async (absolutePath) => {
+    const index = await generateTrackFragmentIndexFromPath(absolutePath);
+    return JSON.stringify(index, null, 2);
+  }
 });
 const generateTrackFragmentIndex = async (cacheRoot, absolutePath) => {
   try {
@@ -101,5 +106,6 @@ const generateTrackFragmentIndex = async (cacheRoot, absolutePath) => {
   }
 };
 export {
-  generateTrackFragmentIndex
+  generateTrackFragmentIndex,
+  generateTrackFragmentIndexFromPath
 };

package/package.json

@@ -1,17 +1,19 @@
 {
   "name": "@editframe/assets",
-  "version": "0.7.0-beta.6",
+  "version": "0.8.0-beta.1",
   "description": "",
   "exports": {
     ".": {
-      "import": {
-        "default": "./dist/packages/assets/src/index.js",
-        "types": "./dist/packages/assets/src/index.d.ts"
-      },
-      "require": {
-        "default": "./dist/packages/assets/src/index.cjs",
-        "types": "./dist/packages/assets/src/index.d.ts"
-      }
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./EncodedAsset.js": {
+      "types": "./dist/EncodedAsset.d.ts",
+      "import": "./dist/EncodedAsset.js"
+    },
+    "./MP4File.js": {
+      "types": "./dist/MP4File.d.ts",
+      "import": "./dist/MP4File.js"
     }
   },
   "type": "module",
@@ -29,8 +31,10 @@
   },
   "devDependencies": {
     "@types/dom-webcodecs": "^0.1.11",
-    "@types/node": "^20.14.9",
+    "@types/node": "^20.14.13",
+    "ora": "^8.0.1",
     "rollup-plugin-tsconfig-paths": "^1.5.2",
+    "typescript": "^5.5.4",
     "vite-plugin-dts": "^3.9.1",
     "vite-tsconfig-paths": "^4.3.2"
   }

package/src/tasks/cacheImage.ts

@@ -1,4 +1,4 @@
-import { idempotentTask } from "../idempotentTask";
+import { idempotentTask } from "../idempotentTask.ts";
 import { createReadStream } from "node:fs";
 
 import path from "node:path";

package/src/tasks/findOrCreateCaptions.ts

@@ -1,19 +1,26 @@
-import { execPromise } from "@/util/execPromise";
-import { idempotentTask } from "../idempotentTask";
-import debug from "debug";
 import { basename } from "node:path";
+import { promisify } from "node:util";
+import { exec } from "node:child_process";
+
+import debug from "debug";
+
+import { idempotentTask } from "../idempotentTask.ts";
+
+const execPromise = promisify(exec);
 
 const log = debug("ef:generateCaptions");
 
-const generateCaptionData = idempotentTask({
+export const generateCaptionDataFromPath = async (absolutePath: string) => {
+  const command = `whisper_timestamped --language en --efficient --output_format vtt ${absolutePath}`;
+  log(`Running command: ${command}`);
+  const { stdout } = await execPromise(command);
+  return stdout;
+};
+
+const generateCaptionDataTask = 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;
-  },
+  runner: generateCaptionDataFromPath,
 });
 
 export const findOrCreateCaptions = async (
@@ -21,7 +28,7 @@ export const findOrCreateCaptions = async (
   absolutePath: string,
 ) => {
   try {
-    return await generateCaptionData(cacheRoot, absolutePath);
+    return await generateCaptionDataTask(cacheRoot, absolutePath);
   } catch (error) {
     console.trace("Error finding or creating captions", error);
     throw error;

package/src/tasks/generateTrack.ts

@@ -1,41 +1,46 @@
-import { idempotentTask } from "../idempotentTask";
-import { MP4File } from "@/av/MP4File";
+import { idempotentTask } from "../idempotentTask.ts";
+import { MP4File } from "../MP4File.ts";
 import debug from "debug";
-import { mp4FileWritable } from "../mp4FileWritable";
+import { mp4FileWritable } from "../mp4FileWritable.ts";
 import { PassThrough } from "node:stream";
 import { basename } from "node:path";
-import { Probe } from "../Probe";
+import { Probe } from "../Probe.ts";
 
-const generateTrackTask = idempotentTask({
+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();
+
+  log(`Generating track 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 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;
-  },
+  runner: generateTrackFromPath,
 });
 
 export const generateTrack = async (

package/src/tasks/generateTrackFragmentIndex.ts

@@ -1,11 +1,13 @@
-import { idempotentTask } from "../idempotentTask";
-import { MP4File } from "@/av/MP4File";
+import { idempotentTask } from "../idempotentTask.ts";
+import { MP4File } from "../MP4File.ts";
 import debug from "debug";
-import { mp4FileWritable } from "../mp4FileWritable";
+import { mp4FileWritable } from "../mp4FileWritable.ts";
 import { basename } from "node:path";
-import { Probe, type TrackFragmentIndex } from "../Probe";
+import { Probe, type TrackFragmentIndex } from "../Probe.ts";
 
-const generateTrackFragmentIndexFromPath = async (absolutePath: string) => {
+export const generateTrackFragmentIndexFromPath = async (
+  absolutePath: string,
+) => {
   const log = debug("ef:generateTrackFragment");
   const probe = await Probe.probePath(absolutePath);
   const readStream = probe.createConformingReadstream();
@@ -46,7 +48,8 @@ const generateTrackFragmentIndexFromPath = async (absolutePath: string) => {
           height: videoTrack.video.height,
           timescale: track.timescale,
           sample_count: videoTrack.nb_samples,
-          duration: 0,
+          codec: videoTrack.codec,
+          duration: videoTrack.duration,
           initSegment: {
             offset: 0,
             size: fragment.data.byteLength,
@@ -69,7 +72,8 @@ const generateTrackFragmentIndexFromPath = async (absolutePath: string) => {
           sample_size: audioTrack.audio.sample_size,
           sample_count: audioTrack.nb_samples,
           timescale: track.timescale,
-          duration: 0,
+          codec: audioTrack.codec,
+          duration: audioTrack.duration,
           initSegment: {
             offset: 0,
             size: fragment.data.byteLength,
@@ -98,13 +102,16 @@ const generateTrackFragmentIndexFromPath = async (absolutePath: string) => {
       trackByteOffsets[fragment.track]! += fragment.data.byteLength;
     }
   }
-  return JSON.stringify(trackFragmentIndexes, null, 2);
+  return trackFragmentIndexes;
 };
 
 const generateTrackFragmentIndexTask = idempotentTask({
   label: "trackFragmentIndex",
   filename: (absolutePath) => `${basename(absolutePath)}.tracks.json`,
-  runner: generateTrackFragmentIndexFromPath,
+  runner: async (absolutePath: string) => {
+    const index = await generateTrackFragmentIndexFromPath(absolutePath);
+    return JSON.stringify(index, null, 2);
+  },
 });
 
 export const generateTrackFragmentIndex = async (

package/dist/lib/av/MP4File.cjs

@@ -1,187 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const MP4Box = require("mp4box");
-const debug = require("debug");
-function _interopNamespaceDefault(e) {
-  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
-  if (e) {
-    for (const k in e) {
-      if (k !== "default") {
-        const d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: () => e[k]
-        });
-      }
-    }
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-const MP4Box__namespace = /* @__PURE__ */ _interopNamespaceDefault(MP4Box);
-const log = debug("ef:av:mp4file");
-class MP4File extends MP4Box__namespace.ISOFile {
-  constructor() {
-    super(...arguments);
-    this.readyPromise = new Promise((resolve, reject) => {
-      this.onReady = () => resolve();
-      this.onError = reject;
-    });
-    this.waitingForSamples = [];
-    this._hasSeenLastSamples = false;
-    this._arrayBufferFileStart = 0;
-  }
-  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 = {};
-    for await (const segment of this.fragmentIterator()) {
-      (trackBuffers[segment.track] ??= []).push(segment.data);
-    }
-    return trackBuffers;
-  }
-  async *fragmentIterator() {
-    await this.readyPromise;
-    const trackInfo = {};
-    for (const videoTrack of this.getInfo().videoTracks) {
-      trackInfo[videoTrack.id] = { index: 0, complete: false };
-      this.setSegmentOptions(videoTrack.id, null, {
-        rapAlignement: true
-      });
-    }
-    for (const audioTrack of this.getInfo().audioTracks) {
-      trackInfo[audioTrack.id] = { index: 0, complete: false };
-      const sampleRate = audioTrack.audio.sample_rate;
-      const probablePacketSize = 1024;
-      const probableFourSecondsOfSamples = Math.ceil(
-        sampleRate / probablePacketSize * 4
-      );
-      this.setSegmentOptions(audioTrack.id, null, {
-        nbSamples: probableFourSecondsOfSamples
-      });
-    }
-    const initSegments = this.initializeSegmentation();
-    for (const initSegment of initSegments) {
-      yield {
-        track: initSegment.id,
-        segment: "init",
-        data: initSegment.buffer,
-        complete: false
-      };
-    }
-    const fragmentStartSamples = {};
-    let finishedReading = false;
-    const allTracksFinished = () => {
-      for (const fragmentedTrack of this.fragmentedTracks) {
-        if (!trackInfo[fragmentedTrack.id]?.complete) {
-          return false;
-        }
-      }
-      return true;
-    };
-    while (!(finishedReading && allTracksFinished())) {
-      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;
-          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 = (
-            // if rapAlignement is true, we emit a fragment when we have a rap sample coming up next
-            fragTrak.rapAlignement === true && nextSample?.is_sync || // if rapAlignement is false, we emit a fragment when we have the required number of samples
-            !fragTrak.rapAlignement && trak.nextSample % fragTrak.nb_samples === 0 || // // if this is the last sample, we emit the fragment
-            // finished ||
-            // if we have more samples than the number of samples requested, we emit the fragment
-            trak.nextSample >= trak.samples.length
-          );
-          if (emitSegment) {
-            const trackInfoForFrag = trackInfo[fragTrak.id];
-            if (!trackInfoForFrag) {
-              throw new Error("trackInfoForFrag is undefined");
-            }
-            if (trak.nextSample >= trak.samples.length) {
-              trackInfoForFrag.complete = true;
-            }
-            log(
-              `Yielding fragment #${trackInfoForFrag.index} for track=${fragTrak.id}`
-            );
-            const startSample = fragmentStartSamples[fragTrak.id];
-            const endSample = trak.samples[trak.nextSample - 1];
-            if (!startSample || !endSample) {
-              throw new Error("startSample or endSample is undefined");
-            }
-            yield {
-              track: fragTrak.id,
-              segment: trackInfoForFrag.index,
-              data: fragTrak.segmentStream.buffer,
-              complete: trackInfoForFrag.complete,
-              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();
-    }
-  }
-  waitForMoreSamples() {
-    if (this._hasSeenLastSamples) {
-      return Promise.resolve(true);
-    }
-    return new Promise((resolve) => {
-      this.waitingForSamples.push(resolve);
-    });
-  }
-  processSamples(last) {
-    this._hasSeenLastSamples = last;
-    for (const observer of this.waitingForSamples) {
-      observer(last);
-    }
-    this.waitingForSamples = [];
-  }
-}
-exports.MP4File = MP4File;

package/dist/lib/util/execPromise.cjs

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const node_child_process = require("node:child_process");
-const node_util = require("node:util");
-const execPromise = node_util.promisify(node_child_process.exec);
-exports.execPromise = execPromise;

package/dist/lib/util/execPromise.js

@@ -1,6 +0,0 @@
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-const execPromise = promisify(exec);
-export {
-  execPromise
-};