@bubo-squared/gyroview 0.1.0

package/dist/packages/adapters/three/src/seamMeter/rowMeans.js

@@ -0,0 +1,38 @@
+var CHANNEL_MAX = 255;
+/**
+* Mean RGB (0..1) of the texels with non-zero alpha in each row of an RGBA8 image; undefined
+* when some row has none, because a lens that images no part of the seam gives nothing to match.
+*/
+function rowMeansOf(pixels, width, rowCount) {
+	const means = [];
+	for (let row = 0; row < rowCount; row += 1) {
+		const mean = rowMean(pixels.subarray(row * width * 4, (row + 1) * width * 4));
+		if (!mean) return void 0;
+		means.push(mean);
+	}
+	return means;
+}
+function rowMean(row) {
+	const sum = [
+		0,
+		0,
+		0
+	];
+	let count = 0;
+	for (let offset = 0; offset + 4 <= row.length; offset += 4) {
+		if ((row[offset + 4 - 1] ?? 0) === 0) continue;
+		sum[0] += row[offset] ?? 0;
+		sum[1] += row[offset + 1] ?? 0;
+		sum[2] += row[offset + 2] ?? 0;
+		count += 1;
+	}
+	if (count === 0) return void 0;
+	const scale = count * CHANNEL_MAX;
+	return [
+		sum[0] / scale,
+		sum[1] / scale,
+		sum[2] / scale
+	];
+}
+//#endregion
+export { rowMeansOf };

package/dist/packages/adapters/three/src/shaderPrograms.js

@@ -0,0 +1,66 @@
+import analysis_frag_default from "./shaders/analysis.frag.js";
+import equirectangularRays_default from "./shaders/equirectangularRays.js";
+import fixedJoin_default from "./shaders/fixedJoin.js";
+import header_default from "./shaders/header.js";
+import lensModels_default from "./shaders/lensModels.js";
+import lensSampling_default from "./shaders/lensSampling.js";
+import lensTextures_default from "./shaders/lensTextures.js";
+import rawLenses_frag_default from "./shaders/rawLenses.frag.js";
+import rectilinearRays_default from "./shaders/rectilinearRays.js";
+import screenAreas_default from "./shaders/screenAreas.js";
+import stitch_frag_default from "./shaders/stitch.frag.js";
+//#region ../../packages/adapters/three/src/shaderPrograms.ts
+/**
+* The fragment programs, each the GLSL chunks it is made of in the order they must appear: a
+* chunk comes after every chunk whose declarations it uses. The only place that order is known.
+*/
+var LENS_PROJECTION = [
+	lensTextures_default,
+	lensModels_default,
+	lensSampling_default
+];
+/**
+* A program that reads the lenses through their calibration, ending in `fragment`.
+*/
+function lensProjectionProgram(fragment) {
+	return [
+		header_default,
+		...LENS_PROJECTION,
+		fragment
+	];
+}
+/**
+* The picture programs with a seam join chunk: `fixedJoin.glsl` for the player, or one that
+* implements its three functions otherwise.
+*/
+function pictureProgramsWith(seamJoin) {
+	const stitchThrough = (rays) => [
+		header_default,
+		screenAreas_default,
+		rays,
+		...LENS_PROJECTION,
+		seamJoin,
+		stitch_frag_default
+	];
+	return {
+		rectilinear: stitchThrough(rectilinearRays_default),
+		equirectangular: stitchThrough(equirectangularRays_default),
+		"lens-tiles": [
+			header_default,
+			screenAreas_default,
+			lensTextures_default,
+			rawLenses_frag_default
+		]
+	};
+}
+var PICTURE_PROGRAMS = pictureProgramsWith(fixedJoin_default);
+var SEAM_ANALYSIS = lensProjectionProgram(analysis_frag_default);
+/**
+* Every chunk of the given programs once, for checking them against the TypeScript side.
+*/
+function chunksOf(programs) {
+	return [...new Set(programs.flat())];
+}
+chunksOf([...Object.values(PICTURE_PROGRAMS), SEAM_ANALYSIS]);
+//#endregion
+export { PICTURE_PROGRAMS, SEAM_ANALYSIS, chunksOf, lensProjectionProgram, pictureProgramsWith };

