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

package/dist/packages/elements/src/EF_FRAMEGEN.cjs

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const task = require("@lit/task");
+const awaitMicrotask = require("../../../lib/util/awaitMicrotask.cjs");
+const EFTemporal = require("./elements/EFTemporal.cjs");
+const EFTimegroup = require("./elements/EFTimegroup.cjs");
+class TriggerCanvas {
+  constructor() {
+    this.canvas = document.createElement("canvas");
+    this.canvas.width = 1;
+    this.canvas.height = 1;
+    Object.assign(this.canvas.style, {
+      position: "fixed",
+      top: "0px",
+      left: "0px",
+      width: "1px",
+      height: "1px",
+      zIndex: "100000"
+    });
+    document.body.prepend(this.canvas);
+    const ctx = this.canvas.getContext("2d", { willReadFrequently: true });
+    if (!ctx) throw new Error("Canvas 2d context not ready");
+    this.ctx = ctx;
+    this.ctx.fillStyle = "black";
+  }
+  trigger() {
+    console.log("TRIGGERING CANVAS");
+    this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+  }
+}
+class EfFramegen {
+  constructor() {
+    this.time = 0;
+    this.frameDurationMs = 0;
+    this.initialBusyTasks = Promise.resolve([]);
+    this.frameBox = document.createElement("div");
+    this.BRIDGE = window.FRAMEGEN_BRIDGE;
+    this.triggerCanvas = new TriggerCanvas();
+    if (this.BRIDGE) {
+      this.connectToBridge();
+    }
+  }
+  log(...args) {
+    console.log("[EF_FRAMEGEN]", ...args);
+  }
+  trace(...args) {
+    console.trace("[EF_FRAMEGEN]", ...args);
+  }
+  connectToBridge() {
+    const BRIDGE = this.BRIDGE;
+    if (!BRIDGE) {
+      throw new Error("No BRIDGE when attempting to connect to bridge");
+    }
+    BRIDGE.onInitialize(async (renderId, renderOptions) => {
+      this.log("BRIDGE.onInitialize", renderId, renderOptions);
+      await this.initialize(renderId, renderOptions);
+      BRIDGE.initialized(renderId);
+    });
+    BRIDGE.onBeginFrame((renderId, frameNumber, isLast) => {
+      this.log("BRIDGE.onBeginFrame", renderId, frameNumber, isLast);
+      this.beginFrame(renderId, frameNumber, isLast);
+    });
+  }
+  async initialize(renderId, renderOptions) {
+    addEventListener("unhandledrejection", (event) => {
+      this.trace("Unhandled rejection:", event.reason);
+      if (this.BRIDGE) {
+        this.BRIDGE.error(renderId, event.reason);
+      }
+    });
+    addEventListener("error", (event) => {
+      this.trace("Uncaught error", event.error);
+      if (this.BRIDGE) {
+        this.BRIDGE.error(renderId, event.error);
+      }
+    });
+    this.renderOptions = renderOptions;
+    const workbench = document.querySelector("ef-workbench");
+    if (!workbench) {
+      throw new Error("No workbench found");
+    }
+    workbench.rendering = true;
+    const timegroups = EFTimegroup.shallowGetTimegroups(workbench);
+    const temporals = EFTemporal.deepGetElementsWithFrameTasks(workbench);
+    const firstGroup = timegroups[0];
+    if (!firstGroup) {
+      throw new Error("No temporal elements found");
+    }
+    firstGroup.currentTimeMs = renderOptions.encoderOptions.fromMs;
+    this.frameDurationMs = 1e3 / renderOptions.encoderOptions.video.framerate;
+    this.initialBusyTasks = Promise.all(
+      temporals.filter((temporal) => temporal.frameTask.status < task.TaskStatus.COMPLETE).map((temporal) => temporal.frameTask).map((task2) => task2.taskComplete)
+    );
+    this.time = 0;
+    if (renderOptions.showFrameBox) {
+      Object.assign(this.frameBox.style, {
+        width: "200px",
+        height: "100px",
+        font: "30px Arial",
+        backgroundColor: "white",
+        position: "absolute",
+        top: "0px",
+        left: "0px",
+        zIndex: "100000"
+      });
+      document.body.prepend(this.frameBox);
+    }
+    this.audioBufferPromise = firstGroup.renderAudio(
+      renderOptions.encoderOptions.alignedFromUs / 1e3,
+      renderOptions.encoderOptions.alignedToUs / 1e3
+      // renderOptions.encoderOptions.fromMs,
+      // renderOptions.encoderOptions.toMs,
+    );
+    this.log("Initialized");
+  }
+  async beginFrame(renderId, frameNumber, isLast) {
+    if (this.renderOptions === void 0) {
+      throw new Error("No renderOptions");
+    }
+    if (this.renderOptions.showFrameBox) {
+      this.frameBox.innerHTML = `
+        <div>Frame #${frameNumber}</div>
+        <div>${this.time.toFixed(4)}</div>
+      `;
+    }
+    const workbench = document.querySelector("ef-workbench");
+    if (!workbench) {
+      throw new Error("No workbench found");
+    }
+    workbench.rendering = true;
+    const timegroups = EFTimegroup.shallowGetTimegroups(workbench);
+    const temporals = EFTemporal.deepGetElementsWithFrameTasks(workbench);
+    const firstGroup = timegroups[0];
+    if (!firstGroup) {
+      throw new Error("No temporal elements found");
+    }
+    this.time = this.renderOptions.encoderOptions.fromMs + frameNumber * this.frameDurationMs;
+    firstGroup.currentTimeMs = this.time;
+    await this.initialBusyTasks;
+    await awaitMicrotask.awaitMicrotask();
+    const now = performance.now();
+    await Promise.all(
+      temporals.filter((temporal) => temporal.frameTask.status < task.TaskStatus.COMPLETE).map((temporal) => {
+        return temporal.frameTask;
+      }).map((task2) => task2.taskComplete)
+    );
+    console.log(
+      `frame:${frameNumber} All tasks complete ${performance.now() - now}ms`
+    );
+    if (isLast && this.audioBufferPromise) {
+      const renderedAudio = await this.audioBufferPromise;
+      const channelCount = renderedAudio.numberOfChannels;
+      const interleavedSamples = new Float32Array(
+        channelCount * renderedAudio.length
+      );
+      for (let i = 0; i < renderedAudio.length; i++) {
+        for (let j = 0; j < channelCount; j++) {
+          interleavedSamples.set(
+            renderedAudio.getChannelData(j).slice(i, i + 1),
+            i * channelCount + j
+          );
+        }
+      }
+      if (this.BRIDGE) {
+        this.triggerCanvas.trigger();
+        this.BRIDGE.frameReady(
+          renderId,
+          frameNumber,
+          interleavedSamples.buffer
+        );
+      } else {
+        const fileReader = new FileReader();
+        fileReader.readAsDataURL(new Blob([interleavedSamples.buffer]));
+        await new Promise((resolve, reject) => {
+          fileReader.onload = resolve;
+          fileReader.onerror = reject;
+        });
+        return fileReader.result;
+      }
+    } else {
+      if (this.BRIDGE) {
+        this.triggerCanvas.trigger();
+        this.BRIDGE.frameReady(renderId, frameNumber, new ArrayBuffer(0));
+      } else {
+        const fileReader = new FileReader();
+        fileReader.readAsDataURL(new Blob([]));
+        await new Promise((resolve, reject) => {
+          fileReader.onload = resolve;
+          fileReader.onerror = reject;
+        });
+        return fileReader.result;
+      }
+    }
+  }
+}
+window.EF_FRAMEGEN = new EfFramegen();
+exports.EfFramegen = EfFramegen;

