@lumen5/framefusion 1.3.1 → 2.0.0

package/dist/framefusion.es.js

@@ -1,34 +1,34 @@
-var $ = (a, i, t) => {
-  if (!i.has(a))
+var B = (a, s, t) => {
+  if (!s.has(a))
     throw TypeError("Cannot " + t);
 };
-var e = (a, i, t) => ($(a, i, "read from private field"), t ? t.call(a) : i.get(a)), c = (a, i, t) => {
-  if (i.has(a))
+var e = (a, s, t) => (B(a, s, "read from private field"), t ? t.call(a) : s.get(a)), h = (a, s, t) => {
+  if (s.has(a))
     throw TypeError("Cannot add the same private member more than once");
-  i instanceof WeakSet ? i.add(a) : i.set(a, t);
-}, o = (a, i, t, s) => ($(a, i, "write to private field"), s ? s.call(a, t) : i.set(a, t), t), b = (a, i, t, s) => ({
+  s instanceof WeakSet ? s.add(a) : s.set(a, t);
+}, o = (a, s, t, i) => (B(a, s, "write to private field"), i ? i.call(a, t) : s.set(a, t), t), F = (a, s, t, i) => ({
   set _(r) {
-    o(a, i, r, t);
+    o(a, s, r, t);
   },
   get _() {
-    return e(a, i, s);
-  }
-}), L = (a, i, t) => ($(a, i, "access private method"), t);
-import C from "@lumen5/beamcoder";
-import q from "path";
-import G from "tmp";
-import H from "fs-extra";
-class X {
-  static async create(i) {
+    return e(a, s, i);
+  }
+}), I = (a, s, t) => (B(a, s, "access private method"), t);
+import R from "@lumen5/beamcoder";
+import z from "path";
+import H from "tmp";
+import X from "fs-extra";
+class j {
+  static async create(s) {
     throw new Error("Not implemented");
   }
   async init({
-    inputFileOrUrl: i,
+    inputFileOrUrl: s,
     outputFile: t,
-    threadCount: s = 8,
+    threadCount: i = 8,
     endTime: r,
-    interpolateFps: h,
-    interpolateMode: n
+    interpolateFps: n,
+    interpolateMode: p
   }) {
     throw new Error("Not implemented");
   }
@@ -41,29 +41,29 @@ class X {
   get height() {
     throw new Error("Not implemented");
   }
-  async seekToPTS(i) {
+  async seekToPTS(s) {
     throw new Error("Not implemented");
   }
-  async getFrameAtTime(i) {
+  async getFrameAtTime(s) {
     throw new Error("Not implemented");
   }
-  async getImageDataAtTime(i) {
+  async getImageDataAtTime(s) {
     throw new Error("Not implemented");
   }
-  async getFrameAtPts(i) {
+  async getFrameAtPts(s) {
     throw new Error("Not implemented");
   }
-  async seekToTime(i) {
+  async seekToTime(s) {
     throw new Error("Not implemented");
   }
   /**
    * Convert a PTS (based on timebase) to PTS (in seconds)
    */
-  ptsToTime(i) {
+  ptsToTime(s) {
     throw new Error("Not implemented");
   }
   async readFrames({
-    onFrameAvailable: i,
+    onFrameAvailable: s,
     flush: t = !0
   } = {
     flush: !0,
@@ -75,102 +75,102 @@ class X {
     throw new Error("Not implemented");
   }
 }
-var x, D, v, _;
-class B {
-  constructor(i) {
-    c(this, x, void 0);
-    c(this, D, void 0);
-    c(this, v, void 0);
-    c(this, _, void 0);
-    o(this, x, i);
-    const t = q.extname(i);
-    o(this, _, G.fileSync({ postfix: t })), o(this, v, e(this, _).name);
+var N, D, x, E;
+class G {
+  constructor(s) {
+    h(this, N, void 0);
+    h(this, D, void 0);
+    h(this, x, void 0);
+    h(this, E, void 0);
+    o(this, N, s);
+    const t = z.extname(s);
+    o(this, E, H.fileSync({ postfix: t })), o(this, x, e(this, E).name);
   }
   /**
   * returns the filepath of the downloaded file. If the file has not been downloaded yet, it will be undefined
   */
   get filepath() {
-    return e(this, v);
+    return e(this, x);
   }
   /**
   * Downloads the file from the given URL. The file will be downloaded to a temporary file.
   */
   async download() {
-    const i = e(this, x), t = await fetch(i);
+    const s = e(this, N), t = await fetch(s);
     if (!t.ok)
       throw new Error(
-        `Failed to fetch ${i}, status: ${t.status}`
+        `Failed to fetch ${s}, status: ${t.status}`
       );
-    const s = t.headers.get("content-type");
-    if (!s || !s.includes("video"))
+    const i = t.headers.get("content-type");
+    if (!i || !i.includes("video"))
       throw new Error(
-        `Source ${i}, returned unsupported content type ${s}`
+        `Source ${s}, returned unsupported content type ${i}`
       );
-    const r = H.createWriteStream(e(this, _).name), h = t.body;
-    if (!h)
-      throw new Error(`Response body is null for ${i}`);
-    const n = h.getReader();
-    return new Promise((y, p) => {
-      const m = () => {
-        n.read().then(({ done: d, value: P }) => {
+    const r = X.createWriteStream(e(this, E).name), n = t.body;
+    if (!n)
+      throw new Error(`Response body is null for ${s}`);
+    const p = n.getReader();
+    return new Promise((y, m) => {
+      const l = () => {
+        p.read().then(({ done: d, value: _ }) => {
           if (d) {
             r.end(() => {
-              o(this, v, e(this, _).name), y();
+              o(this, x, e(this, E).name), y();
             });
             return;
           }
-          const O = Buffer.from(P);
-          r.write(O) ? m() : r.once("drain", m);
-        }).catch(p);
+          const M = Buffer.from(_);
+          r.write(M) ? l() : r.once("drain", l);
+        }).catch(m);
       };
-      r.on("error", p), m();
+      r.on("error", m), l();
     });
   }
   clear() {
-    e(this, _) && e(this, _).removeCallback(), e(this, x) && o(this, x, void 0), e(this, D) && o(this, D, null), e(this, v) && o(this, v, void 0);
+    e(this, E) && e(this, E).removeCallback(), e(this, N) && o(this, N, void 0), e(this, D) && o(this, D, null), e(this, x) && o(this, x, void 0);
   }
 }
-x = new WeakMap(), D = new WeakMap(), v = new WeakMap(), _ = new WeakMap();
-const I = 4, j = ({
+N = new WeakMap(), D = new WeakMap(), x = new WeakMap(), E = new WeakMap();
+const V = 4, K = ({
   demuxer: a,
-  streamIndex: i,
+  streamIndex: s,
   threadCount: t
 }) => {
-  const s = {
-    width: a.streams[i].codecpar.width,
-    height: a.streams[i].codecpar.height,
-    pix_fmt: a.streams[i].codecpar.format,
+  const i = {
+    width: a.streams[s].codecpar.width,
+    height: a.streams[s].codecpar.height,
+    pix_fmt: a.streams[s].codecpar.format,
     thread_count: t
   };
-  return a.streams[i].codecpar.name === "vp8" ? C.decoder({
-    ...s,
+  return a.streams[s].codecpar.name === "vp8" ? R.decoder({
+    ...i,
     name: "libvpx"
-  }) : a.streams[i].codecpar.name === "vp9" ? C.decoder({
-    ...s,
+  }) : a.streams[s].codecpar.name === "vp9" ? R.decoder({
+    ...i,
     name: "libvpx-vp9"
-  }) : C.decoder({
-    ...s,
+  }) : R.decoder({
+    ...i,
     demuxer: a,
-    stream_index: i
+    stream_index: s
   });
-}, K = async ({
+}, O = async ({
   stream: a,
-  outputPixelFormat: i,
+  outputPixelFormat: s,
   interpolateFps: t,
-  interpolateMode: s = "fast"
+  interpolateMode: i = "fast"
 }) => {
   if (!a.codecpar.format)
     return null;
   let r = [`[in0:v]format=${a.codecpar.format}`];
-  if (a.codecpar.color_trc === "arib-std-b67" && (r = [...r, "zscale=t=linear:npl=100:p=bt2020,tonemap=tonemap=hable:desat=0,zscale=t=bt709:p=bt709:m=bt709:r=tv"]), t)
-    if (s === "high-quality")
+  if (t)
+    if (i === "high-quality")
       r = [...r, `minterpolate=fps=${t}`];
-    else if (s === "fast")
+    else if (i === "fast")
       r = [...r, `fps=${t}`];
     else
-      throw new Error(`Unexpected interpolation mode: ${s}`);
-  const h = r.join(", ") + "[out0:v]";
-  return C.filterer({
+      throw new Error(`Unexpected interpolation mode: ${i}`);
+  const n = r.join(", ") + "[out0:v]";
+  return R.filterer({
     filterType: "video",
     inputParams: [
       {
@@ -185,30 +185,30 @@ const I = 4, j = ({
     outputParams: [
       {
         name: "out0:v",
-        pixelFormat: i
+        pixelFormat: s
       }
     ],
-    filterSpec: h
+    filterSpec: n
   });
-}, V = "video", Y = "rgba", Z = 5;
-var l, f, N, w, g, E, T, R, u, F, k, S, W;
-const M = class extends X {
+}, L = "video", Y = 5;
+var c, f, P, w, g, T, v, C, u, b, k, S, q;
+const $ = class extends j {
   constructor() {
     super(...arguments);
-    c(this, S);
+    h(this, S);
     /**
      * The demuxer reads the file and outputs packet streams
      */
-    c(this, l, null);
+    h(this, c, null);
     /**
      * The decoder reads packets and can output raw frame data
      */
-    c(this, f, null);
+    h(this, f, null);
     /**
      * Packets can be filtered to change colorspace, fps and add various effects. If there are no colorspace changes or
      * filters, filter might not be necessary.
      */
-    c(this, N, null);
+    h(this, P, null);
     /**
      * This is where we store filtered frames from each previously processed packet.
      * We keep these in chronological order. We hang on to them for two reasons:
@@ -216,122 +216,119 @@ const M = class extends X {
      * 2. so we can return frames close the end of the stream. When such a frame is requested we have to flush (destroy)
      * the encoder to get the last few frames. This avoids having to re-create an encoder.
      */
-    c(this, w, []);
+    h(this, w, []);
     /**
      * This contains the last raw frames we read from the demuxer. We use it as a starting point for each new query. We
      * do this ensure we don't skip any frames.
      */
-    c(this, g, []);
+    h(this, g, []);
     /**
      * This contains the last packet we read from the demuxer. We use it as a starting point for each new query. We do
      * this ensure we don't skip any frames.
      */
-    c(this, E, null);
+    h(this, T, null);
     /**
      * The last target presentation timestamp (PTS) we requested. If we never requested a time(stamp) then this
      * value is null
      */
-    c(this, T, null);
+    h(this, v, null);
     /**
      * The number of threads to use for decoding
      */
-    c(this, R, 8);
+    h(this, C, 8);
     /**
      * The index of the video stream in the demuxer
      */
-    c(this, u, 0);
+    h(this, u, 0);
     /**
      * The number of packets we've read from the demuxer to complete the frame query
      * @private
      */
-    c(this, F, 0);
+    h(this, b, 0);
     /**
      * The number of times we've recursively read packets from the demuxer to complete the frame query
      * @private
      */
-    c(this, k, 0);
+    h(this, k, 0);
   }
   /**
    * Encoder/Decoder construction is async, so it can't be put in a regular constructor.
    * Use and await this method to generate an extractor.
    */
   static async create(t) {
-    const s = new M();
-    return await s.init(t), s;
+    const i = new $();
+    return await i.init(t), i;
   }
   async init({
     inputFileOrUrl: t,
-    threadCount: s = 8
+    threadCount: i = 8,
+    outputPixelFormat: r = "rgba"
   }) {
-    if (o(this, R, s), t.startsWith("http")) {
-      const r = new B(t);
-      await r.download(), t = r.filepath;
+    if (o(this, C, i), t.startsWith("http")) {
+      const n = new G(t);
+      await n.download(), t = n.filepath;
     }
-    if (t.startsWith("file:") || (t = "file:" + t), o(this, l, await C.demuxer(t)), o(this, u, e(this, l).streams.findIndex((r) => r.codecpar.codec_type === V)), e(this, u) === -1)
-      throw new Error(`File has no ${V} stream!`);
-    o(this, N, await K({
-      stream: e(this, l).streams[e(this, u)],
-      outputPixelFormat: Y
+    if (t.startsWith("file:") || (t = "file:" + t), o(this, c, await R.demuxer(t)), o(this, u, e(this, c).streams.findIndex((n) => n.codecpar.codec_type === L)), e(this, u) === -1)
+      throw new Error(`File has no ${L} stream!`);
+    o(this, P, await O({
+      stream: e(this, c).streams[e(this, u)],
+      outputPixelFormat: r === "original" ? e(this, c).streams[e(this, u)].codecpar.format : "rgba"
     }));
   }
-  /**
-   * This is the duration of the first video stream in the file expressed in seconds.
-   */
   get duration() {
-    const t = e(this, l).streams[e(this, u)];
-    return t.duration !== null ? this.ptsToTime(t.duration) : this.ptsToTime(e(this, l).duration) / 1e3;
+    return Math.max(...e(this, c).streams.map((i) => {
+      const r = i.time_base;
+      return i.duration * r[0] / r[1];
+    })) || this.ptsToTime(e(this, c).duration) / 1e3;
   }
   /**
    * Width in pixels
    */
   get width() {
-    return e(this, l).streams[e(this, u)].codecpar.width;
+    return e(this, c).streams[e(this, u)].codecpar.width;
   }
   /**
    * Height in pixels
    */
   get height() {
-    return e(this, l).streams[e(this, u)].codecpar.height;
+    return e(this, c).streams[e(this, u)].codecpar.height;
   }
   /**
    * Get the beamcoder Frame for a given time in seconds
    * @param targetTime
    */
   async getFrameAtTime(t) {
-    const s = Math.round(this._timeToPTS(t));
-    return this._getFrameAtPts(s);
+    const i = Math.round(this._timeToPTS(t));
+    return this._getFrameAtPts(i);
   }
   /**
    * Get imageData for a given time in seconds
    * @param targetTime
    */
-  async getImageDataAtTime(t, s) {
-    const r = Math.round(this._timeToPTS(t)), h = await this._getFrameAtPts(r);
-    if (!h)
-      return null;
-    let n = s;
-    return s || (n = new Uint8ClampedArray(h.width * h.height * I)), this._setFrameDataToImageData(h, n), {
-      data: n,
-      width: h.width,
-      height: h.height
-    };
+  async getImageDataAtTime(t, i) {
+    const r = Math.round(this._timeToPTS(t)), n = await this._getFrameAtPts(r);
+    return n ? (i && $._setFrameDataToRGBABufferTarget(n, i), {
+      width: n.width,
+      height: n.height,
+      frame: n
+    }) : null;
   }
   /**
    * Get the presentation timestamp (PTS) for a given time in seconds
    */
   _timeToPTS(t) {
-    const s = e(this, l).streams[e(this, u)].time_base;
-    return t * s[1] / s[0];
+    const i = e(this, c).streams[e(this, u)].time_base;
+    return t * i[1] / i[0];
   }
   /**
    * Get the time in seconds from a given presentation timestamp (PTS)
    */
   ptsToTime(t) {
-    const s = e(this, l).streams[e(this, u)].time_base;
-    return t * s[0] / s[1];
+    const i = e(this, c).streams[e(this, u)].time_base;
+    return t * i[0] / i[1];
   }
   get packetReadCount() {
-    return e(this, F);
+    return e(this, b);
   }
   /**
    * Get the frame at the given presentation timestamp (PTS)
@@ -340,44 +337,44 @@ const M = class extends X {
    * the targetPTS. We use it to further move away from the requested PTS to find a frame. The allows use to read
    * additional packets and find a frame that is closer to the targetPTS.
    */
-  async _getFrameAtPts(t, s = 0) {
-    o(this, F, 0);
-    const r = 3, h = e(this, w).flat().some((m) => this.ptsToTime(Math.abs(t - m.pts)) < r);
-    (e(this, T) === null || e(this, T) > t || !h) && (await e(this, l).seek({
+  async _getFrameAtPts(t, i = 0) {
+    o(this, b, 0);
+    const r = 3, n = e(this, w).flat().some((l) => this.ptsToTime(Math.abs(t - l.pts)) < r);
+    (e(this, v) === null || e(this, v) > t || !n) && (await e(this, c).seek({
       stream_index: 0,
       // even though we specify the stream index, it still seeks all streams
-      timestamp: t + s,
+      timestamp: t + i,
       any: !1
-    }), await L(this, S, W).call(this), o(this, E, null), o(this, g, []), o(this, T, t), o(this, w, []));
-    let n = null, y = -1, p = null;
+    }), await I(this, S, q).call(this), o(this, T, null), o(this, g, []), o(this, v, t), o(this, w, []));
+    let p = null, y = -1, m = null;
     if (e(this, w).length > 0) {
-      const m = e(this, w).flat().find((d) => d.pts <= t);
-      if (m) {
-        const d = e(this, w).flat().find((P) => P.pts > m.pts);
-        if (y = m.pts, p = m, d && d.pts > t || y === t)
-          return o(this, T, t), p;
+      const l = e(this, w).flat().find((d) => d.pts <= t);
+      if (l) {
+        const d = e(this, w).flat().find((_) => _.pts > l.pts);
+        if (y = l.pts, m = l, d && d.pts > t || y === t)
+          return o(this, v, t), m;
       }
     }
-    for (!e(this, E) && e(this, g).length === 0 && ({ packet: b(this, E)._, frames: b(this, g)._ } = await this._getNextPacketAndDecodeFrames(), b(this, F)._++); (e(this, E) || e(this, g).length !== 0) && y < t; ) {
+    for (!e(this, T) && e(this, g).length === 0 && ({ packet: F(this, T)._, frames: F(this, g)._ } = await this._getNextPacketAndDecodeFrames(), F(this, b)._++); (e(this, T) || e(this, g).length !== 0) && y < t; ) {
       if (e(this, g).length !== 0) {
-        n = (await e(this, N).filter([{ name: "in0:v", frames: e(this, g) }])).flatMap((P) => P.frames);
-        const d = e(this, F) === 1 && n[0].pts > t ? n[0] : n.reverse().find((P) => P.pts <= t);
+        p = (await e(this, P).filter([{ name: "in0:v", frames: e(this, g) }])).flatMap((_) => _.frames);
+        const d = e(this, b) === 1 && p[0].pts > t ? p[0] : p.reverse().find((_) => _.pts <= t);
         if (!d)
-          return p;
-        if (e(this, w).unshift(n), e(this, w).length > 2 && e(this, w).pop(), y = d == null ? void 0 : d.pts, !p || y <= t)
-          o(this, T, t), p = d;
+          return m;
+        if (e(this, w).unshift(p), e(this, w).length > 2 && e(this, w).pop(), y = d == null ? void 0 : d.pts, !m || y <= t)
+          o(this, v, t), m = d;
         else
           break;
       }
-      ({ packet: b(this, E)._, frames: b(this, g)._ } = await this._getNextPacketAndDecodeFrames()), b(this, F)._++;
+      ({ packet: F(this, T)._, frames: F(this, g)._ } = await this._getNextPacketAndDecodeFrames()), F(this, b)._++;
     }
-    if (!p) {
-      if (Z < e(this, k))
+    if (!m) {
+      if (Y < e(this, k))
         throw Error("No matching frame found");
-      const m = 0.1, d = this._timeToPTS(m);
-      b(this, k)._++, p = await this._getFrameAtPts(t, s - d), p && o(this, k, 0);
+      const l = 0.1, d = this._timeToPTS(l);
+      F(this, k)._++, m = await this._getFrameAtPts(t, i - d), m && o(this, k, 0);
     }
-    return p;
+    return m;
   }
   /**
    * Get the next packet from the video stream and decode it into frames. Each frame has a presentation time stamp
@@ -386,79 +383,79 @@ const M = class extends X {
    */
   async _getNextPacketAndDecodeFrames() {
     const t = await this._getNextVideoStreamPacket();
-    let s = null;
-    t !== null && e(this, f) ? s = await e(this, f).decode(t) : e(this, f) && (s = await e(this, f).flush(), o(this, f, null));
+    let i = null;
+    t !== null && e(this, f) ? i = await e(this, f).decode(t) : e(this, f) && (i = await e(this, f).flush(), o(this, f, null));
     let r = [];
-    return s && s.frames.length !== 0 && (r = s.frames), { packet: t, frames: r };
+    return i && i.frames.length !== 0 && (r = i.frames), { packet: t, frames: r };
   }
   async _getNextVideoStreamPacket() {
-    let t = await e(this, l).read();
+    let t = await e(this, c).read();
     for (; t && t.stream_index !== e(this, u); )
-      if (t = await e(this, l).read(), t === null)
+      if (t = await e(this, c).read(), t === null)
         return null;
     return t;
   }
-  _setFrameDataToImageData(t, s) {
-    const r = t.linesize, h = t.data[0];
-    for (let n = 0; n < t.height; n++) {
-      const y = n * r, p = y + t.width * I, m = h.subarray(y, p), d = n * t.width * I;
-      s.set(m, d);
+  static _setFrameDataToRGBABufferTarget(t, i) {
+    const r = t.linesize, n = t.data[0], p = t.width, y = t.height;
+    for (let m = 0; m < y; m++) {
+      const l = m * r, d = l + p * V, _ = n.subarray(l, d), M = m * p * V;
+      i.set(_, M);
     }
   }
   async dispose() {
-    e(this, f) && (await e(this, f).flush(), o(this, f, null)), e(this, l).forceClose(), o(this, N, null), o(this, w, void 0), o(this, g, []), o(this, E, null), o(this, T, null), o(this, u, 0);
+    e(this, f) && (await e(this, f).flush(), o(this, f, null)), e(this, c).forceClose(), o(this, P, null), o(this, w, void 0), o(this, g, []), o(this, T, null), o(this, v, null), o(this, u, 0);
   }
 };
-let z = M;
-l = new WeakMap(), f = new WeakMap(), N = new WeakMap(), w = new WeakMap(), g = new WeakMap(), E = new WeakMap(), T = new WeakMap(), R = new WeakMap(), u = new WeakMap(), F = new WeakMap(), k = new WeakMap(), S = new WeakSet(), W = async function() {
-  e(this, f) && (await e(this, f).flush(), o(this, f, null)), o(this, f, j({
-    demuxer: e(this, l),
+let W = $;
+c = new WeakMap(), f = new WeakMap(), P = new WeakMap(), w = new WeakMap(), g = new WeakMap(), T = new WeakMap(), v = new WeakMap(), C = new WeakMap(), u = new WeakMap(), b = new WeakMap(), k = new WeakMap(), S = new WeakSet(), q = async function() {
+  e(this, f) && (await e(this, f).flush(), o(this, f, null)), o(this, f, K({
+    demuxer: e(this, c),
     streamIndex: e(this, u),
-    threadCount: e(this, R)
+    threadCount: e(this, C)
   }));
 };
 var A;
-class it {
+class et {
   constructor() {
-    c(this, A, /* @__PURE__ */ new Map());
+    h(this, A, /* @__PURE__ */ new Map());
   }
-  get(i) {
+  get(s) {
     const t = this;
-    let s;
+    let i;
     return {
-      url: i,
+      url: s,
       get filepath() {
-        return s;
+        return i;
       },
       async download() {
-        let r = e(t, A).get(i);
+        let r = e(t, A).get(s);
         if (r)
           r.refCount += 1, r.downloadPromise && await r.downloadPromise;
         else {
-          const h = new B(i), n = h.download();
+          const n = new G(s), p = n.download();
           r = {
-            downloader: h,
+            downloader: n,
             refCount: 1,
-            downloadPromise: n
-          }, e(t, A).set(i, r);
+            downloadPromise: p
+          }, e(t, A).set(s, r);
           try {
-            await n;
+            await p;
           } finally {
             r.downloadPromise = void 0;
           }
         }
-        s = e(t, A).get(i).downloader.filepath;
+        i = e(t, A).get(s).downloader.filepath;
       },
       destroy() {
-        const r = e(t, A).get(i);
-        r && (r.refCount -= 1, r.refCount <= 0 && (r.downloader.clear(), e(t, A).delete(i)), s = void 0);
+        const r = e(t, A).get(s);
+        r && (r.refCount -= 1, r.refCount <= 0 && (r.downloader.clear(), e(t, A).delete(s)), i = void 0);
       }
     };
   }
 }
 A = new WeakMap();
 export {
-  z as BeamcoderExtractor,
-  it as CachedVideoDownloader
+  W as BeamcoderExtractor,
+  et as CachedVideoDownloader
 };
 //# sourceMappingURL=framefusion.es.js.map