package/dist/packages/adapters/three/src/shaders/analysis.frag.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/analysis.frag.glsl?raw
+var analysis_frag_default = "in vec2 vNdc;\nout vec4 outColor;\n\n// One row per lens: what that lens sees along the seam ring, the circle of directions halfway\n// through the blend band around lens 0's optical axis, sampled around the ring along x. Rows\n// share their directions, so their means differ by exposure (and parallax), not by content.\n// Alpha marks the texels a lens actually images.\nvoid main() {\n  int lens = int(floor((vNdc.y + 1.0) * 0.5 * float(MAX_LENSES)));\n  float phi = (vNdc.x + 1.0) * PI;\n  float ring = 0.5 * (uFeather.x + uFeather.y);\n  vec3 inLensZero = vec3(sin(ring) * cos(phi), sin(ring) * sin(phi), cos(ring));\n  // The lens rotations take body directions into each lens; the transpose goes back.\n  vec3 dirBody = transpose(uLensRotation[0]) * inLensZero;\n  if (lens >= uLensCount) {\n    outColor = vec4(0.0);\n    return;\n  }\n  LensSample seen = sampleLensWith(lens, dirBody, SAMPLING_BILINEAR);\n  outColor = seen.isImaged ? vec4(seen.color, 1.0) : vec4(0.0);\n}\n";
+//#endregion
+export { analysis_frag_default as default };

package/dist/packages/adapters/three/src/shaders/equirectangularRays.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/equirectangularRays.glsl?raw
+var equirectangularRays_default = "// An equirectangular picture: a full turn across and a half turn from top to bottom.\n\n// Direction in view space (x right, y down, z forward) seen through a point of the picture, given\n// as fractions of the picture from its top-left corner.\nvec3 rayThroughPicture(vec2 point) {\n  vec2 centred = point * 2.0 - 1.0;\n  float yaw = centred.x * PI;\n  float pitch = -centred.y * HALF_PI;\n  return vec3(sin(yaw) * cos(pitch), -sin(pitch), cos(yaw) * cos(pitch));\n}\n";
+//#endregion
+export { equirectangularRays_default as default };

package/dist/packages/adapters/three/src/shaders/fixedJoin.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/fixedJoin.glsl?raw
+var fixedJoin_default = "// The fixed join: every lens read where the calibration's template reads it, for an infinitely\n// far scene, and blended across the whole feather band. The stitch the player draws; the lab's\n// bent join (ADR 0026) implements the same three functions.\nfloat disparityAt(vec3 dirBody) {\n  return 0.0;\n}\n\nvec3 seamReadDirection(int i, vec3 dirBody, float disparity) {\n  return dirBody;\n}\n\nvec2 seamFeather(float disparity) {\n  return uFeather;\n}\n";
+//#endregion
+export { fixedJoin_default as default };

package/dist/packages/adapters/three/src/shaders/fullscreen.vert.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/fullscreen.vert.glsl?raw
+var fullscreen_vert_default = "// One triangle covering the whole viewport; the fragment shader does all the work.\nin vec3 position;\nout vec2 vNdc;\n\nvoid main() {\n  vNdc = position.xy;\n  gl_Position = vec4(position.xy, 0.0, 1.0);\n}\n";
+//#endregion
+export { fullscreen_vert_default as default };

package/dist/packages/adapters/three/src/shaders/header.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/header.glsl?raw
+var header_default = "// GLSL ES 3.0 needs the default precisions before any float or int is mentioned.\nprecision highp float;\nprecision highp int;\n\nconst float PI = 3.14159265358979;\nconst float HALF_PI = 0.5 * PI;\nconst float TWO_PI = 2.0 * PI;\n";
+//#endregion
+export { header_default as default };

package/dist/packages/adapters/three/src/shaders/lensModels.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/lensModels.glsl?raw
+var lensModels_default = "// The depth is positive for every direction inside a lens's field; directions behind it are\n// projected too, for the footprint's derivatives, and must not divide by zero.\nconst float MIN_DEPTH = 1e-3;\n\n// Canvas pixel of a unit direction in the lens frame under the unified (Mei) model: project onto\n// the unit sphere, then from xi behind its centre onto the image plane, distort, scale.\nvec2 projectMei(vec3 d, float xi, vec2 focal, vec2 principalPoint, vec3 radial, vec2 tangential) {\n  float depth = max(d.z + xi, MIN_DEPTH);\n  vec2 m = d.xy / depth;\n  float r2 = dot(m, m);\n  float radialFactor = 1.0 + radial.x * r2 + radial.y * r2 * r2 + radial.z * r2 * r2 * r2;\n  vec2 tangentialTerm = vec2(\n    2.0 * tangential.x * m.x * m.y + tangential.y * (r2 + 2.0 * m.x * m.x),\n    tangential.x * (r2 + 2.0 * m.y * m.y) + 2.0 * tangential.y * m.x * m.y\n  );\n  return focal * (radialFactor * m + tangentialTerm) + principalPoint;\n}\n\n// Canvas pixel of a unit direction under a radial polynomial in the angle from the optical axis.\nvec2 projectRadialPolynomial(vec3 d, float theta, vec4 c, vec2 principalPoint) {\n  float radius = theta * (c.x + theta * (c.y + theta * (c.z + theta * c.w)));\n  float lateral = length(d.xy);\n  vec2 unit = lateral > 0.0 ? d.xy / lateral : vec2(0.0);\n  return principalPoint + radius * unit;\n}\n";
+//#endregion
+export { lensModels_default as default };