package/dist/packages/elements/src/EF_FRAMEGEN.d.ts

@@ -0,0 +1,45 @@
+import { VideoRenderOptions } from '../../assets';
+
+declare global {
+    interface Window {
+        EF_FRAMEGEN?: EfFramegen;
+        FRAMEGEN_BRIDGE?: {
+            onInitialize: (callback: (renderId: string, renderOptions: VideoRenderOptions) => void) => void;
+            initialized(renderId: string): void;
+            onBeginFrame(callback: (renderId: string, frameNumber: number, isLast: boolean) => void): void;
+            onTriggerCanvas(callback: () => void): void;
+            frameReady(renderId: string, frameNumber: number, audioSamples: ArrayBuffer): void;
+            error(renderId: string, error: Error): void;
+        };
+    }
+}
+declare class TriggerCanvas {
+    private canvas;
+    private ctx;
+    constructor();
+    trigger(): void;
+}
+export declare class EfFramegen {
+    time: number;
+    frameDurationMs: number;
+    initialBusyTasks: Promise<unknown[]>;
+    audioBufferPromise?: Promise<AudioBuffer>;
+    renderOptions?: VideoRenderOptions;
+    frameBox: HTMLDivElement;
+    BRIDGE: {
+        onInitialize: (callback: (renderId: string, renderOptions: VideoRenderOptions) => void) => void;
+        initialized(renderId: string): void;
+        onBeginFrame(callback: (renderId: string, frameNumber: number, isLast: boolean) => void): void;
+        onTriggerCanvas(callback: () => void): void;
+        frameReady(renderId: string, frameNumber: number, audioSamples: ArrayBuffer): void;
+        error(renderId: string, error: Error): void;
+    } | undefined;
+    triggerCanvas: TriggerCanvas;
+    log(...args: any[]): void;
+    trace(...args: any[]): void;
+    constructor();
+    connectToBridge(): void;
+    initialize(renderId: string, renderOptions: VideoRenderOptions): Promise<void>;
+    beginFrame(renderId: string, frameNumber: number, isLast: boolean): Promise<string | ArrayBuffer | null | undefined>;
+}
+export {};

