@openvalle/engine 0.0.0-stage → 0.1.0

package/dist/messages.d.ts

@@ -0,0 +1,116 @@
+/** A file a page gives in place of fetching a path: its bytes, or where to fetch them. */
+export type Source = string | Blob | ArrayBuffer | Uint8Array;
+/** What a scene's controls are bound to: props and data by name, and the files of resources. */
+export type Inputs = {
+    props: Record<string, unknown>;
+    data: Record<string, unknown>;
+    /** Each resource's files, as paths the worker reads. */
+    resources: Record<string, string[]>;
+};
+export type Request = {
+    type: "start";
+    canvas: OffscreenCanvas;
+    /** The address relative paths are fetched from. */
+    base: string;
+    /** Where the built-in fonts are fetched from, by their file names, if not their own addresses. */
+    fonts?: string;
+    /** Whether files are fetched through the page, which answers `{ fetch: id, url }`. */
+    proxied: boolean;
+} | {
+    type: "give";
+    files: Record<string, Source>;
+} | {
+    type: "open";
+    entry: string;
+    inputs: Inputs;
+} | {
+    type: "frame";
+    index: number;
+} | {
+    type: "pixels";
+}
+/** Draws frame `index` off the canvas, and answers its pixels as `pixels` does. */
+ | {
+    type: "still";
+    index: number;
+}
+/** Mixes the timeline's sound: its length in samples, or null where it has none. */
+ | {
+    type: "sound";
+    entry: string;
+}
+/** `samples` of it from `sample`, interleaved stereo. */
+ | {
+    type: "render-sound";
+    sample: number;
+    samples: number;
+}
+/** The MP4 of what is open; the worker says how far it is as `{ progress: id, done }`. */
+ | {
+    type: "export";
+    options: ExportOptions;
+}
+/** The port the audio worklet asks for the sound it plays at. */
+ | {
+    type: "worklet";
+    port: MessagePort;
+} | {
+    type: "close";
+} | {
+    type: "destroy";
+};
+/** How an export encodes what is open: H.264 of `width` × `height`, the frames fitted in whole,
+ * at `rate` frames a second, `bitrate` bits a second, with the sound or not. */
+export type ExportOptions = {
+    width: number;
+    height: number;
+    rate: [number, number];
+    bitrate: number;
+    audio: boolean;
+};
+/** The composition and the controls of what is open. */
+export type Opened = {
+    width: number;
+    height: number;
+    /** Frames a second, as a whole number or a fraction such as `30000/1001`. */
+    fps: string;
+    frames: number;
+    duration: number;
+    loop: boolean;
+    controls: Controls;
+};
+/** What a scene's controls take, as `defineProps`, `defineData` and `defineResources` declare them. */
+export type Controls = {
+    props: Record<string, Control>;
+    data: Record<string, Control>;
+    resources: Record<string, {
+        kind: string;
+        default?: string[];
+    }>;
+};
+export type Control = {
+    type: string;
+    default?: unknown;
+    required?: boolean;
+    label?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    values?: unknown[];
+};
+/** Why a request failed: `no-webgpu`, a `file` that could not be fetched, the `scene`'s error (a
+ * value that does not fit its control among them), or an export `cancelled`. */
+export type Code = "no-webgpu" | "file" | "scene" | "cancelled";
+export type Reply = {
+    id: number;
+} & ({
+    ok: true;
+    value?: unknown;
+} | {
+    ok: false;
+    code: Code;
+    message: string;
+});
+/** The composition's frame at each frame of an export at `rate`: its own at its own rate, else
+ * the one at each frame's time. */
+export declare function exportFrames(composition: Opened, rate: [number, number]): number[];

package/dist/sound.js

@@ -0,0 +1,81 @@
+// web/packages/engine/src/sound.ts
+var AHEAD = 0.25;
+
+class Player extends AudioWorkletProcessor {
+  #source;
+  #gen = -1;
+  #chunks = [];
+  #offset = 0;
+  #queued = 0;
+  #asked = false;
+  #started = false;
+  #late = 0;
+  constructor() {
+    super();
+    this.port.onmessage = (event) => {
+      const message = event.data;
+      if (message.port) {
+        this.#source = message.port;
+        this.#source.onmessage = (e) => this.#chunk(e.data.gen, e.data.data);
+      } else if (message.start !== undefined) {
+        this.#reset(message.start);
+        this.#asked = true;
+        this.#source?.postMessage({ gen: this.#gen, sample: message.sample });
+      } else if (message.stop) {
+        this.#reset(-1);
+      }
+    };
+  }
+  #reset(gen) {
+    this.#gen = gen;
+    this.#chunks = [];
+    this.#offset = 0;
+    this.#queued = 0;
+    this.#asked = false;
+    this.#started = false;
+    this.#late = 0;
+  }
+  #chunk(gen, data) {
+    if (gen !== this.#gen) {
+      return;
+    }
+    this.#asked = false;
+    const dropped = Math.min(this.#late, data.length / 2);
+    this.#late -= dropped;
+    if (dropped < data.length / 2) {
+      this.#chunks.push(data.subarray(2 * dropped));
+      this.#queued += data.length / 2 - dropped;
+    }
+  }
+  process(_, outputs) {
+    const [left, right] = outputs[0];
+    let i = 0;
+    while (i < left.length && this.#chunks.length > 0) {
+      if (!this.#started) {
+        this.#started = true;
+        this.port.postMessage({ started: this.#gen, frame: currentFrame + i });
+      }
+      const chunk = this.#chunks[0];
+      for (;i < left.length && this.#offset < chunk.length; i++, this.#offset += 2) {
+        left[i] = chunk[this.#offset];
+        right[i] = chunk[this.#offset + 1];
+      }
+      if (this.#offset >= chunk.length) {
+        this.#chunks.shift();
+        this.#offset = 0;
+      }
+    }
+    this.#queued -= i;
+    if (this.#started) {
+      this.#late += left.length - i;
+    }
+    left.fill(0, i);
+    right.fill(0, i);
+    if (this.#gen >= 0 && !this.#asked && this.#queued < AHEAD * sampleRate) {
+      this.#asked = true;
+      this.#source?.postMessage({ gen: this.#gen });
+    }
+    return true;
+  }
+}
+registerProcessor("valle-sound", Player);