package/dist/packages/adapters/three/src/shaders/lensSampling.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/lensSampling.glsl?raw
+var lensSampling_default = "// How a body direction becomes a texel of one lens, for the stitch and the seam meters: the\n// calibration as uniforms, and the sampling through each lens model. Needs lensTextures.glsl.\nuniform vec2 uFeather;\nuniform mat3 uLensRotation[MAX_LENSES];\nuniform int uLensKind[MAX_LENSES];\nuniform vec2 uLensPrincipalPoint[MAX_LENSES];\nuniform vec2 uLensFocal[MAX_LENSES];\nuniform float uLensXi[MAX_LENSES];\nuniform vec3 uLensRadial[MAX_LENSES];\nuniform vec2 uLensTangential[MAX_LENSES];\nuniform vec4 uLensPolynomial[MAX_LENSES];\nuniform float uLensHalfFov[MAX_LENSES];\nuniform vec4 uLensWindow[MAX_LENSES];\n\nstruct LensSample {\n  bool isImaged;\n  // Angle from the lens's optical axis.\n  float theta;\n  vec3 color;\n};\n\n// Where lens i images direction d on its calibration canvas; the principal point, and not\n// known, for a kind of lens this shader does not know.\nvec2 canvasPixel(int i, vec3 d, float theta, out bool isKnown) {\n  isKnown = true;\n  if (uLensKind[i] == LENS_MEI) {\n    return projectMei(\n      d,\n      uLensXi[i],\n      uLensFocal[i],\n      uLensPrincipalPoint[i],\n      uLensRadial[i],\n      uLensTangential[i]\n    );\n  }\n  if (uLensKind[i] == LENS_RADIAL_POLYNOMIAL) {\n    return projectRadialPolynomial(d, theta, uLensPolynomial[i], uLensPrincipalPoint[i]);\n  }\n  isKnown = false;\n  return uLensPrincipalPoint[i];\n}\n\n// What lens i shows in a body direction, read as `sampling` says, if it images it at all:\n// outside its field, or beyond the window the frame shows, nothing. The footprint is taken in\n// every fragment before the gates, so its derivatives are defined.\nLensSample sampleLensWith(int i, vec3 dirBody, int sampling) {\n  vec3 d = uLensRotation[i] * dirBody;\n  // atan keeps its precision near the axis where acos loses it.\n  float theta = atan(length(d.xy), d.z);\n  bool isKnown;\n  vec2 pixel = canvasPixel(i, d, theta, isKnown);\n  vec2 windowUv = (pixel - uLensWindow[i].xy) / uLensWindow[i].zw;\n  Footprint footprint = footprintOf(i, windowUv);\n  bool isInWindow =\n    all(greaterThanEqual(windowUv, vec2(0.0))) && all(lessThanEqual(windowUv, vec2(1.0)));\n  LensSample result;\n  result.theta = theta;\n  result.isImaged = isKnown && theta < uLensHalfFov[i] && isInWindow;\n  result.color = result.isImaged ? sampleLens(uLensTexture[i], footprint, sampling).rgb : vec3(0.0);\n  return result;\n}\n\n// What lens i shows in a body direction, read as the picture is.\nLensSample sampleLensAt(int i, vec3 dirBody) {\n  return sampleLensWith(i, dirBody, uSampling);\n}\n";
+//#endregion
+export { lensSampling_default as default };