package/dist/packages/elements/src/EF_FRAMEGEN.js

@@ -0,0 +1,197 @@
+import { TaskStatus } from "@lit/task";
+import { awaitMicrotask } from "../../../lib/util/awaitMicrotask.js";
+import { deepGetElementsWithFrameTasks } from "./elements/EFTemporal.js";
+import { shallowGetTimegroups } from "./elements/EFTimegroup.js";
+class TriggerCanvas {
+  constructor() {
+    this.canvas = document.createElement("canvas");
+    this.canvas.width = 1;
+    this.canvas.height = 1;
+    Object.assign(this.canvas.style, {
+      position: "fixed",
+      top: "0px",
+      left: "0px",
+      width: "1px",
+      height: "1px",
+      zIndex: "100000"
+    });
+    document.body.prepend(this.canvas);
+    const ctx = this.canvas.getContext("2d", { willReadFrequently: true });
+    if (!ctx) throw new Error("Canvas 2d context not ready");
+    this.ctx = ctx;
+    this.ctx.fillStyle = "black";
+  }
+  trigger() {
+    console.log("TRIGGERING CANVAS");
+    this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+  }
+}
+class EfFramegen {
+  constructor() {
+    this.time = 0;
+    this.frameDurationMs = 0;
+    this.initialBusyTasks = Promise.resolve([]);
+    this.frameBox = document.createElement("div");
+    this.BRIDGE = window.FRAMEGEN_BRIDGE;
+    this.triggerCanvas = new TriggerCanvas();
+    if (this.BRIDGE) {
+      this.connectToBridge();
+    }
+  }
+  log(...args) {
+    console.log("[EF_FRAMEGEN]", ...args);
+  }
+  trace(...args) {
+    console.trace("[EF_FRAMEGEN]", ...args);
+  }
+  connectToBridge() {
+    const BRIDGE = this.BRIDGE;
+    if (!BRIDGE) {
+      throw new Error("No BRIDGE when attempting to connect to bridge");
+    }
+    BRIDGE.onInitialize(async (renderId, renderOptions) => {
+      this.log("BRIDGE.onInitialize", renderId, renderOptions);
+      await this.initialize(renderId, renderOptions);
+      BRIDGE.initialized(renderId);
+    });
+    BRIDGE.onBeginFrame((renderId, frameNumber, isLast) => {
+      this.log("BRIDGE.onBeginFrame", renderId, frameNumber, isLast);
+      this.beginFrame(renderId, frameNumber, isLast);
+    });
+  }
+  async initialize(renderId, renderOptions) {
+    addEventListener("unhandledrejection", (event) => {
+      this.trace("Unhandled rejection:", event.reason);
+      if (this.BRIDGE) {
+        this.BRIDGE.error(renderId, event.reason);
+      }
+    });
+    addEventListener("error", (event) => {
+      this.trace("Uncaught error", event.error);
+      if (this.BRIDGE) {
+        this.BRIDGE.error(renderId, event.error);
+      }
+    });
+    this.renderOptions = renderOptions;
+    const workbench = document.querySelector("ef-workbench");
+    if (!workbench) {
+      throw new Error("No workbench found");
+    }
+    workbench.rendering = true;
+    const timegroups = shallowGetTimegroups(workbench);
+    const temporals = deepGetElementsWithFrameTasks(workbench);
+    const firstGroup = timegroups[0];
+    if (!firstGroup) {
+      throw new Error("No temporal elements found");
+    }
+    firstGroup.currentTimeMs = renderOptions.encoderOptions.fromMs;
+    this.frameDurationMs = 1e3 / renderOptions.encoderOptions.video.framerate;
+    this.initialBusyTasks = Promise.all(
+      temporals.filter((temporal) => temporal.frameTask.status < TaskStatus.COMPLETE).map((temporal) => temporal.frameTask).map((task) => task.taskComplete)
+    );
+    this.time = 0;
+    if (renderOptions.showFrameBox) {
+      Object.assign(this.frameBox.style, {
+        width: "200px",
+        height: "100px",
+        font: "30px Arial",
+        backgroundColor: "white",
+        position: "absolute",
+        top: "0px",
+        left: "0px",
+        zIndex: "100000"
+      });
+      document.body.prepend(this.frameBox);
+    }
+    this.audioBufferPromise = firstGroup.renderAudio(
+      renderOptions.encoderOptions.alignedFromUs / 1e3,
+      renderOptions.encoderOptions.alignedToUs / 1e3
+      // renderOptions.encoderOptions.fromMs,
+      // renderOptions.encoderOptions.toMs,
+    );
+    this.log("Initialized");
+  }
+  async beginFrame(renderId, frameNumber, isLast) {
+    if (this.renderOptions === void 0) {
+      throw new Error("No renderOptions");
+    }
+    if (this.renderOptions.showFrameBox) {
+      this.frameBox.innerHTML = `
+        <div>Frame #${frameNumber}</div>
+        <div>${this.time.toFixed(4)}</div>
+      `;
+    }
+    const workbench = document.querySelector("ef-workbench");
+    if (!workbench) {
+      throw new Error("No workbench found");
+    }
+    workbench.rendering = true;
+    const timegroups = shallowGetTimegroups(workbench);
+    const temporals = deepGetElementsWithFrameTasks(workbench);
+    const firstGroup = timegroups[0];
+    if (!firstGroup) {
+      throw new Error("No temporal elements found");
+    }
+    this.time = this.renderOptions.encoderOptions.fromMs + frameNumber * this.frameDurationMs;
+    firstGroup.currentTimeMs = this.time;
+    await this.initialBusyTasks;
+    await awaitMicrotask();
+    const now = performance.now();
+    await Promise.all(
+      temporals.filter((temporal) => temporal.frameTask.status < TaskStatus.COMPLETE).map((temporal) => {
+        return temporal.frameTask;
+      }).map((task) => task.taskComplete)
+    );
+    console.log(
+      `frame:${frameNumber} All tasks complete ${performance.now() - now}ms`
+    );
+    if (isLast && this.audioBufferPromise) {
+      const renderedAudio = await this.audioBufferPromise;
+      const channelCount = renderedAudio.numberOfChannels;
+      const interleavedSamples = new Float32Array(
+        channelCount * renderedAudio.length
+      );
+      for (let i = 0; i < renderedAudio.length; i++) {
+        for (let j = 0; j < channelCount; j++) {
+          interleavedSamples.set(
+            renderedAudio.getChannelData(j).slice(i, i + 1),
+            i * channelCount + j
+          );
+        }
+      }
+      if (this.BRIDGE) {
+        this.triggerCanvas.trigger();
+        this.BRIDGE.frameReady(
+          renderId,
+          frameNumber,
+          interleavedSamples.buffer
+        );
+      } else {
+        const fileReader = new FileReader();
+        fileReader.readAsDataURL(new Blob([interleavedSamples.buffer]));
+        await new Promise((resolve, reject) => {
+          fileReader.onload = resolve;
+          fileReader.onerror = reject;
+        });
+        return fileReader.result;
+      }
+    } else {
+      if (this.BRIDGE) {
+        this.triggerCanvas.trigger();
+        this.BRIDGE.frameReady(renderId, frameNumber, new ArrayBuffer(0));
+      } else {
+        const fileReader = new FileReader();
+        fileReader.readAsDataURL(new Blob([]));
+        await new Promise((resolve, reject) => {
+          fileReader.onload = resolve;
+          fileReader.onerror = reject;
+        });
+        return fileReader.result;
+      }
+    }
+  }
+}
+window.EF_FRAMEGEN = new EfFramegen();
+export {
+  EfFramegen
+};

