@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/player/bitmap/bitmap.js

@@ -0,0 +1,627 @@
+/** The nearest integer, a half to the even one, as C's rint rounds and Flash's pixel coordinates do. */
+export function nearest(v) {
+    const f = Math.floor(v);
+    const d = v - f;
+    if (d !== 0.5) {
+        return d > 0.5 ? f + 1 : f;
+    }
+    return f % 2 === 0 ? f : f + 1;
+}
+/** How far a rect's edge reaches either way, as adl clamps it: 2^30 - 1. */
+export const EDGE_LIMIT = 0x3fffffff;
+/** The edge NaN makes, which lies off every bitmap: int's least. */
+export const NAN_EDGE = -0x80000000;
+/**
+ * A rect's edge as a pixel: rounded to the nearest, a half to the even
+ * one, then clamped to EDGE_LIMIT, so that Infinity and 1e20 lie past
+ * every bitmap as a huge finite edge does; NaN, which the clamp lets
+ * through, is int's least, as adl converts it (a copy's point moved by a
+ * clamped edge lands where 2^30 - 1 puts it).
+ */
+export function pixelEdge(v) {
+    if (Number.isNaN(v)) {
+        return NAN_EDGE;
+    }
+    return Math.max(-EDGE_LIMIT, Math.min(EDGE_LIMIT, nearest(v))) + 0;
+}
+/**
+ * A flash.geom.Rectangle's numbers as the pixels Flash takes it to cover:
+ * each edge, x and x + width, as pixelEdge makes it, so a rect from 1.6 of
+ * 1.8 covers the pixel at 2 alone, and one from 3.5 of 1 covers none
+ * (Ruffle's bitmapdata_rectangle_rounding; under adl the same for every
+ * operation taking a rect). A width of Infinity reaches the bitmap's edge,
+ * one of NaN covers nothing, and an x of NaN or Infinity nothing either.
+ */
+export function pixelRect(x, y, width, height) {
+    const x0 = pixelEdge(x);
+    const y0 = pixelEdge(y);
+    return { x: x0, y: y0, width: pixelEdge(x + width) - x0, height: pixelEdge(y + height) - y0 };
+}
+/**
+ * pixelRect of the rect as merge, copyChannel, paletteMap, threshold and
+ * pixelDissolve take it under adl: a negative width or height spans back
+ * from x to x + width, turned round on the numbers before their edges are
+ * made, so that 5 of -1e20 is a rect from -1e20 of 1e20, which the double
+ * rounds to end at 0, not one reaching from the clamped edge to 5.
+ */
+export function spanRect(x, y, width, height) {
+    if (width < 0) {
+        x += width;
+        width = -width;
+    }
+    if (height < 0) {
+        y += height;
+        height = -height;
+    }
+    return pixelRect(x, y, width, height);
+}
+/** No gaps, shared by every copy that leaves none. */
+const NO_GAPS = [];
+/** The reciprocals Flash divides alpha out with, 8.8 fixed point. */
+const RECIPROCAL = new Uint32Array(256);
+for (let a = 1; a < 256; a++) {
+    RECIPROCAL[a] = Math.floor(0xff00 / a);
+}
+/** `argb` with its colour channels premultiplied by its alpha. */
+export function premultiply(argb) {
+    const a = argb >>> 24;
+    if (a === 255) {
+        return argb >>> 0;
+    }
+    if (a === 0) {
+        return 0;
+    }
+    const r = ((((argb >>> 16) & 0xff) * a + 127) / 255) | 0;
+    const g = ((((argb >>> 8) & 0xff) * a + 127) / 255) | 0;
+    const b = (((argb & 0xff) * a + 127) / 255) | 0;
+    return ((a << 24) | (r << 16) | (g << 8) | b) >>> 0;
+}
+/** A premultiplied pixel with its alpha divided back out. */
+export function unmultiply(pixel) {
+    const a = pixel >>> 24;
+    if (a === 255) {
+        return pixel >>> 0;
+    }
+    if (a === 0) {
+        return 0;
+    }
+    const k = RECIPROCAL[a];
+    const r = Math.min(255, ((((pixel >>> 16) & 0xff) * k + 127) >> 8) >>> 0);
+    const g = Math.min(255, ((((pixel >>> 8) & 0xff) * k + 127) >> 8) >>> 0);
+    const b = Math.min(255, (((pixel & 0xff) * k + 127) >> 8) >>> 0);
+    return ((a << 24) | (r << 16) | (g << 8) | b) >>> 0;
+}
+export class BitmapStore {
+    width;
+    height;
+    transparent;
+    cpu;
+    /**
+     * Whether `cpu` is a library bitmap's pixels, which every store made of it
+     * shares: copied before it is first written, so an atlas a SWF only reads
+     * from is one array, not one for the library and one for each BitmapData.
+     */
+    shared = false;
+    /** The renderers' copies of the store, one each, for `dispose` to free. */
+    copies = new Set();
+    /** The copy a draw wrote last, which reading `pixels` brings back while it is newer; null for none. */
+    gpu = null;
+    /** Whether the GPU's copy was written last, so the CPU's is behind until read. */
+    gpuNewer = false;
+    /** Counts each change, so a texture of the store knows to upload again. */
+    version = 0;
+    /**
+     * Whether the store is opaque but holds pixels below alpha 255, which
+     * erase and alpha leave in one (drawBitmap), as Flash's memory does.
+     * Its pixels then read two ways (adl): as they are, by what reads their
+     * values (getPixel32, getPixels, getVector, clone, compare, floodFill,
+     * Context3D's upload, a ShaderJob's input, unmultiplied), and opaque,
+     * alpha 255 over the premultiplied colour, by what draws or copies them
+     * (draw, copyPixels, encode, the screen, hitTest's alpha): `drawable`.
+     */
+    holdsAlpha = false;
+    /** `drawable`'s pixels and the version they are of, while the store holds alpha. */
+    opaqueCopy = null;
+    opaqueVersion = -1;
+    disposed = false;
+    /**
+     * The Bitmaps showing the store, told of each change so the renderer
+     * looks at them; held weakly, so a Bitmap taken off the display list
+     * and dropped is collected though the BitmapData lives on.
+     */
+    views = new Set();
+    /** `shared`, where given, is the pixels it holds, its own until written: see `of`. */
+    constructor(width, height, transparent, fill, shared) {
+        this.width = width;
+        this.height = height;
+        this.transparent = transparent;
+        if (shared) {
+            this.cpu = shared;
+            this.shared = true;
+            return;
+        }
+        this.cpu = new Uint32Array(width * height);
+        this.cpu.fill(this.premultiplied(fill));
+    }
+    /**
+     * Premultiplied ARGB, row by row, to read and write. Reading them brings
+     * the GPU's copy back first if a draw wrote it last, once: every CPU
+     * operation reads them, so each sees the store as the GPU left it. Shared
+     * pixels are copied first, as they may be written.
+     */
+    get pixels() {
+        const pixels = this.readable;
+        if (this.shared) {
+            this.cpu = pixels.slice();
+            this.shared = false;
+        }
+        return this.cpu;
+    }
+    set pixels(pixels) {
+        this.cpu = pixels;
+        this.shared = false;
+        this.gpuNewer = false;
+    }
+    /**
+     * The pixels as `pixels` gives them, to read only, never to write: shared
+     * pixels stay shared. An operation that writes a store and reads another,
+     * which may be the same, takes the one it writes first, so both are one array.
+     */
+    get readable() {
+        if (this.gpuNewer && this.gpu) {
+            this.cpu = this.gpu.read();
+            this.shared = false;
+        }
+        this.gpuNewer = false;
+        return this.cpu;
+    }
+    /** Whether the GPU's copy is newer than the CPU's, which a read of `pixels` would bring back. */
+    get newerOnGpu() {
+        return this.gpuNewer;
+    }
+    /** A draw wrote `copy`: the store changed, and the CPU's pixels and every other copy are behind it until read. */
+    drawnOnGpu(copy) {
+        this.gpu = copy;
+        this.gpuNewer = true;
+        this.changed();
+        copy.version = this.version;
+    }
+    /**
+     * The pixels for `copy` to upload once its context was lost and given
+     * back: the CPU's, a draw only the copy held lost with it, not read back
+     * from the texture, which is empty now.
+     */
+    lostOnGpu(copy) {
+        if (this.gpu === copy) {
+            this.gpu = null;
+            this.gpuNewer = false;
+        }
+        return this.readable;
+    }
+    /**
+     * `op` done on the GPU's copy where that is newer, so the pixels stay
+     * there: an operation after a draw would otherwise wait for the GPU and
+     * bring the whole store back, on every frame of a SWF that draws and then
+     * scrolls, fills or copies. Only an operation the GPU does exactly takes
+     * this way: moves of whole pixels and fills, never arithmetic. Whether
+     * it was done.
+     */
+    onGpu(op) {
+        const copy = this.gpu;
+        if (!this.gpuNewer || !copy || !op(copy)) {
+            return false;
+        }
+        // The op may have read the pixels back, for a texture of this store that
+        // was behind: the CPU then holds them as they were before it.
+        this.gpuNewer = true;
+        this.changed();
+        copy.version = this.version;
+        return true;
+    }
+    /**
+     * A store of its own holding `pixels`, premultiplied already, which are
+     * never written: the store shares them until it is.
+     */
+    static of(pixels) {
+        return new BitmapStore(pixels.width, pixels.height, pixels.transparent, 0, pixels.pixels);
+    }
+    /** `argb` as this store keeps it: premultiplied, and opaque where the store is. */
+    premultiplied(argb) {
+        return premultiply(this.transparent ? argb : argb | 0xff000000);
+    }
+    /** The rect clipped to the store: null where nothing of it lies within. */
+    clip(r) {
+        const x0 = Math.max(0, r.x);
+        const y0 = Math.max(0, r.y);
+        const x1 = Math.min(this.width, r.x + r.width);
+        const y1 = Math.min(this.height, r.y + r.height);
+        if (x1 <= x0 || y1 <= y0) {
+            return null;
+        }
+        return { x: x0, y: y0, width: x1 - x0, height: y1 - y0 };
+    }
+    getPixel32(x, y) {
+        if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+            return 0;
+        }
+        return this.unmultiplied(this.readable[y * this.width + x]);
+    }
+    /**
+     * A stored pixel as its value reads back: unmultiplied, but an opaque
+     * bitmap's as it is, which is the same but where it holds alpha.
+     */
+    unmultiplied(p) {
+        return this.transparent ? unmultiply(p) : p;
+    }
+    /**
+     * The pixels as a draw, a copy or the screen reads them, to read only:
+     * `readable`, but where an opaque store holds alpha, a copy at alpha 255.
+     */
+    get drawable() {
+        const pixels = this.readable;
+        if (!this.holdsAlpha) {
+            return pixels;
+        }
+        if (this.opaqueCopy === null || this.opaqueVersion !== this.version) {
+            const copy = this.opaqueCopy?.length === pixels.length
+                ? this.opaqueCopy
+                : new Uint32Array(pixels.length);
+            for (let i = 0; i < pixels.length; i++) {
+                copy[i] = (pixels[i] | 0xff000000) >>> 0;
+            }
+            this.opaqueCopy = copy;
+            this.opaqueVersion = this.version;
+        }
+        return this.opaqueCopy;
+    }
+    getPixel(x, y) {
+        return this.getPixel32(x, y) & 0xffffff;
+    }
+    setPixel32(x, y, argb) {
+        if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+            return;
+        }
+        this.pixels[y * this.width + x] = this.premultiplied(argb);
+        this.changed();
+    }
+    /** The colour set, the alpha kept as it was. */
+    setPixel(x, y, rgb) {
+        if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
+            return;
+        }
+        const alpha = unmultiply(this.pixels[y * this.width + x]) & 0xff000000;
+        this.pixels[y * this.width + x] = this.premultiplied((alpha | (rgb & 0xffffff)) >>> 0);
+        this.changed();
+    }
+    fillRect(r, argb) {
+        const c = this.clip(r);
+        if (!c) {
+            return;
+        }
+        const pixel = this.premultiplied(argb);
+        if (this.onGpu((copy) => copy.fill(c, pixel))) {
+            return;
+        }
+        for (let y = c.y; y < c.y + c.height; y++) {
+            this.pixels.fill(pixel, y * this.width + c.x, y * this.width + c.x + c.width);
+        }
+        this.changed();
+    }
+    /**
+     * Flash's copyPixels: the source rect's pixels at the destination point,
+     * both clipped to their stores. With an alpha bitmap each premultiplied
+     * channel is scaled by its alpha at the matching point, k = a, or 256
+     * for 255, then shifted down 8, and where the alpha bitmap does not
+     * reach, the destination is left as it was; Ruffle's
+     * bitmapdata_copypixels_alpha_combine records Flash's 65,536 cases.
+     * Without `mergeAlpha` the pixels replace the destination's; with it,
+     * and always into an opaque destination, they go source over
+     * destination, s + ((d * (256 - sa)) >> 8) a channel (the 160 cases of
+     * bitmapdata_copypixels_alpha_merge). In place, a rect reaching past
+     * the bitmap's left or top edge may leave a gap (copyGaps).
+     */
+    copyPixels(source, rect, dx, dy, mergeAlpha, alpha = null, ax = 0, ay = 0) {
+        const gaps = source === this ? this.copyGaps(rect, dx, dy) : NO_GAPS;
+        // The point and alpha point as given, which the gaps are written from.
+        const gx = dx;
+        const gy = dy;
+        const gax = ax;
+        const gay = ay;
+        const s = source.clip(rect);
+        const d = s &&
+            this.clip({ x: dx + s.x - rect.x, y: dy + s.y - rect.y, width: s.width, height: s.height });
+        if (!s || !d) {
+            if (gaps.length) {
+                this.fillGaps(gaps, source, gx, gy, mergeAlpha, alpha, gax, gay);
+                this.changed();
+            }
+            return;
+        }
+        dx += s.x - rect.x;
+        dy += s.y - rect.y;
+        ax += s.x - rect.x;
+        ay += s.y - rect.y;
+        const sx = s.x + (d.x - dx);
+        const sy = s.y + (d.y - dy);
+        ax += d.x - dx;
+        ay += d.y - dy;
+        // A plain replacement, where the pixels land as they are: an opaque
+        // source's go over anything unchanged, and a gap is empty. In place,
+        // all but a move down and left, which Flash's order smears, are a
+        // memmove.
+        const replaces = !alpha && !source.holdsAlpha && (!source.transparent || (this.transparent && !mergeAlpha));
+        const smears = source === this && d.y > sy && d.x < sx;
+        if (replaces &&
+            !smears &&
+            this.onGpu((copy) => copy.copy(source, { x: sx, y: sy, width: d.width, height: d.height }, d.x, d.y) &&
+                gaps.every((gap) => copy.fill(gap, source.transparent ? 0 : 0xff000000)))) {
+            return;
+        }
+        // In place, in Flash's order, which reads what it already wrote in one
+        // direction (Ruffle's bitmapdata_copypixels_self): rows bottom-up when
+        // the copy moves down without moving left, columns right to left when
+        // it moves right.
+        const up = source === this && d.y > sy && d.x >= sx;
+        const left = source === this && d.x > sx;
+        // The arrays taken once, the written one first: a source or alpha that is this store reads
+        // it too, and so what the copy already wrote. A source that holds alpha is copied opaque, as
+        // a draw reads it; within itself, as it is.
+        const into = this.pixels;
+        const pixels = source !== this && source.holdsAlpha ? source.drawable : source.readable;
+        const mask = alpha?.readable ?? null;
+        const maskWidth = alpha?.width ?? 0;
+        const maskHeight = alpha?.height ?? 0;
+        for (let r = 0; r < d.height; r++) {
+            const row = up ? d.height - 1 - r : r;
+            const to = (d.y + row) * this.width + d.x;
+            const from = (sy + row) * source.width + sx;
+            for (let c = 0; c < d.width; c++) {
+                const i = left ? d.width - 1 - c : c;
+                let p = pixels[from + i];
+                if (mask) {
+                    const mx = ax + i;
+                    const my = ay + row;
+                    if (mx < 0 || my < 0 || mx >= maskWidth || my >= maskHeight) {
+                        continue;
+                    }
+                    p = scale(p, mask[my * maskWidth + mx] >>> 24);
+                }
+                into[to + i] = this.composite(p, into[to + i], mergeAlpha);
+            }
+        }
+        this.fillGaps(gaps, source, gx, gy, mergeAlpha, alpha, gax, gay);
+        this.changed();
+    }
+    /**
+     * The parts of an in-place copy Flash leaves empty: moved right and down
+     * by no more than its size, the rect is written whole from (dx, dy), and
+     * what of it lies left of or above the bitmap reads as nothing, where any
+     * other move (or another source) clips it and moves the point with it.
+     * Within the store, and apart; none for any other copy.
+     */
+    copyGaps(rect, dx, dy) {
+        // Where the source's (0, 0) lands.
+        const kx = dx - rect.x;
+        const ky = dy - rect.y;
+        if ((rect.x >= 0 && rect.y >= 0) ||
+            rect.width <= 0 ||
+            rect.height <= 0 ||
+            kx < 0 ||
+            ky < 0 ||
+            kx > rect.width ||
+            ky > rect.height) {
+            return NO_GAPS;
+        }
+        const right = dx + rect.width;
+        const bottom = dy + rect.height;
+        const left = this.clip({ x: dx, y: dy, width: Math.min(kx, right) - dx, height: rect.height });
+        const x0 = Math.max(dx, kx);
+        const top = this.clip({ x: x0, y: dy, width: right - x0, height: Math.min(ky, bottom) - dy });
+        return [left, top].filter((r) => r !== null);
+    }
+    /**
+     * The gaps of an in-place copy written, as an empty pixel copied: a
+     * transparent bitmap's are what Flash's memory held there, taken as
+     * transparent; an opaque one's Flash reads back as 0, alpha and all, and
+     * draws black, which this keeps them, as opaque black.
+     */
+    fillGaps(gaps, source, dx, dy, mergeAlpha, alpha, ax, ay) {
+        const empty = source.transparent ? 0 : 0xff000000;
+        for (const gap of gaps) {
+            for (let y = gap.y; y < gap.y + gap.height; y++) {
+                for (let x = gap.x; x < gap.x + gap.width; x++) {
+                    let p = empty;
+                    if (alpha) {
+                        const mx = ax + x - dx;
+                        const my = ay + y - dy;
+                        if (mx < 0 || my < 0 || mx >= alpha.width || my >= alpha.height) {
+                            continue;
+                        }
+                        p = scale(p, alpha.readable[my * alpha.width + mx] >>> 24);
+                    }
+                    const i = y * this.width + x;
+                    this.pixels[i] = this.composite(p, this.pixels[i], mergeAlpha);
+                }
+            }
+        }
+    }
+    /** A copied pixel `p` on `d`: over it into an opaque store or merging, else in its place. */
+    composite(p, d, mergeAlpha) {
+        if (!this.transparent) {
+            return (over(p, d) | 0xff000000) >>> 0;
+        }
+        return mergeAlpha ? over(p, d) : p;
+    }
+    /** The rect's pixels, unmultiplied ARGB, row by row; the rect clipped to the store. */
+    getVector(r) {
+        const c = this.clip(r);
+        const out = [];
+        if (!c) {
+            return out;
+        }
+        for (let y = c.y; y < c.y + c.height; y++) {
+            for (let x = c.x; x < c.x + c.width; x++) {
+                out.push(this.unmultiplied(this.readable[y * this.width + x]));
+            }
+        }
+        return out;
+    }
+    /** Unmultiplied ARGB words in the destination's byte order, row by row; the rect clipped to the store. */
+    argbBytes(rect, littleEndian = false) {
+        const c = this.clip(rect);
+        if (!c) {
+            return new Uint8Array(0);
+        }
+        const pixels = this.readable;
+        const out = new Uint8Array(c.width * c.height * 4);
+        const view = new DataView(out.buffer);
+        let j = 0;
+        for (let y = c.y; y < c.y + c.height; y++) {
+            for (let i = y * this.width + c.x, end = i + c.width; i < end; i++, j += 4) {
+                const p = this.unmultiplied(pixels[i]);
+                view.setUint32(j, p, littleEndian);
+            }
+        }
+        return out;
+    }
+    /** The rect's pixels set from `values`, unmultiplied ARGB, row by row, as far as they go; how many it took. */
+    setVector(r, values) {
+        const c = this.clip(r);
+        if (!c) {
+            return 0;
+        }
+        // As many as there are values, row by row; the rest stay.
+        let k = 0;
+        for (let y = c.y; y < c.y + c.height && k < values.length; y++) {
+            for (let x = c.x; x < c.x + c.width && k < values.length; x++) {
+                this.pixels[y * this.width + x] = this.premultiplied(values[k++] >>> 0);
+            }
+        }
+        this.changed();
+        return k;
+    }
+    clone() {
+        const copy = new BitmapStore(this.width, this.height, this.transparent, 0);
+        copy.pixels.set(this.readable);
+        return copy;
+    }
+    dispose() {
+        this.pixels = new Uint32Array(0);
+        for (const copy of this.copies) {
+            copy.destroy();
+        }
+        this.copies.clear();
+        this.gpu = null;
+        this.disposed = true;
+        this.changed();
+    }
+    /** A change: counted, and told to each Bitmap showing the store. */
+    changed() {
+        this.version++;
+        for (const ref of this.views) {
+            const view = ref.deref();
+            if (view) {
+                view.pixelsChanged(this.disposed);
+            }
+            else {
+                this.views.delete(ref);
+            }
+        }
+    }
+}
+/** Source over destination, both premultiplied, as Flash does: s + ((d * (256 - sa)) >> 8) a channel. */
+export function over(s, d) {
+    const sa = s >>> 24;
+    if (sa === 255) {
+        return s >>> 0;
+    }
+    if (sa === 0) {
+        return d >>> 0;
+    }
+    // Each channel written out: a closure over s and d would take a context each pixel.
+    const k = 256 - sa;
+    return (((Math.min(255, sa + (((d >>> 24) * k) >> 8)) << 24) |
+        (Math.min(255, ((s >>> 16) & 0xff) + ((((d >>> 16) & 0xff) * k) >> 8)) << 16) |
+        (Math.min(255, ((s >>> 8) & 0xff) + ((((d >>> 8) & 0xff) * k) >> 8)) << 8) |
+        Math.min(255, (s & 0xff) + (((d & 0xff) * k) >> 8))) >>>
+        0);
+}
+/** A premultiplied pixel's channels scaled by an alpha, as Flash's alpha bitmap scales them. */
+function scale(p, a) {
+    if (a === 255) {
+        return p >>> 0;
+    }
+    return ((((((p >>> 24) * a) >> 8) << 24) |
+        (((((p >>> 16) & 0xff) * a) >> 8) << 16) |
+        (((((p >>> 8) & 0xff) * a) >> 8) << 8) |
+        (((p & 0xff) * a) >> 8)) >>>
+        0);
+}
+/** Each bitmap's fill store, by its pixels, which the SWFs that define the bitmap alike share. */
+const fillStores = new WeakMap();
+/**
+ * The store a SWF bitmap's fills draw from, one for all its shapes and for
+ * every SWF that defines it alike, so one texture; null until its image is
+ * decoded. Nothing writes it.
+ */
+export function characterStore(character) {
+    const pixels = character.pixels;
+    if (!pixels) {
+        return null;
+    }
+    if (!character.store) {
+        let store = fillStores.get(pixels);
+        if (!store) {
+            store = BitmapStore.of(pixels);
+            fillStores.set(pixels, store);
+        }
+        character.store = store;
+    }
+    return character.store;
+}
+/** Whether a word's low byte comes first in memory, as on every machine a browser runs on. */
+const LITTLE_ENDIAN = new Uint8Array(new Uint32Array([1]).buffer)[0] === 1;
+/** Premultiplied ARGB as the RGBA bytes a texture holds, still premultiplied. */
+export function rgbaOf(pixels) {
+    const out = new Uint8Array(pixels.length * 4);
+    rgbaInto(pixels, out);
+    return out;
+}
+/**
+ * rgbaOf into `out`, `pixels.length * 4` bytes or more, as a texture
+ * uploaded again and again takes it; `opaque`, every alpha 255, as an
+ * opaque store holding alpha draws (BitmapStore's drawable). Little-endian,
+ * a pixel is a word whose red and blue swap, written whole rather than a
+ * byte at a time.
+ */
+export function rgbaInto(pixels, out, opaque = false) {
+    if (out.length < pixels.length * 4) {
+        throw new RangeError(`${out.length} bytes hold no ${pixels.length} pixels`);
+    }
+    const alpha = opaque ? 0xff000000 : 0;
+    if (LITTLE_ENDIAN && out.byteOffset % 4 === 0) {
+        const words = new Uint32Array(out.buffer, out.byteOffset, pixels.length);
+        for (let i = 0; i < pixels.length; i++) {
+            const p = pixels[i] | alpha;
+            words[i] = (p & 0xff00ff00) | ((p >>> 16) & 0xff) | ((p & 0xff) << 16);
+        }
+        return;
+    }
+    for (let i = 0; i < pixels.length; i++) {
+        const p = pixels[i] | alpha;
+        const j = i * 4;
+        out[j] = (p >>> 16) & 0xff;
+        out[j + 1] = (p >>> 8) & 0xff;
+        out[j + 2] = p & 0xff;
+        out[j + 3] = p >>> 24;
+    }
+}
+/** RGBA bytes read from a texture as premultiplied ARGB. */
+export function argbOf(bytes) {
+    const out = new Uint32Array(bytes.length / 4);
+    for (let i = 0; i < out.length; i++) {
+        const j = i * 4;
+        out[i] = ((bytes[j + 3] << 24) | (bytes[j] << 16) | (bytes[j + 1] << 8) | bytes[j + 2]) >>> 0;
+    }
+    return out;
+}