package/dist/packages/adapters/three/src/shaders/lensTextures.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/lensTextures.glsl?raw
+var lensTextures_default = "// Where each lens's image is: the decoded frames as textures, each lens's region of its frame,\n// and how a screen pixel reads them. Every program that reads a lens needs these.\nuniform int uLensCount;\nuniform vec4 uLensRegion[MAX_LENSES];\nuniform int uLensTexture[MAX_LENSES];\nuniform sampler2D uTexture0;\nuniform sampler2D uTexture1;\nuniform int uSampling;\n\n// The patch of a lens image one screen pixel covers: where it is read, and how far the next\n// pixel to the right and the next one down move the read, from the screen derivatives.\nstruct Footprint {\n  vec2 uv;\n  vec2 dx;\n  vec2 dy;\n};\n\nvec2 texelSizeOf(int textureIndex) {\n  return 1.0 / vec2(textureIndex == 0 ? textureSize(uTexture0, 0) : textureSize(uTexture1, 0));\n}\n\n// One bilinear tap of the base level, whatever the texture's filters: the seam meters read the\n// frames this way, where the pixel footprint means nothing.\nvec4 fetchBase(int textureIndex, vec2 uv) {\n  return textureIndex == 0\n    ? textureLod(uTexture0, uv, 0.0)\n    : textureLod(uTexture1, uv, 0.0);\n}\n\n// One tap through the mip chain over a footprint.\nvec4 fetchFootprint(int textureIndex, vec2 uv, vec2 dx, vec2 dy) {\n  return textureIndex == 0\n    ? textureGrad(uTexture0, uv, dx, dy)\n    : textureGrad(uTexture1, uv, dx, dy);\n}\n\n// Where a fraction of a lens's region is read. The derivatives are taken here, in every\n// fragment alike, before anything decides whether the pixel shows the lens at all; then the read\n// point is kept half a texel inside the region, so a neighbouring region never bleeds in.\nFootprint footprintOf(int i, vec2 regionUv) {\n  vec2 uv = uLensRegion[i].xy + regionUv * uLensRegion[i].zw;\n  Footprint footprint;\n  footprint.dx = dFdx(uv);\n  footprint.dy = dFdy(uv);\n  vec2 inset = 0.5 * texelSizeOf(uLensTexture[i]);\n  vec2 low = uLensRegion[i].xy + inset;\n  vec2 high = uLensRegion[i].xy + uLensRegion[i].zw - inset;\n  footprint.uv = clamp(uv, low, high);\n  return footprint;\n}\n\n// Four taps on a rotated grid within the footprint, each over a quarter of it (Akenine-Möller\n// et al., Real-Time Rendering, 4th ed., section 5.4.1).\nconst vec2 GRID_OFFSETS[4] = vec2[4](\n  vec2(-0.375, 0.125),\n  vec2(0.125, 0.375),\n  vec2(0.375, -0.125),\n  vec2(-0.125, -0.375)\n);\n\nvec4 fetchSupersampled(int textureIndex, Footprint footprint) {\n  vec4 sum = vec4(0.0);\n  for (int tap = 0; tap < 4; tap++) {\n    vec2 uv =\n      footprint.uv + GRID_OFFSETS[tap].x * footprint.dx + GRID_OFFSETS[tap].y * footprint.dy;\n    sum += fetchFootprint(textureIndex, uv, 0.5 * footprint.dx, 0.5 * footprint.dy);\n  }\n  return 0.25 * sum;\n}\n\nvec4 sampleLens(int textureIndex, Footprint footprint, int sampling) {\n  if (sampling == SAMPLING_TRILINEAR) {\n    return fetchFootprint(textureIndex, footprint.uv, footprint.dx, footprint.dy);\n  }\n  if (sampling == SAMPLING_SUPERSAMPLED) return fetchSupersampled(textureIndex, footprint);\n  return fetchBase(textureIndex, footprint.uv);\n}\n";
+//#endregion
+export { lensTextures_default as default };

package/dist/packages/adapters/three/src/shaders/rawLenses.frag.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/rawLenses.frag.glsl?raw
+var rawLenses_frag_default = "// The decoded lens images on their own, unstitched: each lens's region of its frame exactly as\n// the decoder delivered it, in the lens's screen area, with no pose, stabilization or gain. Black\n// around the areas. Every pixel takes each tile's footprint before the area decides, so the\n// derivatives are defined.\nin vec2 vNdc;\nout vec4 outColor;\n\nvoid main() {\n  vec3 color = vec3(0.0);\n  for (int i = 0; i < MAX_LENSES; i++) {\n    if (i >= uLensCount) break;\n    vec2 point = pointInArea(vNdc, uScreenArea[i]);\n    Footprint footprint = footprintOf(i, point);\n    if (isInArea(point)) color = sampleLens(uLensTexture[i], footprint, uSampling).rgb;\n  }\n  outColor = vec4(color, 1.0);\n}\n";
+//#endregion
+export { rawLenses_frag_default as default };

