@alpha2-sh/editor 0.0.0 → 0.1.0

package/dist/browser/runtime/staging.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The bytes the engine's I420 readback of a `width`x`height` frame keeps staged: its planes and
+ * the renderer's 16-byte canary, what a readback ticket reports as `retainedBytes`.
+ */
+export function estimatedStagingBytes(width: any, height: any): number;
+/**
+ * The least an export of `width`x`height` frames can run with in flight: one frame's readback
+ * staged and the packed copy of one frame the encoder holds.
+ */
+export function minimumExportWorkingSet(width: any, height: any): number;

package/dist/browser/runtime/staging.js

@@ -0,0 +1,32 @@
+// What an export frame holds in flight, computed without loading the runtime.
+// `tests/cases/staging-bytes-corpus.json` holds these to the renderer's `yuv420p_staging_bytes`.
+/** The canary the renderer stages after the planes, to prove the GPU wrote them. */
+const CANARY_BYTES = 16;
+/**
+ * The bytes of the planes of a `width`x`height` I420 readback: each plane's rows padded to the copy
+ * alignment (256), each plane starting on a 512-byte placement boundary, as the renderer lays them
+ * out. The packed frame the encoder takes is this long.
+ */
+function planeBytes(width, height) {
+    const row = (bytes) => Math.ceil(bytes / 256) * 256;
+    const place = (offset) => Math.ceil(offset / 512) * 512;
+    const chromaRows = Math.floor(height / 2);
+    const chroma = row(Math.floor(width / 2)) * chromaRows;
+    const u = place(row(width) * height);
+    const v = place(u + chroma);
+    return v + chroma;
+}
+/**
+ * The bytes the engine's I420 readback of a `width`x`height` frame keeps staged: its planes and
+ * the renderer's 16-byte canary, what a readback ticket reports as `retainedBytes`.
+ */
+export function estimatedStagingBytes(width, height) {
+    return planeBytes(width, height) + CANARY_BYTES;
+}
+/**
+ * The least an export of `width`x`height` frames can run with in flight: one frame's readback
+ * staged and the packed copy of one frame the encoder holds.
+ */
+export function minimumExportWorkingSet(width, height) {
+    return estimatedStagingBytes(width, height) + planeBytes(width, height);
+}

package/dist/browser/runtime/still.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Decodes an image file upright and without colour management. Rejects a picture larger than the
+ * engine takes, as native decoding refuses one.
+ */
+export function decodeStill(file: any): Promise<ImageBitmap>;
+/**
+ * A decoded still's pixels at its own size, in straight alpha as decoded, as a raster frame the
+ * engine presents into the output.
+ */
+export function stillRaster(bitmap: any): {
+    kind: string;
+    width: any;
+    height: any;
+    pixels: Uint8Array<ArrayBuffer>;
+    alpha: string;
+    physicalTimeMicroseconds: number;
+};
+/** The longest side the engine decodes, renders, or composes (`MAX_FRAME_DIMENSION`). */
+export const MAX_STILL_DIMENSION: 16384;
+/** The largest area the engine decodes, renders, or composes (`MAX_FRAME_PIXELS`). */
+export const MAX_STILL_PIXELS: 67108864;

package/dist/browser/runtime/still.js

@@ -0,0 +1,52 @@
+// Reads a still image by the same rule as native decoding, so it shows alike in preview and in
+// browser and native exports:
+// - Upright per Exif `Orientation` (`imageOrientation: "from-image"`; Chrome reads `"none"` as it).
+// - In stored sRGB code values: no ICC profile (`colorSpaceConversion: "none"`), since the engine
+//   treats SDR input as sRGB and native decoding has no colour management.
+// - At its own size; the engine scales it into the output.
+/** The longest side the engine decodes, renders, or composes (`MAX_FRAME_DIMENSION`). */
+export const MAX_STILL_DIMENSION = 16_384;
+/** The largest area the engine decodes, renders, or composes (`MAX_FRAME_PIXELS`). */
+export const MAX_STILL_PIXELS = 67_108_864;
+/**
+ * Decodes an image file upright and without colour management. Rejects a picture larger than the
+ * engine takes, as native decoding refuses one.
+ */
+export async function decodeStill(file) {
+    const bitmap = await createImageBitmap(file, {
+        imageOrientation: "from-image",
+        colorSpaceConversion: "none",
+    });
+    const { width, height } = bitmap;
+    if (width > MAX_STILL_DIMENSION ||
+        height > MAX_STILL_DIMENSION ||
+        width * height > MAX_STILL_PIXELS) {
+        bitmap.close();
+        throw new RangeError(`the picture is ${width}x${height}, larger than the ${MAX_STILL_DIMENSION} pixels a side or ${MAX_STILL_PIXELS} pixels alpha2 decodes`);
+    }
+    return bitmap;
+}
+/**
+ * A decoded still's pixels at its own size, in straight alpha as decoded, as a raster frame the
+ * engine presents into the output.
+ */
+export function stillRaster(bitmap) {
+    const { width, height } = bitmap;
+    const canvas = new OffscreenCanvas(width, height);
+    const context = canvas.getContext("2d", {
+        colorSpace: "srgb",
+        willReadFrequently: true,
+    });
+    context.drawImage(bitmap, 0, 0);
+    const { data } = context.getImageData(0, 0, width, height, {
+        colorSpace: "srgb",
+    });
+    return {
+        kind: "raster-frame",
+        width,
+        height,
+        pixels: new Uint8Array(data.buffer, data.byteOffset, data.byteLength),
+        alpha: "straight",
+        physicalTimeMicroseconds: 0,
+    };
+}

package/dist/browser/runtime/wasm.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Instantiates `alpha2/wasm` once for this realm and resolves to its exports. wasm-bindgen's own
+ * init reuses an instance only after one has finished: two calls in flight instantiate twice, and
+ * the later instance replaces the module's memory under objects made from the first, whose next
+ * call reads out of bounds. Every caller goes through here. A failed load is retried by the next
+ * call.
+ * @param {string | URL | undefined} wasmUrl
+ */
+export function loadEngineWasm(wasmUrl: string | URL | undefined): any;

package/dist/browser/runtime/wasm.js

@@ -0,0 +1,20 @@
+import init from "alpha2/wasm";
+import * as binding from "alpha2/wasm";
+let loading = null;
+/**
+ * Instantiates `alpha2/wasm` once for this realm and resolves to its exports. wasm-bindgen's own
+ * init reuses an instance only after one has finished: two calls in flight instantiate twice, and
+ * the later instance replaces the module's memory under objects made from the first, whose next
+ * call reads out of bounds. Every caller goes through here. A failed load is retried by the next
+ * call.
+ * @param {string | URL | undefined} wasmUrl
+ */
+export function loadEngineWasm(wasmUrl) {
+    loading ??= init(wasmUrl ? { module_or_path: wasmUrl } : undefined)
+        .then(() => binding)
+        .catch((error) => {
+        loading = null;
+        throw error;
+    });
+    return loading;
+}