@swf2es/player 0.0.0-stage → 0.1.0

package/src/playerglobal/flash/display/BitmapData.ts

@@ -0,0 +1,963 @@
+// flash.display.BitmapData: a pixel store (bitmap/bitmap.ts) behind the AS3
+// object, as $store; the natives read and write it. Flash's limits and its
+// ArgumentError 2015 for a size it refuses and for a store disposed.
+import { avm2 } from "@swf2es/runtime";
+import { BitmapStore, type PixelRect, pixelRect, spanRect } from "../../../bitmap/bitmap.js";
+import { drawDisplayObject } from "../../../bitmap/draw.js";
+import {
+  applyFilter,
+  filterRefusal,
+  filtersDrawn,
+  GLOWS,
+  generatedRect,
+} from "../../../bitmap/filters.js";
+import {
+  type Affine,
+  alphaAt,
+  colorBounds,
+  colorTransform,
+  comparePixels,
+  copyChannel,
+  drawBitmap,
+  floodFill,
+  histogram,
+  isThresholdOperation,
+  merge,
+  noise,
+  paletteMap,
+  perlinNoise,
+  pixelDissolve,
+  scroll,
+  threshold,
+} from "../../../bitmap/ops.js";
+import { shaderFilter } from "../../../bitmap/pixel-bender.js";
+import { encodePng } from "../../../bitmap/png.js";
+import type { Filter } from "../../../display/filters.js";
+import { type BitmapCharacter, INVALID_PIXELS } from "../../../display/timeline.js";
+import type { Scripting } from "../../../scripting.js";
+import { filterKindOf, recordOf } from "../filters/BitmapFilter.js";
+import { colorOf } from "../geom/Transform.js";
+import { programOf } from "./ShaderData.js";
+import { kernelOfShader, READ, shaderUse } from "./shaders.js";
+
+/** The longest side adl makes a BitmapData of: 2^31 / 20, whole. */
+const MAX_SIDE = 107374182;
+
+/** The most pixels adl makes a BitmapData of, whatever its shape: 2146500576 bytes. */
+const MAX_PIXELS = 536625144;
+
+type Value = avm2.Value;
+type AsObject = avm2.AsObject;
+
+/** The store of a BitmapData object, or ArgumentError 2015 where it was disposed or never made. */
+export function storeOf(s: Scripting, o: AsObject): BitmapStore {
+  const store = sizeOf(s, o);
+  // A bitmap of 0 by 0 is one Flash could not read from the SWF: it has a size and nothing else.
+  if (store.width === 0) {
+    throw s.rt.error("ArgumentError", 2015);
+  }
+
+  return store;
+}
+
+/** The store for reading its size: one Flash could not read has it, a disposed one not. */
+function sizeOf(s: Scripting, o: AsObject): BitmapStore {
+  const store: BitmapStore | null | undefined = o.$store;
+  if (!store || store.disposed) {
+    throw s.rt.error("ArgumentError", 2015);
+  }
+
+  return store;
+}
+
+/**
+ * A flash.geom.Rectangle as pixels (bitmap.ts pixelRect), NaN and Infinity
+ * as adl takes them; with `span`, a negative size spanning back, as merge,
+ * copyChannel, paletteMap, threshold and pixelDissolve take it (spanRect).
+ * TypeError 2007 for null.
+ */
+function rectOf(s: Scripting, v: Value, span = false): PixelRect {
+  if (v === null || v === undefined) {
+    throw s.rt.error("TypeError", 2007, "rect");
+  }
+
+  const r = v as AsObject;
+  const read = (k: string) => s.rt.toNumber(s.rt.getProperty(r, s.rt.publicName(k)));
+  return (span ? spanRect : pixelRect)(read("x"), read("y"), read("width"), read("height"));
+}
+
+/**
+ * A flash.geom.Point's values as pixels, truncated toward 0 as Flash's
+ * destination, alpha and hit-test points are, unlike a rect's rounded
+ * edges; NaN, and anything past int's range, int's least, which lies off
+ * every bitmap, as adl takes them; TypeError 2007 for null.
+ */
+function pointOf(s: Scripting, v: Value, name: string): [number, number] {
+  if (v === null || v === undefined) {
+    throw s.rt.error("TypeError", 2007, name);
+  }
+
+  const p = v as AsObject;
+  const read = (k: string) => {
+    const t = Math.trunc(s.rt.toNumber(s.rt.getProperty(p, s.rt.publicName(k))));
+    return t >= -0x80000000 && t <= 0x7fffffff ? t + 0 : -0x80000000;
+  };
+  return [read("x"), read("y")];
+}
+
+/** A source BitmapData's store; TypeError 2007 for null. */
+function sourceOf(s: Scripting, v: Value): BitmapStore {
+  if (v === null || v === undefined) {
+    throw s.rt.error("TypeError", 2007, "sourceBitmapData");
+  }
+
+  return storeOf(s, v as AsObject);
+}
+
+/**
+ * draw: a BitmapData, or a Bitmap as its data, its own transform ignored,
+ * composited on the CPU (bitmap/ops.ts drawBitmap); any other display
+ * object rendered by the Scripting's drawer at `samples` a side, over its
+ * own bounds alone, then composited the same way. A null source is
+ * ArgumentError 2005, as Flash words it.
+ */
+function drawInto(
+  s: Scripting,
+  store: BitmapStore,
+  source: Value,
+  matrix: Value,
+  ct: Value,
+  mode: Value,
+  clip: Value,
+  smoothing: Value,
+  samples = 4,
+): void {
+  if (source === null || source === undefined) {
+    throw s.rt.error("ArgumentError", 2005, 0);
+  }
+
+  const o = source as AsObject;
+  const data: AsObject | null =
+    o.$store !== undefined ? o : o.$display?.store !== undefined ? (o.$bitmapData ?? null) : null;
+  if (data === null && o.$display === undefined) {
+    throw s.rt.error("ArgumentError", 2005, 0);
+  }
+
+  const m =
+    matrix === null || matrix === undefined
+      ? { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 }
+      : matrixOf(s, matrix as AsObject);
+  const c = ct === null || ct === undefined ? null : colorOf(s, ct as AsObject);
+  const blend = mode === null || mode === undefined ? "normal" : s.rt.toString(mode);
+  const r = clip === null || clip === undefined ? null : rectOf(s, clip);
+  if (data === null) {
+    // Any other display object, through the renderer, then composited as a bitmap is.
+    if (!s.drawer) {
+      throw s.rt.unsupported("BitmapData#draw of a display object without a renderer");
+    }
+
+    drawDisplayObject(s.drawer, store, o.$display, m, c, blend, r, samples);
+    return;
+  }
+
+  if (data.$bitmapData === null && data.$store === undefined) {
+    return;
+  }
+
+  // A BitmapData drawn into itself goes a row at a time; through a Bitmap, in scan order. A
+  // Bitmap is a display object, whose erase and alpha blends a BitmapData's are not.
+  const bitmap = o.$store === undefined;
+  drawBitmap(
+    store,
+    storeOf(s, data),
+    m,
+    c,
+    blend,
+    r,
+    !!smoothing,
+    !bitmap,
+    bitmap ? "bitmap" : null,
+  );
+}
+
+/**
+ * A flash.geom.Matrix's six values, its translation as draw takes it under
+ * adl, in twips in an int: NaN is int's least, and so is anything past
+ * the int's range, Infinity too, which a matrix that only moves draws at
+ * 0 (and any other off every bitmap); and a move within 2^30 twips of
+ * the range's ends wraps round to near 0, 107374180 drawing at -2.4.
+ */
+function matrixOf(s: Scripting, o: AsObject): Affine {
+  const read = (k: string) => s.rt.toNumber(s.rt.getProperty(o, s.rt.publicName(k)));
+  const m = {
+    a: read("a"),
+    b: read("b"),
+    c: read("c"),
+    d: read("d"),
+    tx: read("tx"),
+    ty: read("ty"),
+  };
+  const moves = m.a === 1 && m.b === 0 && m.c === 0 && m.d === 1;
+  const twips = (t: number) => {
+    const v = t * 20;
+    if (Number.isNaN(v) || (moves && Math.abs(v) >= 2 ** 31)) {
+      return 0;
+    }
+
+    return moves && Math.abs(v) >= 2 ** 30 ? (v - Math.sign(v) * 2 ** 31) / 20 : t;
+  };
+  m.tx = twips(m.tx);
+  m.ty = twips(m.ty);
+  return m;
+}
+
+/** Samples a side of each pixel a display object is rendered at, by drawWithQuality's quality: Flash's 1, 2 and 4. */
+function samplesOf(s: Scripting, quality: Value): number {
+  if (quality === null || quality === undefined) {
+    return 4;
+  }
+
+  switch (s.rt.toString(quality).toLowerCase()) {
+    case "low":
+      return 1;
+    case "medium":
+      return 2;
+    default:
+      return 4;
+  }
+}
+
+export function bitmapDataNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+  /** A filter object's record; TypeError 2007 for null, as for anything that is no filter. */
+  const filterOf = (v: Value): Filter => {
+    const kind = v && typeof v === "object" ? filterKindOf(s.rt, v as AsObject) : null;
+    if (!kind) {
+      throw s.rt.error("TypeError", 2007, "filter");
+    }
+
+    return recordOf(v as AsObject, kind);
+  };
+
+  class BitmapDataNatives {
+    declare $store: BitmapStore | null;
+    declare $symbol: BitmapCharacter | null;
+
+    "flash.display:BitmapData::ctor"(
+      width: Value,
+      height: Value,
+      transparent: Value,
+      fill: Value,
+    ): void {
+      // A class SymbolClass binds to a bitmap has its pixels, whatever size it asks for.
+      const symbol: BitmapCharacter | null = this.$symbol;
+      if (symbol) {
+        this.$store = BitmapStore.of(symbol.pixels ?? INVALID_PIXELS);
+        return;
+      }
+
+      // A side under 1 is refused, and as adl refuses them, a side past 2^31 / 20
+      // (107374183 by 1) and more than MAX_PIXELS (32753 by 16384, 65514 by 8191).
+      const w = s.rt.toInt(width);
+      const h = s.rt.toInt(height);
+      if (w < 1 || h < 1 || w > MAX_SIDE || h > MAX_SIDE || w * h > MAX_PIXELS) {
+        throw s.rt.error("ArgumentError", 2015);
+      }
+
+      // One the browser cannot allocate is refused, as adl refuses what its memory
+      // cannot hold, rather than ending the player with a RangeError.
+      try {
+        this.$store = new BitmapStore(
+          w,
+          h,
+          transparent === undefined ? true : !!transparent,
+          s.rt.toUint(fill === undefined ? 0xffffffff : fill),
+        );
+      } catch (e) {
+        if (e instanceof RangeError) {
+          throw s.rt.error("ArgumentError", 2015);
+        }
+
+        throw e;
+      }
+    }
+
+    // Disposed, every read throws, the size included, as Flash has it.
+    get width(): number {
+      return sizeOf(s, this).width;
+    }
+
+    get height(): number {
+      return sizeOf(s, this).height;
+    }
+
+    get transparent(): boolean {
+      return sizeOf(s, this).transparent;
+    }
+
+    get rect(): Value {
+      const store = sizeOf(s, this);
+      return s.rt.construct(
+        s.rt.classNamed("flash.geom::Rectangle"),
+        0,
+        0,
+        store.width,
+        store.height,
+      );
+    }
+
+    getPixel(x: Value, y: Value): number {
+      return storeOf(s, this).getPixel(s.rt.toInt(x), s.rt.toInt(y));
+    }
+
+    getPixel32(x: Value, y: Value): number {
+      return storeOf(s, this).getPixel32(s.rt.toInt(x), s.rt.toInt(y));
+    }
+
+    setPixel(x: Value, y: Value, color: Value): void {
+      storeOf(s, this).setPixel(s.rt.toInt(x), s.rt.toInt(y), s.rt.toUint(color));
+    }
+
+    setPixel32(x: Value, y: Value, color: Value): void {
+      storeOf(s, this).setPixel32(s.rt.toInt(x), s.rt.toInt(y), s.rt.toUint(color));
+    }
+
+    fillRect(rect: Value, color: Value): void {
+      const store = storeOf(s, this);
+      store.fillRect(rectOf(s, rect), s.rt.toUint(color));
+    }
+
+    clone(): Value {
+      const store = storeOf(s, this);
+      const o = s.rt.construct(
+        s.rt.classNamed("flash.display::BitmapData"),
+        store.width,
+        store.height,
+        store.transparent,
+        0,
+      );
+      o.$store = store.clone();
+      return o;
+    }
+
+    dispose(): void {
+      const store: BitmapStore | null = this.$store;
+      if (store && !store.disposed) {
+        store.dispose();
+      }
+    }
+
+    copyPixels(
+      source: Value,
+      rect: Value,
+      dest: Value,
+      alphaBitmap: Value,
+      alphaPoint: Value,
+      mergeAlpha: Value,
+    ): void {
+      const store = storeOf(s, this);
+      if (source === null || source === undefined) {
+        throw s.rt.error("TypeError", 2007, "sourceBitmapData");
+      }
+
+      const from = storeOf(s, source as AsObject);
+      const r = rectOf(s, rect);
+      const [dx, dy] = pointOf(s, dest, "destPoint");
+      const alpha =
+        alphaBitmap === null || alphaBitmap === undefined
+          ? null
+          : storeOf(s, alphaBitmap as AsObject);
+      const [ax, ay] =
+        alphaPoint === null || alphaPoint === undefined
+          ? [0, 0]
+          : pointOf(s, alphaPoint, "alphaPoint");
+      store.copyPixels(from, r, dx, dy, !!mergeAlpha, alpha, ax, ay);
+    }
+
+    /** `sourceRect` of the source filtered into this at `destPoint`, its filter's rect written whole (bitmap/filters.ts). */
+    applyFilter(source: Value, sourceRect: Value, destPoint: Value, filter: Value): void {
+      const store = storeOf(s, this);
+      const from = sourceOf(s, source);
+      const r = rectOf(s, sourceRect);
+      const [dx, dy] = pointOf(s, destPoint, "destPoint");
+      const f = filterOf(filter);
+      if (f.kind === "shader") {
+        if (!kernelOfShader(f.shader)) {
+          throw s.rt.error("ArgumentError", 2171);
+        }
+
+        // Its inputs read as they are, as a job reads them: run now, not drawn later.
+        const use = shaderUse(s, f.shader, 1, READ);
+        shaderFilter(store, from, r, dx, dy, f.extensions, use, programOf(use.kernel));
+        return;
+      }
+
+      // adl draws none of the filters with a glow into an opaque destination.
+      if (!store.transparent && GLOWS.has(f.kind)) {
+        throw s.rt.error("flash.errors::IllegalOperationError", 2077);
+      }
+
+      switch (filterRefusal(r, f, { x: 0, y: 0, width: from.width, height: from.height })) {
+        case 2015:
+          throw s.rt.error("ArgumentError", 2015);
+        case 2077:
+          throw s.rt.error("flash.errors::IllegalOperationError", 2077);
+      }
+
+      // A displacement map's map as it is now, not as it was when set.
+      const map =
+        f.kind === "displacementMap" && f.mapBitmap ? storeOf(s, f.mapBitmap as AsObject) : null;
+      if (!applyFilter(store, from, r, dx, dy, f, map)) {
+        throw s.rt.unsupported(`BitmapData.applyFilter with a ${f.kind} filter`);
+      }
+    }
+
+    generateFilterRect(sourceRect: Value, filter: Value): Value {
+      const store = storeOf(s, this);
+      const f = filterOf(filter);
+      if (f.kind === "shader") {
+        // This bitmap's rect grown by the extensions, whatever the rect given, as adl gives it.
+        rectOf(s, sourceRect);
+        const [left, top, right, bottom] = f.extensions;
+        return s.rt.construct(
+          s.rt.classNamed("flash.geom::Rectangle"),
+          -left,
+          -top,
+          store.width + left + right,
+          store.height + top + bottom,
+        );
+      }
+
+      if (!filtersDrawn.has(f.kind)) {
+        throw s.rt.unsupported(`BitmapData.generateFilterRect with a ${f.kind} filter`);
+      }
+
+      const r = generatedRect(store.width, store.height, rectOf(s, sourceRect), f);
+      return s.rt.construct(s.rt.classNamed("flash.geom::Rectangle"), r.x, r.y, r.width, r.height);
+    }
+
+    getPixels(rect: Value): Value {
+      const store = storeOf(s, this);
+      const o = s.rt.construct(s.rt.classNamed("flash.utils::ByteArray"));
+      o.$bytes.write(store.argbBytes(rectOf(s, rect)));
+      return o;
+    }
+
+    copyPixelsToByteArray(rect: Value, target: Value): void {
+      const store = storeOf(s, this);
+      if (target === null || target === undefined) {
+        throw s.rt.error("TypeError", 2007, "data");
+      }
+
+      const bytes = (target as AsObject).$bytes;
+      bytes.write(store.argbBytes(rectOf(s, rect), bytes.littleEndian));
+    }
+
+    /**
+     * The rect as an image file, written into `byteArray` from its position
+     * or into a new one, which is returned: PNG; JPEG and JPEG XR, which
+     * Flash also writes, are not supported yet.
+     */
+    encode(rect: Value, compressor: Value, byteArray: Value): Value {
+      const store = storeOf(s, this);
+      if (rect === null || rect === undefined) {
+        throw s.rt.error("TypeError", 2007, "rectangle");
+      }
+
+      if (compressor === null || compressor === undefined) {
+        throw s.rt.error("TypeError", 2007, "compressor");
+      }
+
+      const options = compressor as AsObject;
+      const is = (name: string) => s.rt.isInstance(options, s.rt.classNamed(name));
+      if (!is("flash.display::PNGEncoderOptions")) {
+        if (is("flash.display::JPEGEncoderOptions") || is("flash.display::JPEGXREncoderOptions")) {
+          throw s.rt.unsupported("BitmapData#encode as JPEG");
+        }
+
+        throw s.rt.error("ArgumentError", 2004);
+      }
+
+      const area = store.clip(rectOf(s, rect));
+      if (!area) {
+        throw s.rt.error("ArgumentError", 2006);
+      }
+
+      const fast = !!s.rt.getProperty(options, s.rt.publicName("fastCompression"));
+      const out =
+        byteArray === null || byteArray === undefined
+          ? (s.rt.construct(s.rt.classNamed("flash.utils::ByteArray")) as AsObject)
+          : (byteArray as AsObject);
+      out.$bytes.write(encodePng(store, area, fast));
+      return out;
+    }
+
+    setPixels(rect: Value, input: Value): void {
+      const store = storeOf(s, this);
+      // The parameters checked in order: the rect's null before the input's.
+      const r = rectOf(s, rect);
+      if (input === null || input === undefined) {
+        throw s.rt.error("TypeError", 2007, "inputByteArray");
+      }
+
+      const c = store.clip(r);
+      if (!c) {
+        return;
+      }
+
+      // A pixel at a time, as Flash reads them: those read before the end are set, then EOFError 2030.
+      const bytes = (input as AsObject).$bytes;
+      const values: number[] = [];
+      try {
+        for (let i = 0; i < c.width * c.height; i++) {
+          bytes.checkEOF(4);
+          values.push(bytes.view.getUint32(bytes.position, bytes.littleEndian));
+          bytes.position = (bytes.position + 4) >>> 0;
+        }
+      } finally {
+        store.setVector(c, values);
+      }
+    }
+
+    getVector(rect: Value): Value {
+      const store = storeOf(s, this);
+      const cls = s.rt.resolve(s.rt.vector("uint"));
+      const o = cls.$it.instance();
+      o.$a = store.getVector(rectOf(s, rect));
+      return o;
+    }
+
+    setVector(rect: Value, input: Value): void {
+      const store = storeOf(s, this);
+      const r = rectOf(s, rect);
+      if (input === null || input === undefined) {
+        throw s.rt.error("TypeError", 2007, "imputVector");
+      }
+
+      const c = store.clip(r);
+      if (!c) {
+        return;
+      }
+
+      const values: number[] = (input as AsObject).$a;
+      if (values.length < c.width * c.height) {
+        throw s.rt.error("RangeError", 2006);
+      }
+
+      store.setVector(c, values);
+    }
+
+    noise(seed: Value, low: Value, high: Value, channels: Value, gray: Value): void {
+      noise(
+        storeOf(s, this),
+        s.rt.toInt(seed),
+        low === undefined ? 0 : s.rt.toUint(low),
+        high === undefined ? 255 : s.rt.toUint(high),
+        channels === undefined ? 7 : s.rt.toUint(channels),
+        !!gray,
+      );
+    }
+
+    copyChannel(source: Value, rect: Value, dest: Value, from: Value, to: Value): void {
+      const store = storeOf(s, this);
+      const src = sourceOf(s, source);
+      const r = rectOf(s, rect, true);
+      const [dx, dy] = pointOf(s, dest, "destPoint");
+      copyChannel(store, src, r, dx, dy, s.rt.toUint(from), s.rt.toUint(to));
+    }
+
+    /** Offsets past those given, or not Points, are (0, 0). */
+    perlinNoise(
+      baseX: Value,
+      baseY: Value,
+      octaves: Value,
+      seed: Value,
+      stitch: Value,
+      fractal: Value,
+      channels: Value = 7,
+      gray: Value = false,
+      offsets: Value = null,
+    ): void {
+      const store = storeOf(s, this);
+      const given = (offsets as AsObject | null)?.$a as Value[] | undefined;
+      const point = s.rt.classNamed("flash.geom::Point");
+      const read = (p: AsObject, k: string) =>
+        s.rt.toNumber(s.rt.getProperty(p, s.rt.publicName(k)));
+      // Past 1024 octaves the doubles' ratio would be infinite, where Flash's sum stays as it was from
+      // some 40 on, for any count up to 2^32 - 1, a negative one too (the `perlin-noise` case).
+      const count = Math.min(s.rt.toUint(octaves), 1024);
+      const shifts = Array.from({ length: count }, (_, i): [number, number] => {
+        const p = given?.[i];
+        return p && s.rt.isInstanceOf(p, point.$it)
+          ? [read(p as AsObject, "x"), read(p as AsObject, "y")]
+          : [0, 0];
+      });
+      perlinNoise(
+        store,
+        [s.rt.toNumber(baseX), s.rt.toNumber(baseY)],
+        shifts,
+        s.rt.toInt(seed),
+        !!stitch,
+        !!fractal,
+        s.rt.toUint(channels),
+        !!gray,
+      );
+    }
+
+    paletteMap(
+      source: Value,
+      rect: Value,
+      dest: Value,
+      red: Value = null,
+      green: Value = null,
+      blue: Value = null,
+      alpha: Value = null,
+    ): void {
+      const store = storeOf(s, this);
+      const src = sourceOf(s, source);
+      if (rect === null || rect === undefined) {
+        throw s.rt.error("TypeError", 2007, "sourceRect");
+      }
+
+      const r = rectOf(s, rect, true);
+      const [dx, dy] = pointOf(s, dest, "destPoint");
+      // A channel's table, or itself where none is given.
+      const table = (v: Value, shift: number): Uint32Array =>
+        Uint32Array.from({ length: 256 }, (_, i) =>
+          v === null || v === undefined
+            ? i << shift
+            : s.rt.toUint(s.rt.getProperty(v as AsObject, s.rt.publicName(i))),
+        );
+      paletteMap(store, src, r, dx, dy, [
+        table(red, 16),
+        table(green, 8),
+        table(blue, 0),
+        table(alpha, 24),
+      ]);
+    }
+
+    /**
+     * 0 for the same pixels, a BitmapData of their differences, or -3 and
+     * -4 for another width and height, as Flash's; -1 for this one disposed.
+     */
+    compare(other: Value): Value {
+      if (other === null || other === undefined) {
+        throw s.rt.error("TypeError", 2007, "otherBitmapData");
+      }
+
+      const own: BitmapStore | null = this.$store;
+      if (!own || own.disposed) {
+        return -1;
+      }
+
+      const theirs = storeOf(s, other as AsObject);
+      if (theirs.width !== own.width) {
+        return -3;
+      }
+
+      if (theirs.height !== own.height) {
+        return -4;
+      }
+
+      const pixels = comparePixels(own, theirs);
+      if (!pixels) {
+        return 0;
+      }
+
+      const o = s.rt.construct(
+        s.rt.classNamed("flash.display::BitmapData"),
+        own.width,
+        own.height,
+        true,
+        0,
+      ) as AsObject;
+      (o.$store as BitmapStore).pixels.set(pixels);
+      (o.$store as BitmapStore).changed();
+      return o;
+    }
+
+    colorTransform(rect: Value, ct: Value): void {
+      const store = storeOf(s, this);
+      const r = rectOf(s, rect);
+      if (ct === null || ct === undefined) {
+        throw s.rt.error("TypeError", 2007, "colorTransform");
+      }
+
+      // A foot of NaN, int's least, less a top past 0 wraps round in int
+      // arithmetic to a height reaching the bitmap's foot, as adl has it; a
+      // width of NaN covers nothing.
+      r.height |= 0;
+      colorTransform(store, r, colorOf(s, ct as AsObject));
+    }
+
+    merge(
+      source: Value,
+      rect: Value,
+      dest: Value,
+      rMul: Value,
+      gMul: Value,
+      bMul: Value,
+      aMul: Value,
+    ): void {
+      const store = storeOf(s, this);
+      const src = sourceOf(s, source);
+      const r = rectOf(s, rect, true);
+      const [dx, dy] = pointOf(s, dest, "destPoint");
+      merge(
+        store,
+        src,
+        r,
+        dx,
+        dy,
+        [rMul, gMul, bMul, aMul].map((m) => s.rt.toUint(m)) as [number, number, number, number],
+      );
+    }
+
+    scroll(x: Value, y: Value): void {
+      scroll(storeOf(s, this), s.rt.toInt(x), s.rt.toInt(y));
+    }
+
+    threshold(
+      source: Value,
+      rect: Value,
+      dest: Value,
+      op: Value,
+      value: Value,
+      color: Value,
+      mask: Value,
+      copySource: Value,
+    ): number {
+      const store = storeOf(s, this);
+      const src = sourceOf(s, source);
+      const r = rectOf(s, rect, true);
+      const [dx, dy] = pointOf(s, dest, "destPoint");
+      // A String parameter: undefined is null, refused with 2007 before the value is looked at.
+      if (op === null || op === undefined) {
+        throw s.rt.error("TypeError", 2007, "operation");
+      }
+
+      const operation = s.rt.toString(op);
+      if (!isThresholdOperation(operation)) {
+        throw s.rt.error("ArgumentError", 2005, 3);
+      }
+
+      return threshold(
+        store,
+        src,
+        r,
+        dx,
+        dy,
+        operation,
+        s.rt.toUint(value),
+        s.rt.toUint(color),
+        mask === undefined ? 0xffffffff : s.rt.toUint(mask),
+        !!copySource,
+      );
+    }
+
+    getColorBoundsRect(mask: Value, color: Value, find: Value): Value {
+      const r = colorBounds(
+        storeOf(s, this),
+        s.rt.toUint(mask),
+        s.rt.toUint(color),
+        find === undefined ? true : !!find,
+      );
+      return s.rt.construct(s.rt.classNamed("flash.geom::Rectangle"), r.x, r.y, r.width, r.height);
+    }
+
+    floodFill(x: Value, y: Value, color: Value): void {
+      floodFill(storeOf(s, this), s.rt.toInt(x), s.rt.toInt(y), s.rt.toUint(color));
+    }
+
+    histogram(rect: Value): Value {
+      const store = storeOf(s, this);
+      const counts = histogram(
+        store,
+        rect === null || rect === undefined
+          ? { x: 0, y: 0, width: store.width, height: store.height }
+          : rectOf(s, rect),
+      );
+      const inner = s.rt.resolve(s.rt.vector("Number"));
+      const outer = s.rt.applyType(s.rt.classNamed("__AS3__.vec::Vector"), [inner]);
+      const o = outer.$it.instance();
+      o.$a = counts.map((c) => {
+        const v = inner.$it.instance();
+        v.$a = c;
+        return v;
+      });
+      return o;
+    }
+
+    hitTest(
+      firstPoint: Value,
+      firstAlpha: Value,
+      second: Value,
+      secondPoint: Value,
+      secondAlpha: Value,
+    ): boolean {
+      const store = storeOf(s, this);
+      const [fx, fy] = pointOf(s, firstPoint, "firstPoint");
+      // adl refuses a point the bitmap, put there, would reach past int's range from.
+      if (fx + store.width > 0x7fffffff || fy + store.height > 0x7fffffff) {
+        throw s.rt.error("ArgumentError", 1508, "firstPoint");
+      }
+
+      const a1 = s.rt.toUint(firstAlpha);
+      const other = second as AsObject;
+      if (other === null || other === undefined) {
+        throw s.rt.error("ArgumentError", 2005, 2);
+      }
+
+      const name = s.rt.traitsOf(other).name;
+      // A Bitmap tests as its BitmapData.
+      const data: AsObject | null =
+        other.$store !== undefined
+          ? other
+          : other.$display?.store !== undefined
+            ? (other.$bitmapData ?? null)
+            : null;
+      const isPoint = name === "flash.geom::Point";
+      const isRect = name === "flash.geom::Rectangle";
+      if (isPoint || isRect) {
+        // A point truncated, a rect's edges rounded, as everywhere else.
+        const area = isRect ? rectOf(s, other) : null;
+        const [px, py] = isPoint ? pointOf(s, other, "secondObject") : [0, 0];
+        const x0 = (area ? area.x : px) - fx;
+        const y0 = (area ? area.y : py) - fy;
+        const w = area ? area.width : 1;
+        const h = area ? area.height : 1;
+        for (let y = Math.max(0, y0); y < Math.min(store.height, y0 + h); y++) {
+          for (let x = Math.max(0, x0); x < Math.min(store.width, x0 + w); x++) {
+            // A point or rect hits no pixel of alpha 0, at threshold 0 too (bitmapdata_hittest_threshold).
+            const a = alphaAt(store, x, y);
+            if (a > 0 && a >= a1) {
+              return true;
+            }
+          }
+        }
+
+        return false;
+      }
+
+      if (data) {
+        const second = storeOf(s, data);
+        // Against a bitmap, its point is required.
+        const [sx, sy] = pointOf(s, secondPoint, "secondBitmapDataPoint");
+        if (sx + second.width > 0x7fffffff || sy + second.height > 0x7fffffff) {
+          throw s.rt.error("ArgumentError", 1508, "secondBitmapDataPoint");
+        }
+
+        const a2 = secondAlpha === undefined ? 1 : s.rt.toUint(secondAlpha);
+        const ox = sx - fx;
+        const oy = sy - fy;
+        for (let y = Math.max(0, oy); y < Math.min(store.height, oy + second.height); y++) {
+          for (let x = Math.max(0, ox); x < Math.min(store.width, ox + second.width); x++) {
+            if (alphaAt(store, x, y) >= a1 && alphaAt(second, x - ox, y - oy) >= a2) {
+              return true;
+            }
+          }
+        }
+
+        return false;
+      }
+
+      throw s.rt.error("ArgumentError", 2005, 2);
+    }
+
+    pixelDissolve(
+      source: Value,
+      rect: Value,
+      dest: Value,
+      seed: Value,
+      count: Value,
+      fill: Value,
+    ): number {
+      const store = storeOf(s, this);
+      // Anything but a BitmapData is refused as null, as Flash words it.
+      if (source === null || source === undefined || (source as AsObject).$store === undefined) {
+        throw s.rt.error("TypeError", 2007, "sourceBitmapData");
+      }
+
+      const src = storeOf(s, source as AsObject);
+      if (rect === null || rect === undefined) {
+        throw s.rt.error("TypeError", 2007, "sourceRect");
+      }
+
+      const r = rectOf(s, rect, true);
+      const [dx, dy] = pointOf(s, dest, "destPoint");
+      const n = count === undefined ? 0 : s.rt.toInt(count);
+      if (n < 0) {
+        throw s.rt.error("RangeError", 2027, "numPixels", n);
+      }
+
+      return pixelDissolve(
+        store,
+        src,
+        r,
+        dx,
+        dy,
+        // An int, as declared: NaN is 0, where it would never reach a state.
+        seed === undefined ? 0 : s.rt.toInt(seed),
+        n,
+        fill === undefined ? 0 : s.rt.toUint(fill),
+      );
+    }
+
+    draw(
+      source: Value,
+      matrix: Value,
+      ct: Value,
+      mode: Value,
+      clip: Value,
+      smoothing: Value,
+    ): void {
+      drawInto(s, storeOf(s, this), source, matrix, ct, mode, clip, smoothing);
+    }
+
+    drawWithQuality(
+      source: Value,
+      matrix: Value,
+      ct: Value,
+      mode: Value,
+      clip: Value,
+      smoothing: Value,
+      quality: Value,
+    ): void {
+      drawInto(
+        s,
+        storeOf(s, this),
+        source,
+        matrix,
+        ct,
+        mode,
+        clip,
+        smoothing,
+        samplesOf(s, quality),
+      );
+    }
+
+    lock(): void {
+      storeOf(s, this);
+    }
+
+    unlock(): void {
+      storeOf(s, this);
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.display::BitmapData", BitmapDataNatives);
+  return natives;
+}
+
+export function bitmapDataHooks(s: Scripting): Record<string, avm2.ClassHook> {
+  return {
+    "flash.display::BitmapData": {
+      create: (traits) => {
+        const o = Object.create(traits.proto);
+        o.$store = null;
+        o.$symbol = s.symbols.bitmapSymbol(traits);
+        return o;
+      },
+    },
+  };
+}