package/dist/packages/adapters/three/src/shaders/rectilinearRays.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/rectilinearRays.glsl?raw
+var rectilinearRays_default = "// A rectilinear picture: the image plane scaled so that the horizontal field of view means what\n// the picture says.\nuniform float uPlaneHalfExtent;\nuniform float uPictureAspect;\n\n// Direction in view space (x right, y down, z forward) seen through a point of the picture, given\n// as fractions of the picture from its top-left corner.\nvec3 rayThroughPicture(vec2 point) {\n  vec2 centred = point * 2.0 - 1.0;\n  vec2 plane = vec2(centred.x * uPlaneHalfExtent, centred.y * uPlaneHalfExtent / uPictureAspect);\n  return normalize(vec3(plane, 1.0));\n}\n";
+//#endregion
+export { rectilinearRays_default as default };

package/dist/packages/adapters/three/src/shaders/screenAreas.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/screenAreas.glsl?raw
+var screenAreas_default = "// Where on the viewport the picture goes: per area, x, y, width and height as fractions of the\n// viewport from its top-left corner.\nuniform vec4 uScreenArea[MAX_LENSES];\n\n// Where a pixel lies within an area, as fractions of the area from its top-left corner: outside\n// 0 to 1 when the pixel lies outside the area. Normalised device y points up, screen y down.\nvec2 pointInArea(vec2 ndc, vec4 area) {\n  vec2 screen = vec2(ndc.x + 1.0, 1.0 - ndc.y) * 0.5;\n  return (screen - area.xy) / area.zw;\n}\n\nbool isInArea(vec2 point) {\n  return all(greaterThanEqual(point, vec2(0.0))) && all(lessThanEqual(point, vec2(1.0)));\n}\n";
+//#endregion
+export { screenAreas_default as default };

package/dist/packages/adapters/three/src/shaders/stitch.frag.js

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/stitch.frag.glsl?raw
+var stitch_frag_default = "// The stitched sphere through the picture's rays: each lens's texel for the ray, read and weighted\n// across the feather band as the seam join says, and matched in exposure. Every pixel samples, even outside the picture's area,\n// so the footprints' derivatives are defined; the area decides what shows.\nuniform mat3 uViewRotation;\nuniform mat3 uStabilization;\nuniform vec3 uLensGain[MAX_LENSES];\n\nin vec2 vNdc;\nout vec4 outColor;\n\nvoid main() {\n  vec2 point = pointInArea(vNdc, uScreenArea[0]);\n  vec3 dirView = rayThroughPicture(point);\n  vec3 dirBody = uStabilization * (uViewRotation * dirView);\n  vec3 sum = vec3(0.0);\n  float weightSum = 0.0;\n  float disparity = disparityAt(dirBody);\n  vec2 feather = seamFeather(disparity);\n  for (int i = 0; i < MAX_LENSES; i++) {\n    if (i >= uLensCount) break;\n    // A lens silenced through its gain (ADR 0012) leaves the blend altogether, so the other\n    // lens fills the feather band alone and a lens-only render shows that lens as it is.\n    if (all(equal(uLensGain[i], vec3(0.0)))) continue;\n    LensSample lens = sampleLensAt(i, seamReadDirection(i, dirBody, disparity));\n    if (!lens.isImaged) continue;\n    // Weighed by the angle from the lens's axis where it is read, which a seam join may move.\n    float weight = 1.0 - smoothstep(feather.x, feather.y, lens.theta);\n    sum += weight * uLensGain[i] * lens.color;\n    weightSum += weight;\n  }\n  bool isShown = isInArea(point) && weightSum > 0.0;\n  outColor = isShown ? vec4(sum / weightSum, 1.0) : vec4(0.0, 0.0, 0.0, 1.0);\n}\n";
+//#endregion
+export { stitch_frag_default as default };

package/dist/packages/adapters/three/src/webglRenderer.js

@@ -0,0 +1,37 @@
+import { GyroViewError } from "../../../core/src/shared/errors/GyroViewError.js";
+import "../../../core/src/index.js";
+import { WebGLRenderer } from "three";
+//#region ../../packages/adapters/three/src/webglRenderer.ts
+/**
+* The WebGL 2 context a picture renderer draws on, wrapped by three, with every shader failure
+* made an error.
+*/
+function createRenderer(canvas, options) {
+	const context = canvas.getContext("webgl2", {
+		preserveDrawingBuffer: options.preserveDrawingBuffer ?? false,
+		antialias: false,
+		alpha: false,
+		depth: false,
+		stencil: false
+	});
+	if (!context) throw new GyroViewError("render-unavailable", "this browser has no WebGL2 context");
+	const renderer = new WebGLRenderer({
+		canvas,
+		context
+	});
+	renderer.setPixelRatio(1);
+	renderer.debug.onShaderError = (gl, program, ...shaders) => {
+		rejectProgram(gl, program, shaders);
+	};
+	return renderer;
+}
+/**
+* A shader that does not compile or link is a defect, not something to log and draw black over.
+* A compile failure's reason is in its shader's log, a link failure's in the program's.
+*/
+function rejectProgram(gl, program, shaders) {
+	const log = [gl.getProgramInfoLog(program), ...shaders.map((shader) => gl.getShaderInfoLog(shader))].filter(Boolean).join("\n");
+	throw new GyroViewError("render-unavailable", `a shader did not compile or link: ${log}`);
+}
+//#endregion
+export { createRenderer };

