@editframe/assets 0.6.0-beta.1

package/dist/lib/av/MP4File.cjs

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const MP4Box = require("mp4box");
+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);
+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.log("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;
+            }
+            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.dts - startSample.dts + 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/av/MP4File.js

@@ -0,0 +1,165 @@
+import * as MP4Box from "mp4box";
+class MP4File extends MP4Box.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.log("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;
+            }
+            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.dts - startSample.dts + 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 = [];
+  }
+}
+export {
+  MP4File
+};

package/dist/lib/util/execPromise.cjs

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

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

package/dist/packages/assets/src/Probe.cjs

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const node_child_process = require("node:child_process");
+const execPromise = require("../../../lib/util/execPromise.cjs");
+const z = require("zod");
+const node_fs = require("node:fs");
+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 z__namespace = /* @__PURE__ */ _interopNamespaceDefault(z);
+const AudioStreamSchema = z__namespace.object({
+  index: z__namespace.number(),
+  codec_name: z__namespace.string(),
+  codec_long_name: z__namespace.string(),
+  codec_type: z__namespace.literal("audio"),
+  codec_tag_string: z__namespace.string(),
+  codec_tag: z__namespace.string(),
+  sample_fmt: z__namespace.string(),
+  sample_rate: z__namespace.string(),
+  channels: z__namespace.number(),
+  channel_layout: z__namespace.string(),
+  bits_per_sample: z__namespace.number(),
+  initial_padding: z__namespace.number().optional(),
+  r_frame_rate: z__namespace.string(),
+  avg_frame_rate: z__namespace.string(),
+  time_base: z__namespace.string(),
+  start_pts: z__namespace.number(),
+  start_time: z__namespace.coerce.number(),
+  duration_ts: z__namespace.number(),
+  duration: z__namespace.coerce.number(),
+  bit_rate: z__namespace.string(),
+  disposition: z__namespace.record(z__namespace.unknown())
+});
+const VideoStreamSchema = z__namespace.object({
+  index: z__namespace.number(),
+  codec_name: z__namespace.string(),
+  codec_long_name: z__namespace.string(),
+  codec_type: z__namespace.literal("video"),
+  codec_tag_string: z__namespace.string(),
+  codec_tag: z__namespace.string(),
+  width: z__namespace.number(),
+  height: z__namespace.number(),
+  coded_width: z__namespace.number(),
+  coded_height: z__namespace.number(),
+  r_frame_rate: z__namespace.string(),
+  avg_frame_rate: z__namespace.string(),
+  time_base: z__namespace.string(),
+  start_pts: z__namespace.number().optional(),
+  start_time: z__namespace.coerce.number().optional(),
+  duration_ts: z__namespace.number().optional(),
+  duration: z__namespace.coerce.number().optional(),
+  bit_rate: z__namespace.string().optional(),
+  disposition: z__namespace.record(z__namespace.unknown())
+});
+const ProbeFormatSchema = z__namespace.object({
+  filename: z__namespace.string(),
+  nb_streams: z__namespace.number(),
+  nb_programs: z__namespace.number(),
+  format_name: z__namespace.string(),
+  format_long_name: z__namespace.string(),
+  start_time: z__namespace.string().optional(),
+  duration: z__namespace.string().optional(),
+  size: z__namespace.string(),
+  bit_rate: z__namespace.string().optional(),
+  probe_score: z__namespace.number()
+});
+const StreamSchema = z__namespace.discriminatedUnion("codec_type", [
+  AudioStreamSchema,
+  VideoStreamSchema
+]);
+const ProbeSchema = z__namespace.object({
+  streams: z__namespace.array(StreamSchema),
+  format: ProbeFormatSchema
+});
+class Probe {
+  constructor(absolutePath, rawData) {
+    this.absolutePath = absolutePath;
+    this.data = ProbeSchema.parse(rawData);
+  }
+  static async probePath(absolutePath) {
+    const probeResult = await execPromise.execPromise(
+      `ffprobe -v error -show_format -show_streams -of json ${absolutePath}`
+    );
+    const json = JSON.parse(probeResult.stdout);
+    return new Probe(absolutePath, json);
+  }
+  get audioStreams() {
+    return this.data.streams.filter(
+      (stream) => stream.codec_type === "audio"
+    );
+  }
+  get videoStreams() {
+    return this.data.streams.filter(
+      (stream) => stream.codec_type === "video"
+    );
+  }
+  get streams() {
+    return this.data.streams;
+  }
+  get format() {
+    return this.data.format;
+  }
+  get mustReencodeAudio() {
+    return this.audioStreams.some((stream) => stream.codec_name !== "aac");
+  }
+  get mustReencodeVideo() {
+    return false;
+  }
+  get mustRemux() {
+    return this.format.format_name !== "mp4";
+  }
+  get hasAudio() {
+    return this.audioStreams.length > 0;
+  }
+  get hasVideo() {
+    return this.videoStreams.length > 0;
+  }
+  get isAudioOnly() {
+    return this.audioStreams.length > 0 && this.videoStreams.length === 0;
+  }
+  get isVideoOnly() {
+    return this.audioStreams.length === 0 && this.videoStreams.length > 0;
+  }
+  get mustProcess() {
+    return this.mustReencodeAudio || this.mustReencodeVideo || this.mustRemux;
+  }
+  get ffmpegAudioOptions() {
+    if (!this.hasAudio) {
+      return [];
+    }
+    if (this.mustReencodeAudio) {
+      return [
+        "-c:a",
+        "aac",
+        "-b:a",
+        "192k",
+        "-ar",
+        "48000"
+      ];
+    }
+    return ["-c:a", "copy"];
+  }
+  get ffmpegVideoOptions() {
+    if (!this.hasVideo) {
+      return [];
+    }
+    if (this.mustReencodeVideo) {
+      return [
+        "-c:v",
+        "h264",
+        "-pix_fmt",
+        "yuv420p"
+      ];
+    }
+    return ["-c:v", "copy"];
+  }
+  createConformingReadstream() {
+    if (!this.mustProcess) {
+      return node_fs.createReadStream(this.absolutePath);
+    }
+    return node_child_process.spawn("ffmpeg", [
+      "-i",
+      this.absolutePath,
+      ...this.ffmpegAudioOptions,
+      ...this.ffmpegVideoOptions,
+      "-f",
+      "mp4",
+      "-frag_duration",
+      "8000000",
+      "-movflags",
+      "frag_keyframe+empty_moov",
+      "pipe:1"
+    ], {
+      stdio: ["ignore", "pipe", "inherit"]
+    }).stdout;
+  }
+}
+exports.AudioStreamSchema = AudioStreamSchema;
+exports.Probe = Probe;
+exports.VideoStreamSchema = VideoStreamSchema;