gesso-core 0.1.0 → 0.2.0

package/dist/testing.d.ts

@@ -1,4 +1,4 @@
-import { $t as Canvas2DRenderer, Aa as ScrollSink, Bs as TextMeasurer, Da as PointerControllerOptions, Ea as UiKeyboardController, Ha as UiFocusManager, If as UiInputDispatcher, La as UiGestureRecognizer, Lm as UiNodeType, Mm as LayoutRecord, Na as UiWheelController, Nc as UiGraph, Oa as UiPointerController, Qi as UiPlatformAdapter, Sp as LayoutResult, Xi as PlatformEventTarget, Zi as PlatformSurface, as as Canvas2DContext, bp as Constraints, ca as UiTouchScroller, dn as CanvasSurface, hi as LayoutEngine, io as UiHitTester, jp as UiNode, ka as ScrollContainerState, os as Canvas2DGradient, sa as TouchScrollerOptions, un as CanvasHost, xp as LayoutBox } from "./index-DuZEAhyZ.js";
+import { $f as UiInputDispatcher, Cn as CanvasHost, Cs as Canvas2DGradient, Ga as UiPointerController, Jp as UiNode, Ka as ScrollContainerState, Lp as Constraints, Mi as LayoutEngine, Rp as LayoutBox, Ss as Canvas2DContext, Ta as UiTouchScroller, Ua as UiKeyboardController, Wa as PointerControllerOptions, Xa as UiWheelController, Xc as UiGraph, Ym as LayoutRecord, ao as UiFocusManager, eh as UiNodeType, eo as UiGestureRecognizer, fn as Canvas2DRenderer, ha as UiPlatformAdapter, ma as PlatformSurface, pa as PlatformEventTarget, qa as ScrollSink, rc as TextMeasurer, wa as TouchScrollerOptions, wn as CanvasSurface, xo as UiHitTester, zp as LayoutResult } from "./index-DAdauEn9.js";
 //#region src/layout/LayoutTestUtils.d.ts
 /**
  * Shared helpers for layout specs: builds UiNode trees through
@@ -228,5 +228,166 @@ declare class RenderHarness {
   box(node: UiNode): LayoutBox;
 }
 //#endregion
-export { FakeCanvasHost, FakeEventTarget, FakePlatformSurface, InputTestHarness, type RecordedCall, RecordingCanvasContext, RenderHarness, callArgs, callNames, callsOf, savedDepth };
+//#region src/media/Mp4TestUtils.d.ts
+/**
+ * A very small MP4 writer, and a decoder that decodes nothing.
+ *
+ * Both exist for the same reason the demuxer's spec gives for building
+ * its files by hand: a fixture `.mp4` is a better test of reality and
+ * a worse test of this code, because when it fails you do not know
+ * which of forty boxes was misread. Building the file means a spec can
+ * name the exact field it is about, and construct the awkward cases —
+ * a chunk holding several samples, composition offsets reordering
+ * them, a track with no `stss` — rather than hunting for a file that
+ * has one.
+ *
+ * In `gesso-core/testing` rather than beside a spec because two specs
+ * now want it: the demuxer's, which reads these files, and the
+ * resolver's, which plays them.
+ */
+/** `size type payload`, which is every box in the format. */
+declare function box(type: string, ...payload: number[][]): number[];
+/** A full box: a version and three flag bytes before the payload. */
+declare function fullBox(type: string, version: number, ...payload: number[][]): number[];
+/** An AAC audio track, for a file that has sound as well as pictures. */
+interface AudioTrackSpec {
+  timescale: number;
+  deltas: {
+    count: number;
+    delta: number;
+  }[];
+  sizes: number[];
+  chunkOffsets: number[];
+  chunkRuns: {
+    firstChunk: number;
+    samplesPerChunk: number;
+  }[];
+  channels: number;
+  sampleRate: number;
+  /**
+   * The `AudioSpecificConfig`, whose top five bits are the audio
+   * object type. The default is AAC-LC at 44.1kHz stereo, which is
+   * `mp4a.40.2` and what nearly every file on the web carries.
+   */
+  config?: number[];
+}
+interface TrackSpec {
+  timescale: number;
+  /** One `stts` run per entry. */
+  deltas: {
+    count: number;
+    delta: number;
+  }[];
+  compositionOffsets?: {
+    count: number;
+    offset: number;
+  }[];
+  sizes: number[];
+  chunkOffsets: number[];
+  chunkRuns: {
+    firstChunk: number;
+    samplesPerChunk: number;
+  }[];
+  /** Omitted means no `stss` at all, which means every sample is a sync sample. */
+  syncSamples?: number[];
+  width: number;
+  height: number;
+  handler?: string;
+  /** The sample entry's four character code. `avc1` unless said otherwise. */
+  codec?: 'avc1' | 'av01' | 'vp09';
+  /** The bytes of the configuration record after any fixed header; see `configurationBox`. */
+  configBytes?: number[];
+}
+declare function buildMp4(spec: TrackSpec, options?: {
+  fragmented?: boolean;
+  audio?: AudioTrackSpec;
+}): ArrayBuffer;
+/** One run of samples inside a fragment. */
+interface FragmentSpec {
+  /** Decode time the fragment starts at, in the track's timescale. Omitted means "carry on". */
+  baseMediaDecodeTime?: number;
+  samples: {
+    duration: number;
+    size: number;
+    isKey: boolean;
+  }[];
+}
+interface FragmentedSpec {
+  trackId: number;
+  timescale: number;
+  width: number;
+  height: number;
+  fragments: FragmentSpec[];
+  /** Written into `trex`, and used by any sample whose `trun` omits the field. */
+  defaultSampleDuration?: number;
+  defaultSampleSize?: number;
+  /** Leave a field out of the `trun` so the default has to supply it. */
+  omit?: {
+    duration?: boolean;
+    size?: boolean;
+  };
+}
+/**
+ * A fragmented MP4: a `moov` that describes the track and promises
+ * fragments, then the fragments.
+ *
+ * The `stbl` is a shell — `stsd` and four empty tables — which is what
+ * a fragmenter writes and is exactly the shape that used to make this
+ * demuxer return zero samples for a file the browser played.
+ */
+declare function buildFragmentedMp4(spec: FragmentedSpec): ArrayBuffer;
+/** The offset `mdat`'s payload lands at, for a table that must point into it. */
+declare function mdatStart(data: ArrayBuffer): number;
+/** One chunk as the fake decoder saw it. */
+interface DecodedChunk {
+  readonly timestamp: number;
+  readonly type: 'key' | 'delta';
+}
+/**
+ * A `VideoDecoder` that records what it was asked to decode and hands
+ * back a frame for each.
+ *
+ * What the resolver's spec is about is *which samples are submitted*:
+ * a seek that starts at the wrong keyframe, or one that decodes the
+ * whole clip to get somewhere, is a bug in arithmetic that has nothing
+ * to do with pixels. So this decodes nothing and the frames it emits
+ * carry a timestamp and a `close` and no image at all.
+ *
+ * Emission is synchronous, which a real decoder's never is. That makes
+ * the specs readable and is the one way this lies: the ordering
+ * hazards a real decoder creates — a frame arriving after the position
+ * has moved past it — are `Mp4Playback`'s to handle and are asserted
+ * by pushing frames in by hand rather than by waiting for a thread.
+ */
+declare class FakeVideoDecoder {
+  static readonly submitted: DecodedChunk[];
+  /** How many times a decoder was configured: a seek costs one. */
+  static configures: number;
+  static resets: number;
+  /** Set to stop frames being emitted, for a spec about a queue filling up. */
+  static emit: boolean;
+  static install(): () => void;
+  static reset(): void;
+  /** Every timestamp submitted since the last configure, in order. */
+  static get sinceConfigure(): number[];
+  static isConfigSupported(): Promise<{
+    supported: boolean;
+  }>;
+  state: 'unconfigured' | 'configured' | 'closed';
+  decodeQueueSize: number;
+  private readonly output;
+  constructor(init: {
+    output: (frame: {
+      timestamp: number;
+      close(): void;
+    }) => void;
+    error: (e: unknown) => void;
+  });
+  configure(): void;
+  decode(chunk: DecodedChunk): void;
+  reset(): void;
+  close(): void;
+}
+//#endregion
+export { type AudioTrackSpec, type DecodedChunk, FakeCanvasHost, FakeEventTarget, FakePlatformSurface, FakeVideoDecoder, type FragmentSpec, type FragmentedSpec, InputTestHarness, type RecordedCall, RecordingCanvasContext, RenderHarness, type TrackSpec, box, buildFragmentedMp4, buildMp4, callArgs, callNames, callsOf, fullBox, mdatStart, savedDepth };
 //# sourceMappingURL=testing.d.ts.map