package/dist/packages/adapters/webcodecs/src/WebCodecsVideoDecoderPort.js

@@ -0,0 +1,135 @@
+import { GyroViewError, asGyroViewError, messageOf } from "../../../core/src/shared/errors/GyroViewError.js";
+import { microseconds, microsecondsToSeconds, secondsToMicroseconds } from "../../../core/src/shared/units/time.js";
+import "../../../core/src/index.js";
+//#region ../../packages/adapters/webcodecs/src/WebCodecsVideoDecoderPort.ts
+/**
+* A hard `prefer-hardware` refuses codecs the browser could decode in software (H.264 recordings
+* on machines without a hardware decoder); with no preference the browser still picks hardware
+* when it has it (ADR 0010).
+*/
+var HARDWARE_ACCELERATION = "no-preference";
+/**
+* VideoDecoderPort over the browser's WebCodecs `VideoDecoder`. Frames are exposed as
+* `DecodedFrame<VideoFrame>`; the renderer uploads the handle to the GPU and the pipeline closes
+* it afterwards.
+*/
+var WebCodecsVideoDecoderPort = class {
+	/**
+	* A configuration WebCodecs finds malformed is one it does not support.
+	*/
+	async isSupported(configuration) {
+		if (typeof VideoDecoder === "undefined") return false;
+		try {
+			return (await VideoDecoder.isConfigSupported(this.toWebCodecsConfig(configuration))).supported === true;
+		} catch {
+			return false;
+		}
+	}
+	create(configuration, callbacks) {
+		try {
+			return Promise.resolve(this.configureDecoder(configuration, callbacks));
+		} catch (error) {
+			return Promise.reject(asGyroViewError(error, "codec-unsupported", "the decoder rejected its configuration"));
+		}
+	}
+	configureDecoder(configuration, callbacks) {
+		if (typeof VideoDecoder === "undefined") throw new GyroViewError("codec-unsupported", "this browser has no WebCodecs VideoDecoder");
+		return new WebCodecsDecoderHandle(this.toWebCodecsConfig(configuration), callbacks);
+	}
+	toWebCodecsConfig(configuration) {
+		const { description, isFullRange } = configuration;
+		return {
+			codec: configuration.codec,
+			codedWidth: configuration.codedWidth,
+			codedHeight: configuration.codedHeight,
+			...description && { description },
+			...isFullRange !== void 0 && { colorSpace: { fullRange: isFullRange } },
+			hardwareAcceleration: HARDWARE_ACCELERATION,
+			optimizeForLatency: false
+		};
+	}
+};
+/**
+* One configured `VideoDecoder` for its whole life. The error it reported through its callback
+* is kept, so later calls fail with the real cause instead of a bare "closed" state.
+*/
+var WebCodecsDecoderHandle = class {
+	decoder;
+	failure;
+	constructor(config, callbacks) {
+		this.decoder = new VideoDecoder({
+			output: (frame) => {
+				callbacks.onFrame(wrapFrame(frame));
+			},
+			error: (error) => {
+				this.failure ??= new GyroViewError("decode", `video decoder failed: ${error.message}`, { cause: error });
+				callbacks.onError(this.failure);
+			}
+		});
+		try {
+			this.decoder.configure(config);
+		} catch (error) {
+			this.decoder.close();
+			throw error;
+		}
+	}
+	get pendingCount() {
+		return this.decoder.decodeQueueSize;
+	}
+	/**
+	* WebCodecs throws platform exceptions for a packet it refuses (a delta frame first, a closed
+	* decoder); they cross the port as `decode` failures, as the fake's do.
+	*/
+	decode(packet) {
+		if (this.failure) throw this.failure;
+		try {
+			this.decoder.decode(chunkOf(packet));
+		} catch (error) {
+			throw new GyroViewError("decode", `the decoder refused a packet: ${messageOf(error)}`, { cause: error });
+		}
+	}
+	/**
+	* Resolves on the decoder's `dequeue` events until fewer than `limit` packets are pending, or
+	* at once when the decoder is no longer configured.
+	*/
+	waitForPendingBelow(limit) {
+		return this.decoder.decodeQueueSize < limit ? Promise.resolve() : new Promise((resolve) => {
+			const check = () => {
+				if (this.decoder.decodeQueueSize >= limit && this.decoder.state === "configured") return;
+				this.decoder.removeEventListener("dequeue", check);
+				resolve();
+			};
+			this.decoder.addEventListener("dequeue", check);
+		});
+	}
+	async flush() {
+		if (this.decoder.state !== "configured") throw this.failure ?? new GyroViewError("decode", "flush on a closed decoder");
+		try {
+			await this.decoder.flush();
+		} catch (error) {
+			throw this.failure ?? new GyroViewError("decode", "the decoder could not be flushed", { cause: error });
+		}
+	}
+	close() {
+		if (this.decoder.state !== "closed") this.decoder.close();
+	}
+};
+function chunkOf(packet) {
+	return new EncodedVideoChunk({
+		type: packet.isKeyFrame ? "key" : "delta",
+		timestamp: secondsToMicroseconds(packet.timestamp),
+		duration: secondsToMicroseconds(packet.duration),
+		data: packet.data
+	});
+}
+function wrapFrame(frame) {
+	return {
+		timestamp: microsecondsToSeconds(microseconds(frame.timestamp)),
+		handle: frame,
+		close: () => {
+			frame.close();
+		}
+	};
+}
+//#endregion
+export { WebCodecsVideoDecoderPort };

