@editframe/elements 0.5.0-beta.8 → 0.6.0-beta.1

package/dist/{editor/util/EncodedAsset/EncodedAsset.mjs → lib/av/EncodedAsset.js}

@@ -1,15 +1,14 @@
-import { memoize } from "../../../util/memoize.mjs";
 import * as MP4Box from "mp4box";
-import { MP4File } from "../MP4File.mjs";
+import { memoize } from "../util/memoize.js";
+import { MP4File } from "./MP4File.js";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  var result = __getOwnPropDesc(target, key);
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result)
-    __defProp(target, key, result);
+      result = decorator(target, key, result) || result;
+  if (result) __defProp(target, key, result);
   return result;
 };
 const BUFFER_SIZE = 10;
@@ -49,7 +48,7 @@ class ISOFileAsset extends FileAsset {
 }
 __decorateClass([
   memoize
-], ISOFileAsset.prototype, "fileInfo", 1);
+], ISOFileAsset.prototype, "fileInfo");
 const _VideoAsset = class _VideoAsset2 extends ISOFileAsset {
   constructor(localName, mp4boxFile, file) {
     super(localName, file, mp4boxFile);
@@ -112,11 +111,12 @@ const _VideoAsset = class _VideoAsset2 extends ISOFileAsset {
     this.requestedSampleNumber = 0;
     this.outCursor = 0;
     this.sampleCursor = 0;
-    this.decodedFrames.forEach((frame) => {
+    for (const frame of this.decodedFrames) {
       frame.close();
-    });
+    }
     this.decodedFrames = [];
     this.lastDecodedSample = void 0;
+    this.lastSoughtFrame?.close();
     this.lastSoughtFrame = void 0;
   }
   addEventListener(type, callback) {
@@ -127,9 +127,9 @@ const _VideoAsset = class _VideoAsset2 extends ISOFileAsset {
     this.eventListeners[type]?.delete(callback);
   }
   emit(type, ...args) {
-    this.eventListeners[type]?.forEach((listener) => {
+    for (const listener of this.eventListeners[type] ?? []) {
       listener(...args);
-    });
+    }
   }
   get videoCodec() {
     if (!this.defaultVideoTrack) {
@@ -220,10 +220,15 @@ const _VideoAsset = class _VideoAsset2 extends ISOFileAsset {
   }
   async decodeSlice(start, end) {
     const samples = this.samples.slice(start, end + 1);
-    const sliceStart = samples[0].offset;
-    const sliceEnd = samples[samples.length - 1].offset + samples[samples.length - 1].size;
+    const firstSample = samples[0];
+    const lastSample = samples[samples.length - 1];
+    if (!firstSample || !lastSample) {
+      throw new Error("Samples not found");
+    }
+    const sliceStart = firstSample.offset;
+    const sliceEnd = lastSample.offset + lastSample.size;
     const buffer = await this.file.slice(sliceStart, sliceEnd).arrayBuffer();
-    const firstSampleOffset = samples[0].offset;
+    const firstSampleOffset = firstSample.offset;
     for (let i = start; i <= end; i++) {
       await this.waitUntilVideoQueueDrained();
       const sample = this.getSample(i);
@@ -246,7 +251,7 @@ const _VideoAsset = class _VideoAsset2 extends ISOFileAsset {
     if (!this.defaultVideoTrack) {
       throw new Error("No default video track found");
     }
-    let description;
+    let description = new Uint8Array();
     const trak = this.mp4boxFile.getTrackById(this.defaultVideoTrack.id);
     for (const entry of trak.mdia.minf.stbl.stsd.entries) {
       if (entry.avcC ?? entry.hvcC) {
@@ -268,7 +273,6 @@ const _VideoAsset = class _VideoAsset2 extends ISOFileAsset {
       codec: this.defaultVideoTrack.codec,
       codedWidth: this.defaultVideoTrack.track_width,
       codedHeight: this.defaultVideoTrack.track_height,
-      // hardwareAcceleration: "prefer-hardware",
       optimizeForLatency: true,
       description
     };
@@ -287,7 +291,7 @@ const _VideoAsset = class _VideoAsset2 extends ISOFileAsset {
   getSample(index = -1) {
     const sample = this.samples?.[index];
     if (!sample) {
-      throw new Error("Sample not found at index " + index);
+      throw new Error(`Sample not found at index ${index}`);
     }
     return sample;
   }
@@ -380,9 +384,9 @@ const _VideoAsset = class _VideoAsset2 extends ISOFileAsset {
     if (this.seekingWillGoBackwards(seconds)) {
       console.log("BACKWARDS FLUSH");
       await this.videoDecoder.flush();
-      this.decodedFrames.forEach((frame2) => {
+      for (const frame2 of this.decodedFrames) {
         frame2.close();
-      });
+      }
       this.decodedFrames = [];
       let syncSampleNumber = sample.number;
       while (!this.getSample(syncSampleNumber).is_sync) {
@@ -406,6 +410,9 @@ const _VideoAsset = class _VideoAsset2 extends ISOFileAsset {
     }
     this.removeEventListener("frame", maybeFrame);
     if (frame) {
+      if (this.lastSoughtFrame && !this.decodedFrames.includes(this.lastSoughtFrame)) {
+        this.lastSoughtFrame.close();
+      }
       this.lastSoughtFrame = frame;
     }
     return frame;
@@ -422,25 +429,25 @@ const _VideoAsset = class _VideoAsset2 extends ISOFileAsset {
 };
 __decorateClass([
   memoize
-], _VideoAsset.prototype, "editsOffset", 1);
+], _VideoAsset.prototype, "editsOffset");
 __decorateClass([
   memoize
-], _VideoAsset.prototype, "timescale", 1);
+], _VideoAsset.prototype, "timescale");
 __decorateClass([
   memoize
-], _VideoAsset.prototype, "samples", 1);
+], _VideoAsset.prototype, "samples");
 __decorateClass([
   memoize
-], _VideoAsset.prototype, "displayOrderedSamples", 1);
+], _VideoAsset.prototype, "displayOrderedSamples");
 __decorateClass([
   memoize
-], _VideoAsset.prototype, "defaultVideoTrack", 1);
+], _VideoAsset.prototype, "defaultVideoTrack");
 __decorateClass([
   memoize
-], _VideoAsset.prototype, "defaultVideoTrak", 1);
+], _VideoAsset.prototype, "defaultVideoTrak");
 __decorateClass([
   memoize
-], _VideoAsset.prototype, "duration", 1);
+], _VideoAsset.prototype, "duration");
 let VideoAsset = _VideoAsset;
 const _AudioAsset = class _AudioAsset2 extends ISOFileAsset {
   static async createFromReadableStream(id, stream, file) {
@@ -493,19 +500,19 @@ const _AudioAsset = class _AudioAsset2 extends ISOFileAsset {
 };
 __decorateClass([
   memoize
-], _AudioAsset.prototype, "defaultAudioTrack", 1);
+], _AudioAsset.prototype, "defaultAudioTrack");
 __decorateClass([
   memoize
-], _AudioAsset.prototype, "defaultAudioTrak", 1);
+], _AudioAsset.prototype, "defaultAudioTrak");
 __decorateClass([
   memoize
-], _AudioAsset.prototype, "audioCodec", 1);
+], _AudioAsset.prototype, "audioCodec");
 __decorateClass([
   memoize
-], _AudioAsset.prototype, "samplerate", 1);
+], _AudioAsset.prototype, "samplerate");
 __decorateClass([
   memoize
-], _AudioAsset.prototype, "channelCount", 1);
+], _AudioAsset.prototype, "channelCount");
 const _ImageAsset = class _ImageAsset2 extends FileAsset {
   static async createFromReadableStream(id, file) {
     if (file.size === 0) {
@@ -525,10 +532,10 @@ const _ImageAsset = class _ImageAsset2 extends FileAsset {
 };
 __decorateClass([
   memoize
-], _ImageAsset.prototype, "objectUrl", 1);
+], _ImageAsset.prototype, "objectUrl");
 __decorateClass([
   memoize
-], _ImageAsset.prototype, "format", 1);
+], _ImageAsset.prototype, "format");
 export {
   AssetNotAvailableLocally,
   FileAsset,

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/{editor/util/MP4File.mjs → lib/av/MP4File.js}

@@ -28,7 +28,7 @@ class MP4File extends MP4Box.ISOFile {
    * Fragments all tracks in a file into separate array buffers.
    */
   async fragmentAllTracks() {
-    let trackBuffers = {};
+    const trackBuffers = {};
     for await (const segment of this.fragmentIterator()) {
       (trackBuffers[segment.track] ??= []).push(segment.data);
     }
@@ -82,60 +82,64 @@ class MP4File extends MP4Box.ISOFile {
         if (trak.samples === void 0) {
           throw new Error("trak.samples is undefined");
         }
-        eachSample:
-          while (trak.nextSample < trak.samples.length) {
-            let result = void 0;
-            if (trak?.samples[trak.nextSample]) {
-              fragmentStartSamples[fragTrak.id] ||= trak.samples[trak.nextSample];
-            }
-            try {
-              result = this.createFragment(
-                fragTrak.id,
-                trak.nextSample,
-                fragTrak.segmentStream
-              );
-            } catch (error) {
-              console.log("Failed to createFragment", error);
+        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 (result) {
-              fragTrak.segmentStream = result;
-              trak.nextSample++;
-            } else {
-              finishedReading = await this.waitForMoreSamples();
-              break eachSample;
+            if (trak.nextSample >= trak.samples.length) {
+              trackInfoForFrag.complete = true;
             }
-            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) {
-              if (trak.nextSample >= trak.samples.length) {
-                trackInfo[fragTrak.id].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: trackInfo[fragTrak.id].index,
-                data: fragTrak.segmentStream.buffer,
-                complete: trackInfo[fragTrak.id].complete,
-                cts: startSample.cts,
-                dts: startSample.dts,
-                duration: endSample.dts - startSample.dts + endSample.duration
-              };
-              trackInfo[fragTrak.id].index += 1;
-              fragTrak.segmentStream = null;
-              delete fragmentStartSamples[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.dts - startSample.dts + endSample.duration
+            };
+            trackInfoForFrag.index += 1;
+            fragTrak.segmentStream = null;
+            delete fragmentStartSamples[fragTrak.id];
           }
+        }
       }
       finishedReading = await this.waitForMoreSamples();
     }

package/dist/lib/av/msToTimeCode.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const msToTimeCode = (ms, subSecond = false) => {
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const pad = (num) => num.toString().padStart(2, "0");
+  let timecode = `${pad(hours)}:${pad(minutes % 60)}:${pad(seconds % 60)}`;
+  if (subSecond) {
+    const subSeconds = Math.floor(ms % 1e3 / 10);
+    timecode += `.${subSeconds.toString().padStart(2, "0")}`;
+  }
+  return timecode;
+};
+exports.msToTimeCode = msToTimeCode;

package/dist/lib/util/awaitMicrotask.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const awaitMicrotask = async () => {
+  await new Promise((resolve) => {
+    queueMicrotask(resolve);
+  });
+};
+exports.awaitMicrotask = awaitMicrotask;

package/dist/lib/util/memoize.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+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);
+  };
+};
+exports.memoize = memoize;

package/dist/{util/memoize.mjs → lib/util/memoize.js}

@@ -1,7 +1,6 @@
 const memoize = (_target, _propertyKey, descriptor) => {
   const get = descriptor.get;
-  if (!get)
-    return;
+  if (!get) return;
   const memoized = /* @__PURE__ */ new WeakMap();
   descriptor.get = function() {
     if (!memoized.has(this)) {