package/dist/testing.js

@@ -1,4 +1,4 @@
-import { N as Constraints, X as UiPlatformAdapter, _t as UiInputDispatcher, b as LayoutEngine, cr as UiGraph, ct as UiFocusManager, it as UiWheelController, lt as UiHitTester, nt as UiGestureRecognizer, ot as UiKeyboardController, r as Canvas2DRenderer, st as UiPointerController, t as CanvasSurface, tt as UiTouchScroller, wt as CharacterCountTextMeasurer } from "./CanvasSurface-CrG-uJ5o.js";
+import { N as Constraints, X as UiPlatformAdapter, _t as UiInputDispatcher, b as LayoutEngine, cr as UiGraph, ct as UiFocusManager, it as UiWheelController, lt as UiHitTester, nt as UiGestureRecognizer, ot as UiKeyboardController, r as Canvas2DRenderer, st as UiPointerController, t as CanvasSurface, tt as UiTouchScroller, wt as CharacterCountTextMeasurer } from "./CanvasSurface-5dU-U3qQ.js";
 //#region src/layout/LayoutTestUtils.ts
 /**
 * Shared helpers for layout specs: builds UiNode trees through
@@ -555,6 +555,329 @@ var RenderHarness = class {
 	}
 };
 //#endregion
-export { FakeCanvasHost, FakeEventTarget, FakePlatformSurface, InputTestHarness, RecordingCanvasContext, RenderHarness, callArgs, callNames, callsOf, savedDepth };
+//#region src/media/Mp4TestUtils.ts
+/**
+* A very small MP4 writer, and a decoder that decodes nothing.
+*
+* Both exist for the same reason the demuxer's spec gives for building
+* its files by hand: a fixture `.mp4` is a better test of reality and
+* a worse test of this code, because when it fails you do not know
+* which of forty boxes was misread. Building the file means a spec can
+* name the exact field it is about, and construct the awkward cases —
+* a chunk holding several samples, composition offsets reordering
+* them, a track with no `stss` — rather than hunting for a file that
+* has one.
+*
+* In `gesso-core/testing` rather than beside a spec because two specs
+* now want it: the demuxer's, which reads these files, and the
+* resolver's, which plays them.
+*/
+function u32(value) {
+	return [
+		value >>> 24 & 255,
+		value >>> 16 & 255,
+		value >>> 8 & 255,
+		value & 255
+	];
+}
+function u16(value) {
+	return [value >>> 8 & 255, value & 255];
+}
+function ascii(text) {
+	return [...text].map((character) => character.charCodeAt(0));
+}
+/** `size type payload`, which is every box in the format. */
+function box(type, ...payload) {
+	const body = payload.flat();
+	return [
+		...u32(body.length + 8),
+		...ascii(type),
+		...body
+	];
+}
+/** A full box: a version and three flag bytes before the payload. */
+function fullBox(type, version, ...payload) {
+	return box(type, [
+		version,
+		0,
+		0,
+		0
+	], ...payload);
+}
+/**
+* The codec configuration box, which differs per codec and is where a
+* codec string comes from.
+*/
+function configurationBox(spec) {
+	if (spec.codec === "av01") return box("av1C", [129, ...spec.configBytes ?? [4, 0]]);
+	if (spec.codec === "vp09") return fullBox("vpcC", 1, spec.configBytes ?? [
+		0,
+		31,
+		128
+	]);
+	return box("avcC", [
+		1,
+		100,
+		0,
+		31,
+		255,
+		225
+	]);
+}
+function visualSampleEntry(spec) {
+	return box(spec.codec ?? "avc1", [
+		0,
+		0,
+		0,
+		0,
+		0,
+		0
+	], u16(1), Array.from({ length: 16 }, () => 0), u16(spec.width), u16(spec.height), u32(4718592), u32(4718592), u32(0), u16(1), Array.from({ length: 32 }, () => 0), u16(24), [255, 255], configurationBox(spec));
+}
+/** `esds`: the descriptor tree down to the two numbers a codec string needs. */
+function esds(spec) {
+	const config = spec.config ?? [18, 16];
+	const dsi = [
+		5,
+		config.length,
+		...config
+	];
+	const dcd = [
+		4,
+		13 + dsi.length,
+		64,
+		21,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		...dsi
+	];
+	return fullBox("esds", 0, [
+		3,
+		3 + dcd.length,
+		0,
+		1,
+		0,
+		...dcd
+	]);
+}
+function audioSampleEntry(spec) {
+	return box("mp4a", [
+		0,
+		0,
+		0,
+		0,
+		0,
+		0
+	], u16(1), u16(0), [
+		0,
+		0,
+		0,
+		0,
+		0,
+		0
+	], u16(spec.channels), u16(16), u16(0), u16(0), u16(spec.sampleRate), u16(0), esds(spec));
+}
+function audioSampleTable(spec) {
+	return box("stbl", fullBox("stsd", 0, u32(1), audioSampleEntry(spec)), fullBox("stts", 0, u32(spec.deltas.length), ...spec.deltas.map((run) => [...u32(run.count), ...u32(run.delta)])), fullBox("stsc", 0, u32(spec.chunkRuns.length), ...spec.chunkRuns.map((run) => [
+		...u32(run.firstChunk),
+		...u32(run.samplesPerChunk),
+		...u32(1)
+	])), fullBox("stsz", 0, u32(0), u32(spec.sizes.length), ...spec.sizes.map((size) => u32(size))), fullBox("stco", 0, u32(spec.chunkOffsets.length), ...spec.chunkOffsets.map((offset) => u32(offset))));
+}
+function audioTrak(spec) {
+	return box("trak", box("mdia", fullBox("mdhd", 0, u32(0), u32(0), u32(spec.timescale), u32(1e3)), fullBox("hdlr", 0, u32(0), ascii("soun"), Array.from({ length: 12 }, () => 0), [0]), box("minf", audioSampleTable(spec))));
+}
+function sampleTable(spec) {
+	const boxes = [
+		fullBox("stsd", 0, u32(1), visualSampleEntry(spec)),
+		fullBox("stts", 0, u32(spec.deltas.length), ...spec.deltas.map((run) => [...u32(run.count), ...u32(run.delta)])),
+		fullBox("stsc", 0, u32(spec.chunkRuns.length), ...spec.chunkRuns.map((run) => [
+			...u32(run.firstChunk),
+			...u32(run.samplesPerChunk),
+			...u32(1)
+		])),
+		fullBox("stsz", 0, u32(0), u32(spec.sizes.length), ...spec.sizes.map((size) => u32(size))),
+		fullBox("stco", 0, u32(spec.chunkOffsets.length), ...spec.chunkOffsets.map((offset) => u32(offset)))
+	];
+	if (spec.compositionOffsets !== void 0) boxes.splice(2, 0, fullBox("ctts", 0, u32(spec.compositionOffsets.length), ...spec.compositionOffsets.map((run) => [...u32(run.count), ...u32(run.offset)])));
+	if (spec.syncSamples !== void 0) boxes.push(fullBox("stss", 0, u32(spec.syncSamples.length), ...spec.syncSamples.map((number) => u32(number))));
+	return box("stbl", ...boxes);
+}
+function buildMp4(spec, options = {}) {
+	const trak = box("trak", box("mdia", fullBox("mdhd", 0, u32(0), u32(0), u32(spec.timescale), u32(1e3)), fullBox("hdlr", 0, u32(0), ascii(spec.handler ?? "vide"), Array.from({ length: 12 }, () => 0), [0]), box("minf", sampleTable(spec))));
+	const bytes = [
+		...box("ftyp", ascii("isom"), u32(512), ascii("isomiso2avc1mp41")),
+		...box("moov", fullBox("mvhd", 0, Array.from({ length: 100 }, () => 0)), trak, ...options.audio === void 0 ? [] : [audioTrak(options.audio)]),
+		...options.fragmented === true ? box("moof", box("mfhd", u32(1))) : [],
+		...box("mdat", Array.from({ length: 512 }, () => 65))
+	];
+	return new Uint8Array(bytes).buffer;
+}
+function tkhd(trackId) {
+	return fullBox("tkhd", 0, u32(0), u32(0), u32(trackId), Array.from({ length: 68 }, () => 0));
+}
+/**
+* A fragmented MP4: a `moov` that describes the track and promises
+* fragments, then the fragments.
+*
+* The `stbl` is a shell — `stsd` and four empty tables — which is what
+* a fragmenter writes and is exactly the shape that used to make this
+* demuxer return zero samples for a file the browser played.
+*/
+function buildFragmentedMp4(spec) {
+	const shellSpec = {
+		timescale: spec.timescale,
+		deltas: [],
+		sizes: [],
+		chunkOffsets: [],
+		chunkRuns: [],
+		width: spec.width,
+		height: spec.height
+	};
+	const trak = box("trak", tkhd(spec.trackId), box("mdia", fullBox("mdhd", 0, u32(0), u32(0), u32(spec.timescale), u32(1e3)), fullBox("hdlr", 0, u32(0), ascii("vide"), Array.from({ length: 12 }, () => 0), [0]), box("minf", sampleTable(shellSpec))));
+	const mvex = box("mvex", fullBox("trex", 0, u32(spec.trackId), u32(1), u32(spec.defaultSampleDuration ?? 0), u32(spec.defaultSampleSize ?? 0), u32(0)));
+	const moov = box("moov", fullBox("mvhd", 0, Array.from({ length: 100 }, () => 0)), trak, mvex);
+	const bytes = [...box("ftyp", ascii("isom"), u32(512), ascii("isomiso6avc1mp41")), ...moov];
+	for (const fragment of spec.fragments) {
+		const payloadSize = fragment.samples.reduce((total, sample) => total + sample.size, 0);
+		const build = (dataOffset) => {
+			const trunFlags = 1 | (spec.omit?.duration === true ? 0 : 256) | (spec.omit?.size === true ? 0 : 512) | 1024;
+			const entries = fragment.samples.flatMap((sample) => [
+				...spec.omit?.duration === true ? [] : u32(sample.duration),
+				...spec.omit?.size === true ? [] : u32(sample.size),
+				...u32(sample.isKey ? 0 : 65536)
+			]);
+			const trun = box("trun", [
+				0,
+				trunFlags >> 16 & 255,
+				trunFlags >> 8 & 255,
+				trunFlags & 255
+			], u32(fragment.samples.length), u32(dataOffset), entries);
+			const traf = box("traf", box("tfhd", [
+				0,
+				2,
+				0,
+				0
+			], u32(spec.trackId)), ...fragment.baseMediaDecodeTime === void 0 ? [] : [fullBox("tfdt", 0, u32(fragment.baseMediaDecodeTime))], trun);
+			return box("moof", fullBox("mfhd", 0, u32(1)), traf);
+		};
+		const moof = build(build(0).length + 8);
+		bytes.push(...moof, ...box("mdat", Array.from({ length: payloadSize }, () => 66)));
+	}
+	return new Uint8Array(bytes).buffer;
+}
+/** The offset `mdat`'s payload lands at, for a table that must point into it. */
+function mdatStart(data) {
+	const view = new DataView(data);
+	let at = 0;
+	while (at + 8 <= data.byteLength) {
+		const size = view.getUint32(at);
+		if (String.fromCharCode(view.getUint8(at + 4), view.getUint8(at + 5), view.getUint8(at + 6), view.getUint8(at + 7)) === "mdat") return at + 8;
+		at += size;
+	}
+	throw new Error("no mdat");
+}
+/**
+* A `VideoDecoder` that records what it was asked to decode and hands
+* back a frame for each.
+*
+* What the resolver's spec is about is *which samples are submitted*:
+* a seek that starts at the wrong keyframe, or one that decodes the
+* whole clip to get somewhere, is a bug in arithmetic that has nothing
+* to do with pixels. So this decodes nothing and the frames it emits
+* carry a timestamp and a `close` and no image at all.
+*
+* Emission is synchronous, which a real decoder's never is. That makes
+* the specs readable and is the one way this lies: the ordering
+* hazards a real decoder creates — a frame arriving after the position
+* has moved past it — are `Mp4Playback`'s to handle and are asserted
+* by pushing frames in by hand rather than by waiting for a thread.
+*/
+var FakeVideoDecoder = class FakeVideoDecoder {
+	static submitted = [];
+	/** How many times a decoder was configured: a seek costs one. */
+	static configures = 0;
+	static resets = 0;
+	/** Set to stop frames being emitted, for a spec about a queue filling up. */
+	static emit = true;
+	static install() {
+		const scope = globalThis;
+		const previous = {
+			VideoDecoder: scope.VideoDecoder,
+			EncodedVideoChunk: scope.EncodedVideoChunk,
+			VideoFrame: scope.VideoFrame,
+			createImageBitmap: scope.createImageBitmap
+		};
+		FakeVideoDecoder.reset();
+		scope.VideoDecoder = FakeVideoDecoder;
+		scope.EncodedVideoChunk = class {
+			timestamp;
+			type;
+			constructor(init) {
+				this.timestamp = init.timestamp;
+				this.type = init.type;
+			}
+		};
+		scope.VideoFrame = class {};
+		scope.createImageBitmap = void 0;
+		return () => Object.assign(scope, previous);
+	}
+	static reset() {
+		FakeVideoDecoder.submitted.length = 0;
+		FakeVideoDecoder.configures = 0;
+		FakeVideoDecoder.resets = 0;
+		FakeVideoDecoder.emit = true;
+	}
+	/** Every timestamp submitted since the last configure, in order. */
+	static get sinceConfigure() {
+		return FakeVideoDecoder.submitted.map((chunk) => chunk.timestamp);
+	}
+	static isConfigSupported() {
+		return Promise.resolve({ supported: true });
+	}
+	state = "unconfigured";
+	decodeQueueSize = 0;
+	output;
+	constructor(init) {
+		this.output = init.output;
+	}
+	configure() {
+		this.state = "configured";
+		FakeVideoDecoder.configures++;
+	}
+	decode(chunk) {
+		FakeVideoDecoder.submitted.push({
+			timestamp: chunk.timestamp,
+			type: chunk.type
+		});
+		if (!FakeVideoDecoder.emit) {
+			this.decodeQueueSize++;
+			return;
+		}
+		this.output({
+			timestamp: chunk.timestamp,
+			close: () => {}
+		});
+	}
+	reset() {
+		FakeVideoDecoder.resets++;
+		this.decodeQueueSize = 0;
+		this.state = "unconfigured";
+	}
+	close() {
+		this.state = "closed";
+	}
+};
+//#endregion
+export { FakeCanvasHost, FakeEventTarget, FakePlatformSurface, FakeVideoDecoder, InputTestHarness, RecordingCanvasContext, RenderHarness, box, buildFragmentedMp4, buildMp4, callArgs, callNames, callsOf, fullBox, mdatStart, savedDepth };
 
 //# sourceMappingURL=testing.js.map