@bubo-squared/gyroview 0.3.0 → 0.4.0

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

@@ -1,7 +1,10 @@
 import { ensureIndexInRange, ensureInvariant } from "../../../core/src/shared/errors/GyroViewError.js";
+import { MEI_TERM_CAPACITY } from "../../../core/src/domain/optics/MeiDistortion.js";
 import { IDENTITY_MATRIX3 } from "../../../core/src/shared/math/Matrix3.js";
 import { aspectOfArea, planeHalfExtentOf } from "../../../core/src/domain/view/rectilinear.js";
 import "../../../core/src/index.js";
+import { toThreeMatrix } from "./threeMatrix.js";
+import { CONVERSION_DEFINES, conversionUniforms } from "./conversionUniforms.js";
 import "./samplingStrategies.js";
 import { Matrix3, Vector2, Vector3, Vector4 } from "three";
 var LENS_MEI = 0;
@@ -14,6 +17,10 @@ var SHADER_DEFINES = Object.fromEntries([
 	["MAX_LENSES", 2],
 	["LENS_MEI", LENS_MEI],
 	["LENS_RADIAL_POLYNOMIAL", LENS_RADIAL_POLYNOMIAL],
+	["MEI_RADIAL_TERMS", MEI_TERM_CAPACITY.radial],
+	["MEI_TANGENTIAL_ORDERS", MEI_TERM_CAPACITY.tangential],
+	["MEI_THIN_PRISM_ORDERS", MEI_TERM_CAPACITY.thinPrism],
+	...CONVERSION_DEFINES,
 	["SAMPLING_BILINEAR", 0],
 	["SAMPLING_TRILINEAR", 1],
 	["SAMPLING_SUPERSAMPLED", 2]
@@ -24,6 +31,7 @@ function createRendererUniforms(setup, textures) {
 		...viewUniforms(setup),
 		...projectionUniforms(lenses),
 		...samplingUniforms(lenses),
+		...conversionUniforms(lenses),
 		uTexture0: { value: textures[0] ?? null },
 		uTexture1: { value: textures[1] ?? null }
 	};
@@ -47,12 +55,18 @@ function projectionUniforms(lenses) {
 		uLensPrincipalPoint: { value: lenses.map((lens) => toVector2(lens.projection.principalPoint)) },
 		uLensFocal: { value: slots.map((slot) => slot.focal) },
 		uLensXi: { value: slots.map((slot) => slot.xi) },
-		uLensRadial: { value: slots.map((slot) => slot.radial) },
-		uLensTangential: { value: slots.map((slot) => slot.tangential) },
+		uLensRadial: { value: slots.flatMap((slot) => slot.radial) },
+		uLensTangential: { value: slots.flatMap((slot) => slot.tangential) },
+		uLensThinPrism: { value: slots.flatMap((slot) => slot.thinPrism) },
 		uLensPolynomial: { value: slots.map((slot) => slot.polynomial) },
 		uLensHalfFov: { value: lenses.map((lens) => lens.halfFieldOfView) }
 	};
 }
+var NO_MEI_DISTORTION = {
+	radial: [],
+	tangential: [],
+	thinPrism: []
+};
 /**
 * Exhaustive over the projection kinds: a new kind does not compile until it is packed.
 */
@@ -62,20 +76,33 @@ function slotOf(projection) {
 			kind: LENS_MEI,
 			focal: new Vector2(...projection.focal),
 			xi: projection.xi,
-			radial: new Vector3(...projection.radial),
-			tangential: new Vector2(...projection.tangential),
+			...meiTermSlots(projection.distortion),
 			polynomial: new Vector4()
 		};
 		case "radial-polynomial": return {
 			kind: LENS_RADIAL_POLYNOMIAL,
 			focal: new Vector2(),
 			xi: 0,
-			radial: new Vector3(),
-			tangential: new Vector2(),
+			...meiTermSlots(NO_MEI_DISTORTION),
 			polynomial: new Vector4(...projection.coefficients)
 		};
 	}
 }