package/dist/packages/adapters/webcodecs/src/index.js

@@ -0,0 +1,2 @@
+import { WebCodecsVideoDecoderPort } from "./WebCodecsVideoDecoderPort.js";
+export { WebCodecsVideoDecoderPort };

package/dist/packages/core/src/application/gainMatching/GainMatching.js

@@ -0,0 +1,66 @@
+import { GainMatcher } from "../../domain/optics/gainMatch.js";
+import { reportLater } from "../../shared/errors/reportLater.js";
+//#region ../../packages/core/src/application/gainMatching/GainMatching.ts
+/**
+* Media time between measurements: exposure drifts over seconds, and a read-back per frame
+* would stall the GPU pipeline.
+*/
+var MEASURE_INTERVAL_SECONDS = .5;
+/**
+* Keeps the lens gains matched over time: measures the seam after a presented frame every so
+* often, feeds the matcher and applies what it says. One measurement in flight at a time; one
+* that lands after `stop` changes nothing. A meter that fails stops the matching, the gains left
+* as they are, and the failure is reported once. The meter is borrowed: whoever created it
+* disposes it.
+*/
+var GainMatching = class {
+	meter;
+	applyGains;
+	reportFailure;
+	matcher = new GainMatcher();
+	lastMeasuredAt;
+	inFlight;
+	isStopped = false;
+	constructor(meter, applyGains, reportFailure = reportLater) {
+		this.meter = meter;
+		this.applyGains = applyGains;
+		this.reportFailure = reportFailure;
+	}
+	afterPresent(mediaTime) {
+		if ((this.lastMeasuredAt === void 0 || Math.abs(mediaTime - this.lastMeasuredAt) >= MEASURE_INTERVAL_SECONDS) && !this.isStopped) this.matchReporting(mediaTime);
+	}
+	/**
+	* Measures and applies at once; joins a measurement already under way.
+	*/
+	matchNow(mediaTime) {
+		this.inFlight ??= this.measureAt(mediaTime);
+		return this.inFlight;
+	}
+	stop() {
+		this.isStopped = true;
+	}
+	async matchReporting(mediaTime) {
+		try {
+			await this.matchNow(mediaTime);
+		} catch (error) {
+			this.reportFailure(error);
+		}
+	}
+	/**
+	* Counted from its start, so a failing meter is not asked again at every frame.
+	*/
+	async measureAt(mediaTime) {
+		this.lastMeasuredAt = mediaTime;
+		try {
+			const means = await this.meter.measure();
+			if (means && !this.isStopped) this.applyGains(this.matcher.update(means, mediaTime));
+		} catch (error) {
+			this.isStopped = true;
+			throw error;
+		} finally {
+			this.inFlight = void 0;
+		}
+	}
+};
+//#endregion
+export { GainMatching };

package/dist/packages/core/src/application/gainMatching/GainMatchingFrameSink.js