package/dist/packages/elements/src/EF_INTERACTIVE.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const EF_INTERACTIVE = !window.location.search.includes("EF_NONINTERACTIVE");
+exports.EF_INTERACTIVE = EF_INTERACTIVE;

package/dist/packages/elements/src/EF_INTERACTIVE.d.ts

@@ -0,0 +1 @@
+export declare const EF_INTERACTIVE: boolean;

package/dist/packages/elements/src/elements/CrossUpdateController.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class CrossUpdateController {
+  constructor(host, target) {
+    this.host = host;
+    this.target = target;
+    this.host.addController(this);
+  }
+  hostUpdate() {
+    this.target.requestUpdate();
+  }
+  remove() {
+    this.host.removeController(this);
+  }
+}
+exports.CrossUpdateController = CrossUpdateController;

package/dist/packages/elements/src/elements/CrossUpdateController.d.ts

@@ -0,0 +1,9 @@
+import { LitElement, ReactiveController, ReactiveControllerHost } from 'lit';
+
+export declare class CrossUpdateController implements ReactiveController {
+    private host;
+    private target;
+    constructor(host: ReactiveControllerHost, target: LitElement);
+    hostUpdate(): void;
+    remove(): void;
+}

package/dist/packages/elements/src/elements/EFAudio.cjs

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const lit = require("lit");
+const ref_js = require("lit/directives/ref.js");
+const decorators_js = require("lit/decorators.js");
+const EFMedia = require("./EFMedia.cjs");
+const task = require("@lit/task");
+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;
+  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);
+  return result;
+};
+exports.EFAudio = class EFAudio extends EFMedia.EFMedia {
+  constructor() {
+    super(...arguments);
+    this.audioElementRef = ref_js.createRef();
+    this.src = "";
+    this.frameTask = new task.Task(this, {
+      args: () => [
+        this.trackFragmentIndexLoader.status,
+        this.initSegmentsLoader.status,
+        this.seekTask.status,
+        this.fetchSeekTask.status,
+        this.videoAssetTask.status
+      ],
+      task: async () => {
+        await this.trackFragmentIndexLoader.taskComplete;
+        await this.initSegmentsLoader.taskComplete;
+        await this.seekTask.taskComplete;
+        await this.fetchSeekTask.taskComplete;
+        await this.videoAssetTask.taskComplete;
+        this.rootTimegroup?.requestUpdate();
+      }
+    });
+  }
+  render() {
+    return lit.html`<audio ${ref_js.ref(this.audioElementRef)}></audio>`;
+  }
+  get audioElement() {
+    return this.audioElementRef.value;
+  }
+};
+__decorateClass([
+  decorators_js.property({ type: String })
+], exports.EFAudio.prototype, "src", 2);
+exports.EFAudio = __decorateClass([
+  decorators_js.customElement("ef-audio")
+], exports.EFAudio);