+function meiTermSlots(distortion) {
+	return {
+		radial: fittedToCapacity(distortion.radial, MEI_TERM_CAPACITY.radial, () => 0),
+		tangential: fittedToCapacity(distortion.tangential.map((pair) => new Vector2(pair.p1, pair.p2)), MEI_TERM_CAPACITY.tangential, () => new Vector2()),
+		thinPrism: fittedToCapacity(distortion.thinPrism.map((term) => new Vector2(term.x, term.y)), MEI_TERM_CAPACITY.thinPrism, () => new Vector2())
+	};
+}
+/**
+* The terms in the room the shader holds for their family, the rest of it zero; more terms than
+* it holds are a defect of the model that made them.
+*/
+function fittedToCapacity(terms, capacity, zero) {
+	ensureInvariant(terms.length <= capacity, `a Mei lens has ${terms.length} terms of a family the shader holds ${capacity} of`);
+	return Array.from({ length: capacity }, (_unused, index) => terms[index] ?? zero());
+}
 function samplingUniforms(lenses) {
 	return {
 		uLensWindow: { value: lenses.map((lens) => new Vector4(lens.window.x, lens.window.y, lens.window.width, lens.window.height)) },
@@ -136,12 +163,6 @@ function valuesOf(picture, viewportAspect) {
 function toVector4(area) {
 	return new Vector4(area.x, area.y, area.width, area.height);
 }
-/**
-* Row-major core matrix into a three matrix, whose `set` takes rows too.
-*/
-function toThreeMatrix(m) {
-	return new Matrix3().set(...m);
-}
 function toVector2(point) {
 	return new Vector2(point.x, point.y);
 }

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

@@ -1,4 +1,5 @@
 import analysis_frag_default from "./shaders/analysis.frag.js";
+import displayConversion_default from "./shaders/displayConversion.js";
 import equirectangularRays_default from "./shaders/equirectangularRays.js";
 import fixedJoin_default from "./shaders/fixedJoin.js";
 import header_default from "./shaders/header.js";
@@ -14,8 +15,9 @@ import stitch_frag_default from "./shaders/stitch.frag.js";
 * 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_TEXELS = [lensTextures_default, displayConversion_default];
 var LENS_PROJECTION = [
-	lensTextures_default,
+	...LENS_TEXELS,
 	lensModels_default,
 	lensSampling_default
 ];
@@ -48,7 +50,7 @@ function pictureProgramsWith(seamJoin) {
 		"lens-tiles": [
 			header_default,
 			screenAreas_default,
-			lensTextures_default,
+			...LENS_TEXELS,
 			rawLenses_frag_default
 		]
 	};

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

@@ -1,4 +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";
+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// exposure signals, in which it is a factor (ADR 0033). Alpha marks the texels a lens 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.signal, 1.0) : vec4(0.0);\n}\n";
 //#endregion
 export { analysis_frag_default as default };

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

@@ -0,0 +1,4 @@
+//#region ../../packages/adapters/three/src/shaders/displayConversion.glsl?raw
+var displayConversion_default = "// How lens i's texels are brought to the SDR BT.709 display, as the core's exposureSignalOf and\n// shownOf (ADR 0033): the browser's upload has applied the track's matrix and range; the\n// transfer and primaries are this chunk's. Shown as recorded, or HLG converted to scene light,\n// into BT.709 and toned; gain matching scales the exposure signal between the two (ADR 0012).\nuniform int uLensConversion[MAX_LENSES];\n// R′G′B′ through the matrix a frame names back to the track's own (matrixCorrectionOf).\nuniform mat3 uLensMatrixCorrection[MAX_LENSES];\nuniform mat3 uLensGamut[MAX_LENSES];\n// Exposure, roll-off start, roll-off ceiling, display encoding power.\nuniform vec4 uLensTone[MAX_LENSES];\n\nstruct ToneCurve {\n  float exposure;\n  float kneeStart;\n  float ceiling;\n  float exponent;\n};\n\nToneCurve toneOf(int i) {\n  vec4 tone = uLensTone[i];\n  return ToneCurve(tone.x, tone.y, tone.z, tone.w);\n}\n\nfloat hlgInverseOetf(float signal) {\n  return signal <= HLG_SEGMENT_JOIN\n    ? signal * signal / HLG_SQUARE_SEGMENT_DIVISOR\n    : (exp((signal - HLG_C) / HLG_A) + HLG_B) / HLG_LOG_SEGMENT_DIVISOR;\n}\n\nconst vec3 BT709_LUMINANCE = vec3(BT709_LUMINANCE_RED, BT709_LUMINANCE_GREEN, BT709_LUMINANCE_BLUE);\n\nfloat rolledOff(float luminance, ToneCurve tone) {\n  float over = luminance - tone.kneeStart;\n  return over <= 0.0\n    ? luminance\n    : tone.kneeStart + over / (1.0 + over / (tone.ceiling - tone.kneeStart));\n}\n\n// The signal exposed back to light, its luminance rolled off with every channel scaled alike,\n// and encoded for the display.\nvec3 tonedFrom(vec3 signal, ToneCurve tone) {\n  vec3 light = tone.exposure * pow(signal, vec3(tone.exponent));\n  float luminance = dot(light, BT709_LUMINANCE);\n  float scale = luminance > 0.0 ? rolledOff(luminance, tone) / luminance : 1.0;\n  return min(pow(light * scale, vec3(1.0 / tone.exponent)), vec3(1.0));\n}\n\nbool isHlg(int i) {\n  return uLensConversion[i] == CONVERSION_HLG_TO_SDR_BT709;\n}\n\n// Lens i's texel where its exposure is a factor; as recorded for any kind but HLG.\nvec3 exposureSignalOf(int i, vec3 texel) {\n  vec3 recorded = uLensMatrixCorrection[i] * texel;\n  if (!isHlg(i)) return recorded;\n  // A corrected texel may fall just below black, which the square segment would make light.\n  recorded = max(recorded, 0.0);\n  vec3 scene = vec3(\n    hlgInverseOetf(recorded.r),\n    hlgInverseOetf(recorded.g),\n    hlgInverseOetf(recorded.b)\n  );\n  vec3 light = max(uLensGamut[i] * scene, 0.0);\n  return pow(light, vec3(1.0 / toneOf(i).exponent));\n}\n\n// An exposure signal of lens i as the display shows it; as recorded for any kind but HLG.\nvec3 shownOf(int i, vec3 signal) {\n  if (!isHlg(i)) return signal;\n  return tonedFrom(signal, toneOf(i));\n}\n\nvec3 toDisplay(int i, vec3 texel) {\n  return shownOf(i, exposureSignalOf(i, texel));\n}\n";
+//#endregion
+export { displayConversion_default as default };

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

@@ -1,4 +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";
+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\nuniform vec2 uLensPrincipalPoint[MAX_LENSES];\nuniform vec2 uLensFocal[MAX_LENSES];\nuniform float uLensXi[MAX_LENSES];\n// Each Mei lens's distortion as the core's MeiDistortion holds it, lens after lens, as many terms\n// per lens as each family holds room for, by increasing order: radial terms k1, k2, ... of r²,\n// Brown's tangential pairs (p1, p2) scaled by r^(2j), and thin-prism shifts scaled by r^(2j + 2).\n// The orders a lens does not fill are zero.\nuniform float uLensRadial[MAX_LENSES * MEI_RADIAL_TERMS];\nuniform vec2 uLensTangential[MAX_LENSES * MEI_TANGENTIAL_ORDERS];\nuniform vec2 uLensThinPrism[MAX_LENSES * MEI_THIN_PRISM_ORDERS];\nuniform vec4 uLensPolynomial[MAX_LENSES];\n\n// c0 + c1 r² + c2 r⁴ + ... of each of lens i's families, by Horner's rule, as the core's seriesIn.\nfloat radialSeries(int i, float r2) {\n  float sum = 0.0;\n  for (int j = MEI_RADIAL_TERMS - 1; j >= 0; j--) {\n    sum = sum * r2 + uLensRadial[i * MEI_RADIAL_TERMS + j];\n  }\n  return sum;\n}\n\nvec2 tangentialSeries(int i, float r2) {\n  vec2 sum = vec2(0.0);\n  for (int j = MEI_TANGENTIAL_ORDERS - 1; j >= 0; j--) {\n    sum = sum * r2 + uLensTangential[i * MEI_TANGENTIAL_ORDERS + j];\n  }\n  return sum;\n}\n\nvec2 thinPrismSeries(int i, float r2) {\n  vec2 sum = vec2(0.0);\n  for (int j = MEI_THIN_PRISM_ORDERS - 1; j >= 0; j--) {\n    sum = sum * r2 + uLensThinPrism[i * MEI_THIN_PRISM_ORDERS + j];\n  }\n  return sum;\n}\n\n// A normalised image-plane point distorted by lens i, as the core's distortMei.\nvec2 distortMei(int i, vec2 m) {\n  float r2 = dot(m, m);\n  float radialFactor = 1.0 + r2 * radialSeries(i, r2);\n  vec2 decentering = tangentialSeries(i, r2);\n  vec2 tangentialTerm = vec2(\n    2.0 * decentering.x * m.x * m.y + decentering.y * (r2 + 2.0 * m.x * m.x),\n    decentering.x * (r2 + 2.0 * m.y * m.y) + 2.0 * decentering.y * m.x * m.y\n  );\n  return radialFactor * m + tangentialTerm + r2 * thinPrismSeries(i, r2);\n}\n\n// Canvas pixel of a unit direction in lens i's 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(int i, vec3 d) {\n  float depth = max(d.z + uLensXi[i], MIN_DEPTH);\n  return uLensFocal[i] * distortMei(i, d.xy / depth) + uLensPrincipalPoint[i];\n}\n\n// Canvas pixel of a unit direction under lens i's radial polynomial in the angle from its axis.\nvec2 projectRadialPolynomial(int i, vec3 d, float theta) {\n  vec4 c = uLensPolynomial[i];\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 uLensPrincipalPoint[i] + radius * unit;\n}\n";
 //#endregion
 export { lensModels_default as default };

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

@@ -1,4 +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";
+var lensSampling_default = "// How a body direction becomes a texel of one lens, for the stitch and the seam meters: the\n// pose and field as uniforms, and the sampling through each lens model, the texel as its\n// exposure signal. Needs lensTextures.glsl, displayConversion.glsl and lensModels.glsl.\nuniform vec2 uFeather;\nuniform mat3 uLensRotation[MAX_LENSES];\nuniform int uLensKind[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  // The texel where the lens's exposure is a factor (displayConversion.glsl).\n  vec3 signal;\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(i, d);\n  }\n  if (uLensKind[i] == LENS_RADIAL_POLYNOMIAL) {\n    return projectRadialPolynomial(i, d, theta);\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.signal = result.isImaged\n    ? exposureSignalOf(i, sampleLens(uLensTexture[i], footprint, sampling).rgb)\n    : 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/rawLenses.frag.js

@@ -1,4 +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 reads every tile, and the area picks one without a branch: a\n// read inside a branch that some pixels of a 2x2 quad skip took a far too coarse footprint on\n// Apple GPUs (Chrome through Metal), a grey line along a tile's edge wherever the edge fell\n// inside a quad.\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    vec3 sampled = sampleLens(uLensTexture[i], footprint, uSampling).rgb;\n    color = mix(color, sampled, float(isInArea(point)));\n  }\n  outColor = vec4(color, 1.0);\n}\n";
+var rawLenses_frag_default = "// The decoded lens images on their own, unstitched: each lens's region of its frame as the\n// decoder delivered it, brought to the display (ADR 0033), in the lens's screen area, with no\n// pose, stabilization or gain. Black around the areas. Every pixel reads every tile, and the area\n// picks one without a branch: a read inside a branch that some pixels of a 2x2 quad skip took a\n// far too coarse footprint on Apple GPUs (Chrome through Metal), a grey line along a tile's edge\n// wherever the edge fell inside a quad.\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    vec3 sampled = toDisplay(i, sampleLens(uLensTexture[i], footprint, uSampling).rgb);\n    color = mix(color, sampled, float(isInArea(point)));\n  }\n  outColor = vec4(color, 1.0);\n}\n";
 //#endregion
 export { rawLenses_frag_default as default };

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

@@ -1,4 +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";
+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,\n// even outside the picture's area, so the footprints' derivatives are defined; the area decides\n// 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    // Matched in exposure where exposure is a factor, then brought to the display (ADR 0033).\n    sum += weight * shownOf(i, uLensGain[i] * lens.signal);\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/threeMatrix.js

@@ -0,0 +1,10 @@
+import { Matrix3 } from "three";
+//#region ../../packages/adapters/three/src/threeMatrix.ts
+/**
+* Row-major core matrix into a three matrix, whose `set` takes rows too.
+*/
+function toThreeMatrix(m) {
+	return new Matrix3().set(...m);
+}
+//#endregion
+export { toThreeMatrix };

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

@@ -1,6 +1,7 @@
 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";
+import { colorSpaceOf } from "./colorSpaceOf.js";
 //#region ../../packages/adapters/webcodecs/src/WebCodecsVideoDecoderPort.ts
 /**
 * A hard `prefer-hardware` refuses codecs the browser could decode in software (H.264 recordings
@@ -15,10 +16,11 @@ var HARDWARE_ACCELERATION = "no-preference";
 */
 var WebCodecsVideoDecoderPort = class {
 	/**
-	* A configuration WebCodecs finds malformed is one it does not support.
+	* A configuration WebCodecs finds malformed is one it does not support. A browser without
+	* WebCodecs refuses to answer, since no configuration would do.
 	*/
 	async isSupported(configuration) {
-		if (typeof VideoDecoder === "undefined") return false;
+		if (typeof VideoDecoder === "undefined") throw webCodecsUnavailable();
 		try {
 			return (await VideoDecoder.isConfigSupported(this.toWebCodecsConfig(configuration))).supported === true;
 		} catch {
@@ -33,17 +35,18 @@ var WebCodecsVideoDecoderPort = class {
 		}
 	}
 	configureDecoder(configuration, callbacks) {
-		if (typeof VideoDecoder === "undefined") throw new GyroViewError("codec-unsupported", "this browser has no WebCodecs VideoDecoder");
+		if (typeof VideoDecoder === "undefined") throw webCodecsUnavailable();
 		return new WebCodecsDecoderHandle(this.toWebCodecsConfig(configuration), callbacks);
 	}
 	toWebCodecsConfig(configuration) {
-		const { description, isFullRange } = configuration;
+		const { description } = configuration;
+		const colorSpace = colorSpaceOf(configuration.colour);
 		return {
 			codec: configuration.codec,
 			codedWidth: configuration.codedWidth,
 			codedHeight: configuration.codedHeight,
 			...description && { description },
-			...isFullRange !== void 0 && { colorSpace: { fullRange: isFullRange } },
+			...colorSpace && { colorSpace },
 			hardwareAcceleration: HARDWARE_ACCELERATION,
 			optimizeForLatency: false
 		};
@@ -114,6 +117,14 @@ var WebCodecsDecoderHandle = class {
 		if (this.decoder.state !== "closed") this.decoder.close();
 	}
 };
+/**
+* Browsers expose WebCodecs only in secure contexts, so a page served over plain HTTP is the
+* likelier cause than an old browser, and the one its developer can fix.
+*/
+function webCodecsUnavailable() {
+	const reason = globalThis.isSecureContext ? "this browser has no WebCodecs VideoDecoder" : "WebCodecs exists only in secure contexts (HTTPS), and this page is not one";
+	return new GyroViewError("webcodecs-unavailable", reason);
+}
 function chunkOf(packet) {
 	return new EncodedVideoChunk({
 		type: packet.isKeyFrame ? "key" : "delta",

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

@@ -0,0 +1,32 @@
+//#region ../../packages/adapters/webcodecs/src/colorSpaceOf.ts
+/**
+* A track's colour as a decoder configuration's colour space: every value the track names, none
+* it leaves unspecified. WebCodecs gives the frames the configured colour space whole ("Output
+* VideoFrames"), so it says all the bitstream says, and the frames carry the colour the display
+* conversion was chosen for (ADR 0033). An engine whose WebCodecs does not know one of the values
+* would refuse the whole configuration, so it is told the range alone, as before. Undefined for a
+* track that names nothing.
+*/
+function colorSpaceOf(colour) {
+	const range = colour.range === "unspecified" ? void 0 : { fullRange: colour.range === "full" };
+	const named = {
+		...colour.primaries !== "unspecified" && { primaries: colour.primaries },
+		...colour.transfer !== "unspecified" && { transfer: colour.transfer },
+		...colour.matrix !== "unspecified" && { matrix: colour.matrix },
+		...range
+	};
+	return Object.keys(named).length === 0 ? void 0 : understoodHere(named) ?? range;
+}
+/**
+* The colour space as this engine reads it, undefined where it names a value the engine does not
+* know.
+*/
+function understoodHere(colorSpace) {
+	try {
+		return new VideoColorSpace(colorSpace).toJSON();
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { colorSpaceOf };

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

@@ -28,8 +28,8 @@ var KEY_FRAME_LATE = {
 * a deadline. The host resolves `deadline` once the probe has taken too long (the core has no
 * timers); sources still undecided then report `timed-out`, or `key-frame-late` while their key
 * frame was still being read, and their decoders are closed. A track that cannot be read rejects
-* the probe with its own failure, and the other sources' decoders are closed then, not at the
-* deadline.
+* the probe with its own failure, as a platform without decoders does, and the other sources'
+* decoders are closed then, not at the deadline.
 */
 async function probeDecoding(frameSources, decoderPort, deadline) {
 	const probes = frameSources.map((track) => new SourceProbe(track, decoderPort));

package/dist/packages/core/src/application/recording/frameTimesOf.js

@@ -13,7 +13,6 @@ async function frameTimesOf(recording, frameSource, timeline) {
 		...timeline,
 		frameCount,
 		frameRate: info.frameRate,
-		readoutTime: info.readoutTime,
 		exposureRecord
 	}, info.preferredFrameTimeSource);
 	return plan.needsTrackTimestamps ? plan.resolveWith(await frameSource.sampleTimestamps()) : plan.resolved;

package/dist/packages/core/src/domain/colour/DisplayConversion.js

@@ -0,0 +1,137 @@
+import { IDENTITY_MATRIX3 } from "../../shared/math/Matrix3.js";
+//#region ../../packages/core/src/domain/colour/DisplayConversion.ts
+/**
+* BT.2100 HLG's inverse OETF (ITU-R BT.2100-2, table 5): `E'² / 3` up to half signal, then
+* `(exp((E' - c) / a) + b) / 12`, with a, b (1 - 4a) and c; the shader's defines come from here.
+*/
+var HLG_OETF = {
+	a: .17883277,
+	b: .28466892,
+	c: .55991073,
+	segmentJoin: .5,
+	squareSegmentDivisor: 3,
+	logSegmentDivisor: 12
+};
+/**
+* Linear BT.2020 to linear BT.709 RGB (ITU-R BT.2087-0, equation 5), to seven decimals as the two
+* sets of primaries and their shared D65 white derive it, so each row sums to one and greys stay
+* grey.
+*/
+var BT2020_TO_BT709 = [
+	1.660491,
+	-.5876411,
+	-.0728499,
+	-.1245505,
+	1.1328999,
+	-.0083494,
+	-.0181508,
+	-.1005789,
+	1.1187297
+];
+/**
+* BT.709's luminance of linear red, green and blue (ITU-R BT.709-6, item 3.2): what the highlight
+* roll-off acts on, so a colour keeps its hue as it rolls off.
+*/
+var BT709_LUMINANCE = [
+	.2126,
+	.7152,
+	.0722
+];
+/**
+* Insta360 Studio's own HLG-to-SDR curve, fitted pixel by pixel to the X6's HLG and Rec.709
+* exports of the same stitch: scene light, no OOTF, brought up by two fifths, its luminance
+* rolled off above 0.2 and encoded with a power of 1/2.2 (ADR 0033).
+*/
+var STUDIO_TONE = {
+	exposure: 1.4,
+	kneeStart: .2,
+	ceiling: 1.5,
+	exponent: 2.2
+};
+/**
+* The primaries SDR is shown as recorded with: BT.709's, and the SD primaries close to them; a
+* track that names none is taken for BT.709.
+*/
+var BT709_LIKE_PRIMARIES = /* @__PURE__ */ new Set([
+	"bt709",
+	"bt470bg",
+	"smpte170m",
+	"unspecified"
+]);
+/**
+* The matrix that brings HLG's linear light into BT.709, by the track's primaries: none for
+* BT.709, BT.2087's for BT.2020, which BT.2100 means when a track names none. Undefined for
+* primaries HLG is not recorded with, whose gamut is left as it is.
+*/
+var HLG_GAMUT_BY_PRIMARIES = {
+	bt709: IDENTITY_MATRIX3,
+	bt2020: BT2020_TO_BT709,
+	unspecified: BT2020_TO_BT709,
+	bt470bg: void 0,
+	smpte170m: void 0,
+	smpte432: void 0
+};
+/**
+* A track's texels shown as recorded, its own matrix still corrected back to: what the player
+* draws of SDR, and the measurements of a recording drawn in its own signal.
+*/
+function asRecordedOf({ matrix }) {
+	return {
+		kind: "as-recorded",
+		matrix
+	};
+}
+function asRecordedFrom(colour) {
+	const conversion = asRecordedOf(colour);
+	return BT709_LIKE_PRIMARIES.has(colour.primaries) ? { conversion } : {
+		conversion,
+		problem: `${colour.primaries} primaries are shown as BT.709`
+	};
+}
+function hlgFrom(colour) {
+	const gamut = HLG_GAMUT_BY_PRIMARIES[colour.primaries];
+	const conversion = {
+		kind: "hlg-to-sdr-bt709",
+		matrix: colour.matrix,
+		gamut: gamut ?? IDENTITY_MATRIX3,
+		tone: STUDIO_TONE
+	};
+	return gamut === void 0 ? {
+		conversion,
+		problem: `HLG of ${colour.primaries} primaries is shown without their gamut`
+	} : { conversion };
+}
+function notShown(transfer) {
+	return (colour) => ({
+		conversion: asRecordedOf(colour),
+		problem: `the ${transfer} transfer cannot be shown yet: drawn as recorded`
+	});
+}
+/**
+* The conversion of every transfer, from the track's colour: a transfer the player learns to
+* name does not compile until it is given one.
+*/
+var CONVERSION_BY_TRANSFER = {
+	bt709: asRecordedFrom,
+	smpte170m: asRecordedFrom,
+	"iec61966-2-1": asRecordedFrom,
+	unspecified: asRecordedFrom,
+	hlg: hlgFrom,
+	pq: notShown("pq"),
+	linear: notShown("linear")
+};
+/**
+* Picks a conversion for each track's colour; a colour no conversion shows is drawn as recorded,
+* with a warning, rather than refused: the picture is there, its colours wrong. Tracks that share
+* a problem share its warning.
+*/
+function displayConversionsOf(colours) {
+	const choices = colours.map((colour) => CONVERSION_BY_TRANSFER[colour.transfer](colour));
+	const problems = choices.flatMap((choice) => choice.problem === void 0 ? [] : [choice.problem]);
+	return {
+		conversions: choices.map((choice) => choice.conversion),
+		warnings: [...new Set(problems)]
+	};
+}
+//#endregion
+export { BT709_LUMINANCE, HLG_OETF, asRecordedOf, displayConversionsOf };

package/dist/packages/core/src/domain/colour/TrackColour.js

@@ -0,0 +1,38 @@
+//#region ../../packages/core/src/domain/colour/TrackColour.ts
+/**
+* The values a video track's colour can name, as its bitstream says: the HEVC or AVC VUI, or the
+* sample entry's `colr` box. Spelled as WebCodecs spells `VideoColorSpaceInit`, so an adapter
+* passes values through; `unspecified` where the track says nothing, or something the player
+* does not know.
+*/
+var COLOUR_PRIMARIES = [
+	"bt709",
+	"bt470bg",
+	"smpte170m",
+	"bt2020",
+	"smpte432"
+];
+var TRANSFER_CHARACTERISTICS = [
+	"bt709",
+	"smpte170m",
+	"iec61966-2-1",
+	"linear",
+	"pq",
+	"hlg"
+];
+var MATRIX_COEFFICIENTS = [
+	"rgb",
+	"bt709",
+	"bt470bg",
+	"smpte170m",
+	"bt2020-ncl"
+];
+/**
+* A value as WebCodecs spells it, as the core names it: one of `names`, or unspecified for any
+* other value or none.
+*/
+function namedOrUnspecified(names, value) {
+	return names.find((name) => name === value) ?? "unspecified";
+}
+//#endregion
+export { COLOUR_PRIMARIES, MATRIX_COEFFICIENTS, TRANSFER_CHARACTERISTICS, namedOrUnspecified };

package/dist/packages/core/src/domain/colour/matrixCorrection.js

@@ -0,0 +1,76 @@
+import { IDENTITY_MATRIX3, multiplyMatrices } from "../../shared/math/Matrix3.js";
+//#region ../../packages/core/src/domain/colour/matrixCorrection.ts
+/**
+* The weights of each matrix (ITU-R BT.709-6 item 3.2, BT.2020-2 table 4, BT.601-7 item 2.5.1,
+* whose SD matrices BT.470BG and SMPTE 170M share); none for RGB or a matrix left unsaid.
+*/
+var LUMA_WEIGHTS = {
+	bt709: {
+		red: .2126,
+		blue: .0722
+	},
+	"bt2020-ncl": {
+		red: .2627,
+		blue: .0593
+	},
+	bt470bg: {
+		red: .299,
+		blue: .114
+	},
+	smpte170m: {
+		red: .299,
+		blue: .114
+	},
+	rgb: void 0,
+	unspecified: void 0
+};
+/**
+* The matrix that brings R′G′B′ a platform derived from Y′CbCr through `applied` to the R′G′B′
+* `recorded` gives: WebKit's decoders convert with BT.709 whatever a stream says (ADR 0033). No
+* correction when the two agree, or either is not known.
+*/
+function matrixCorrectionOf(recorded, applied) {
+	const to = LUMA_WEIGHTS[recorded];
+	const from = LUMA_WEIGHTS[applied];
+	return to === void 0 || from === void 0 || recorded === applied ? IDENTITY_MATRIX3 : multiplyMatrices(rgbFromYcbcr(to), ycbcrFromRgb(from));
+}
+/**
+* R′G′B′ of Y′, Pb and Pr.
+*/
+function rgbFromYcbcr({ red, blue }) {
+	const green = 1 - red - blue;
+	const redChroma = 2 * (1 - red);
+	const blueChroma = 2 * (1 - blue);
+	return [
+		1,
+		0,
+		redChroma,
+		1,
+		-blue * blueChroma / green,
+		-red * redChroma / green,
+		1,
+		blueChroma,
+		0
+	];
+}
+/**
+* Y′, Pb and Pr of R′G′B′.
+*/
+function ycbcrFromRgb({ red, blue }) {
+	const green = 1 - red - blue;
+	const blueChroma = 2 * (1 - blue);
+	const redChroma = 2 * (1 - red);
+	return [
+		red,
+		green,
+		blue,
+		-red / blueChroma,
+		-green / blueChroma,
+		(1 - blue) / blueChroma,
+		(1 - red) / redChroma,
+		-green / redChroma,
+		-blue / redChroma
+	];
+}
+//#endregion
+export { matrixCorrectionOf };

package/dist/packages/core/src/domain/format/calibration/CalibrationVersion.js

@@ -1,13 +1,16 @@
 //#region ../../packages/core/src/domain/format/calibration/CalibrationVersion.ts
 /**
-* Which calibration string a set was read from, in increasing order of fidelity: `offset` (1),
-* `offset_v2` (2) and `offset_v3` (3). The versioned strings declare theirs in the high bits of
-* their version word (the X5 recordings; insta360-rs docs); the legacy one declares none.
+* Which calibration string a set was read from: `offset` (1), `offset_v2` (2), `offset_v3` (3)
+* and `offset_v6` (6, the Mei model with more terms). The versioned strings declare theirs in the
+* high bits of their version word (the X5 recordings; insta360-rs docs); the legacy one declares
+* none. The number says nothing of which reading draws the lenses best: that is the calibration
+* preference's (ADR 0023).
 */
 var CalibrationVersion = {
 	Legacy: 1,
 	Polynomial: 2,
-	Mei: 3
+	Mei: 3,
+	ExtendedMei: 6
 };
 //#endregion
 export { CalibrationVersion };

package/dist/packages/core/src/domain/format/calibration/layouts/CalibrationStringLayout.js

@@ -8,7 +8,7 @@ function eulerDegrees(yaw, pitch, roll) {
 	};
 }
 /**
-* For the versioned strings (v2, v3): what is wrong with a version word that does not declare
+* For the versioned strings (v2, v3, v6): what is wrong with a version word that does not declare
 * `expected` in its high bits, if anything.
 */
 function versionWordMismatch(versionWord, expected) {

package/dist/packages/core/src/domain/format/calibration/layouts/LegacyCalibrationLayout.js

@@ -13,6 +13,7 @@ var LEGACY_CALIBRATION_LAYOUT = {
 	version: CalibrationVersion.Legacy,
 	lensTokens: 6,
 	trailingTokens: 3,
+	radialScale: 1,
 	parseLens(block, lensIndex) {
 		return {
 			lensIndex,