package/dist/thread/player/bitmap/draw.js

@@ -0,0 +1,68 @@
+// A display object drawn into a bitmap: rendered by the host's renderer
+// over its own bounds alone, then composited as a bitmap is (ops.ts
+// drawBitmap). AS3's BitmapData.draw and AVM1's share it.
+import { bounds } from "../display/bounds.js";
+import { pickWork } from "../display/display.js";
+import { transformRect } from "../display/geometry.js";
+import { drawnAsStage } from "../display/perspective.js";
+import { BitmapStore } from "./bitmap.js";
+import { drawBitmap } from "./ops.js";
+/** `d` drawn into `store` through `m`, as drawInto draws a display object. */
+function drawObject(drawer, store, d, m, c, blend, r, samples) {
+    // Only the part the object can reach: its bounds through the matrix, a
+    // pixel wider for anti-aliasing, within the clip and the bitmap; the
+    // snapshot's cost is then the object's size, not the bitmap's.
+    const local = bounds(d, true);
+    if (!local) {
+        return;
+    }
+    const reach = transformRect(local, m);
+    const x0 = Math.max(0, Math.floor(reach.xMin) - 1, r ? r.x : 0);
+    const y0 = Math.max(0, Math.floor(reach.yMin) - 1, r ? r.y : 0);
+    const x1 = Math.min(store.width, Math.ceil(reach.xMax) + 1, r ? r.x + r.width : store.width);
+    const y1 = Math.min(store.height, Math.ceil(reach.yMax) + 1, r ? r.y + r.height : store.height);
+    if (x1 <= x0 || y1 <= y0) {
+        return;
+    }
+    const placed = { ...m, tx: m.tx - x0, ty: m.ty - y0 };
+    // Plain source over goes on the GPU, the store left there until a script reads it.
+    if (!c &&
+        blend === "normal" &&
+        drawer.drawInto(store, d, placed, x0, y0, x1 - x0, y1 - y0, samples)) {
+        return;
+    }
+    // Erase and alpha go by where the object is, not how much of a pixel it covers: adl draws
+    // them unsmoothed, as low quality draws.
+    const grid = blend === "erase" || blend === "alpha" ? 1 : samples;
+    const drawn = new BitmapStore(x1 - x0, y1 - y0, true, 0);
+    drawn.pixels = drawer.snapshot(d, placed, x1 - x0, y1 - y0, grid);
+    const at = { a: 1, b: 0, c: 0, d: 1, tx: x0, ty: y0 };
+    drawBitmap(store, drawn, at, c, blend, r, false, false, "drawing");
+}
+/**
+ * A display object drawn into `store` through `m` by `drawer`, the host's
+ * renderer, over its own bounds alone, then composited as a bitmap is: an
+ * AS3 BitmapData's draw, and an AVM1 one's.
+ */
+export function drawDisplayObject(drawer, store, d, m, c, blend, r, samples) {
+    // What is in 3D in an object on no stage projects as on a stage the bitmap's size.
+    let top = d;
+    while (top.parent) {
+        top = top.parent;
+    }
+    const restore = drawnAsStage(top, store.width, store.height);
+    if (!restore) {
+        drawObject(drawer, store, d, m, c, blend, r, samples);
+        return;
+    }
+    // Planes in perspective made before are made again, for that stage and after it; only then,
+    // as each change picks the pointer's hover again and remakes every plane.
+    pickWork.changes++;
+    try {
+        drawObject(drawer, store, d, m, c, blend, r, samples);
+    }
+    finally {
+        restore();
+        pickWork.changes++;
+    }
+}