package/dist/packages/elements/src/elements/EFAudio.d.ts

@@ -0,0 +1,10 @@
+import { EFMedia } from './EFMedia';
+import { Task } from '@lit/task';
+
+export declare class EFAudio extends EFMedia {
+    audioElementRef: import('lit-html/directives/ref').Ref<HTMLAudioElement>;
+    src: string;
+    render(): import('lit-html').TemplateResult<1>;
+    get audioElement(): HTMLAudioElement | undefined;
+    frameTask: Task<readonly [import('@lit/task').TaskStatus, import('@lit/task').TaskStatus, import('@lit/task').TaskStatus, import('@lit/task').TaskStatus, import('@lit/task').TaskStatus], void>;
+}

package/dist/{elements/src/elements/EFAudio.mjs → packages/elements/src/elements/EFAudio.js}

@@ -1,7 +1,7 @@
 import { html } from "lit";
 import { createRef, ref } from "lit/directives/ref.js";
 import { property, customElement } from "lit/decorators.js";
-import { EFMedia } from "./EFMedia.mjs";
+import { EFMedia } from "./EFMedia.js";
 import { Task } from "@lit/task";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -10,8 +10,7 @@ var __decorateClass = (decorators, target, key, kind) => {
   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);
+  if (kind && result) __defProp(target, key, result);
   return result;
 };
 let EFAudio = class extends EFMedia {
@@ -28,13 +27,11 @@ let EFAudio = class extends EFMedia {
         this.videoAssetTask.status
       ],
       task: async () => {
-        console.log("EFAudio frameTask", this.ownCurrentTimeMs);
         await this.trackFragmentIndexLoader.taskComplete;
         await this.initSegmentsLoader.taskComplete;
         await this.seekTask.taskComplete;
         await this.fetchSeekTask.taskComplete;
         await this.videoAssetTask.taskComplete;
-        console.log("EFAudio frameTask complete", this.ownCurrentTimeMs);
         this.rootTimegroup?.requestUpdate();
       }
     });