@@ -0,0 +1,62 @@
+import { GainMatching } from "./GainMatching.js";
+//#region ../../packages/core/src/application/gainMatching/GainMatchingFrameSink.ts
+var UNIT_GAIN = [
+	1,
+	1,
+	1
+];
+/**
+* Use case: while enabled, keeps the lenses' exposure matched along the seam of the pictures the
+* sink draws, measuring after presentations. Off until enabled; disabled, the lenses show their
+* exposure as recorded (ADR 0012).
+*/
+var GainMatchingFrameSink = class {
+	sink;
+	renderer;
+	active;
+	lastMediaTime;
+	constructor(sink, renderer) {
+		this.sink = sink;
+		this.renderer = renderer;
+	}
+	enable() {
+		if (this.active) return;
+		const { renderer } = this;
+		const meter = renderer.createSeamMeter();
+		const matching = new GainMatching(meter, (gains) => {
+			renderer.setLensGains(gains);
+		});
+		this.active = {
+			meter,
+			matching
+		};
+	}
+	disable() {
+		this.stop();
+		const unitGains = Array.from({ length: this.renderer.lensCount }, () => UNIT_GAIN);
+		this.renderer.setLensGains(unitGains);
+	}
+	/**
+	* One measurement and adjustment of the picture on screen right now, awaited: how tests
+	* observe matching without waiting for the next scheduled measurement.
+	*/
+	async matchNow() {
+		if (this.lastMediaTime === void 0) return;
+		await this.active?.matching.matchNow(this.lastMediaTime);
+	}
+	present(presentation) {
+		this.sink.present(presentation);
+		this.lastMediaTime = presentation.mediaTime;
+		this.active?.matching.afterPresent(presentation.mediaTime);
+	}
+	dispose() {
+		this.stop();
+	}
+	stop() {
+		this.active?.matching.stop();
+		this.active?.meter.dispose();
+		this.active = void 0;
+	}
+};
+//#endregion
+export { GainMatchingFrameSink };

package/dist/packages/core/src/application/playback/ClockWatch.js

@@ -0,0 +1,76 @@
+//#region ../../packages/core/src/application/playback/ClockWatch.ts
+/**
+* This much media time between two playing ticks means the ticks stopped while the clock ran on
+* (a hidden tab or an offscreen frame gets no animation frames). Ticks come with every animation
+* frame, a few hundredths of a second apart at the slowest.
+*/
+var MISSED_TICKS_SECONDS = 1;
+/**
+* A clock found this far from where it was last seen or put was moved from outside: the lock
+* screen's scrubber, a media key's play from the end. A running clock covers a few hundredths of
+* a second between two ticks.
+*/
+var OUTSIDE_MOVE_SECONDS = .25;
+/**
+* What a playback session's ticks notice about its clock between them: that the platform moved
+* it, or that ticks were missed while it ran on.
+*/
+var ClockWatch = class {
+	position;
+	previousPlayingTick;
+	/**
+	* The session put the clock here itself.
+	*/
+	placedAt(time) {
+		this.position = time;
+	}
+	/**
+	* The session stopped the running clock here: however far it ran on since the last tick, that
+	* was playback. A move back is still one from outside, for the next tick to notice.
+	*/
+	stoppedAt(time) {
+		if (this.position === void 0 || time >= this.position) this.position = time;
+	}
+	/**
+	* Playing starts from here: ticks that never come from now on are missed ticks too, as when
+	* playback starts in a hidden tab.
+	*/
+	playingFrom(time) {
+		this.previousPlayingTick = time;
+	}
+	/**
+	* Whether the clock is not where it was last seen or put: moved back while playing, or moved at
+	* all while standing still. Notes where it is now.
+	*/
+	wasMovedFromOutside({ now, state }) {
+		const known = this.position;
+		this.position = now;
+		if (known === void 0) return false;
+		return (state === "playing" ? known - now : Math.abs(now - known)) > OUTSIDE_MOVE_SECONDS;
+	}
+	/**
+	* Whether the clock ran on for a while since the last playing tick. Notes this tick.
+	*/
+	wereTicksMissed({ now, state }) {
+		const isPlaying = state === "playing";
+		const previous = this.previousPlayingTick;
+		this.previousPlayingTick = isPlaying ? now : void 0;
+		const gap = previous === void 0 ? 0 : now - previous;
+		return isPlaying && gap > MISSED_TICKS_SECONDS;
+	}
+};
+/**
+* The platform stopped the clock by itself (media keys, an audio interruption): not running, yet
+* not at the end of its media.
+*/
+function isStoppedFromOutside(clock) {
+	return !clock.isRunning && !clock.hasEnded;
+}
+/**
+* At the end of the recording: the clock's own media ran out, or it stands at the duration.
+*/
+function isAtEndOfMedia(clock, duration) {
+	return clock.hasEnded || clock.currentTime >= duration;
+}
+//#endregion
+export { ClockWatch, isAtEndOfMedia, isStoppedFromOutside };