@bubo-squared/gyroview 0.3.1 → 0.4.1

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
@@ -38,13 +39,14 @@ var WebCodecsVideoDecoderPort = class {
 		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
 		};

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/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,

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

@@ -1,45 +1,119 @@
-import { V3Token } from "../offsetTokens.js";
+import { MeiToken, V3Token, V6Token } from "../offsetTokens.js";
 import { canvasOfFirstBlock, eulerDegrees, versionWordMismatch } from "./CalibrationStringLayout.js";
 import { CalibrationVersion } from "../CalibrationVersion.js";
 import { MeiModel } from "../../../optics/MeiModel.js";
+import { RADIAL_AND_FIRST_PAIR } from "../v6TermReading.js";
 //#region ../../packages/core/src/domain/format/calibration/layouts/MeiCalibrationLayout.ts
 /**
-* `offset_v3`: `xi fx fy cx cy yaw pitch roll tx ty tz k1 k2 k3 p1 p2 width height type` per
-* lens, then a version word with 3 in its high 16 bits.
+* The layout of a Mei string version, a version word after its lens blocks.
 */
-var MEI_CALIBRATION_LAYOUT = {
+function meiLayout(format) {
+	return {
+		version: format.version,
+		lensTokens: format.lensTokens,
+		trailingTokens: 1,
+		radialScale: format.radialScale,
+		versionWordProblem: (versionWord) => versionWordMismatch(versionWord, format.version),
+		parseLens: (block, lensIndex) => meiLensOf(block, lensIndex, format),
+		canvasOf: (_numbers, blocks) => canvasOfFirstBlock(blocks, format.canvasTokens.width, format.canvasTokens.height)
+	};
+}
+function meiLensOf(block, lensIndex, format) {
+	return {
+		lensIndex,
+		model: new MeiModel({
+			xi: block(MeiToken.Xi),
+			focal: [block(MeiToken.FocalX), block(MeiToken.FocalY)],
+			principalPoint: {
+				x: block(MeiToken.CenterX),
+				y: block(MeiToken.CenterY)
+			},
+			distortion: format.distortionOf(block)
+		}),
+		orientation: eulerDegrees(block(MeiToken.Yaw), block(MeiToken.Pitch), block(MeiToken.Roll)),
+		translation: [
+			block(MeiToken.TranslationX),
+			block(MeiToken.TranslationY),
+			block(MeiToken.TranslationZ)
+		]
+	};
+}
+/**
+* `offset_v3`: the Mei tokens, then `k1 k2 k3 p1 p2 width height type` per lens, and a version
+* word with 3 in its high 16 bits. Drawn as read: the X5, the only camera seen to write it,
+* stitches through its legacy string (ADR 0023).
+*/
+var MEI_CALIBRATION_LAYOUT = meiLayout({
 	version: CalibrationVersion.Mei,
 	lensTokens: 19,
-	trailingTokens: 1,
-	versionWordProblem: (versionWord) => versionWordMismatch(versionWord, CalibrationVersion.Mei),
-	parseLens(block, lensIndex) {
-		return {
-			lensIndex,
-			model: new MeiModel({
-				xi: block(V3Token.Xi),
-				focal: [block(V3Token.FocalX), block(V3Token.FocalY)],
-				principalPoint: {
-					x: block(V3Token.CenterX),
-					y: block(V3Token.CenterY)
-				},
-				radial: [
-					block(V3Token.K1),
-					block(V3Token.K2),
-					block(V3Token.K3)
-				],
-				tangential: [block(V3Token.P1), block(V3Token.P2)]
-			}),
-			orientation: eulerDegrees(block(V3Token.Yaw), block(V3Token.Pitch), block(V3Token.Roll)),
-			translation: [
-				block(V3Token.TranslationX),
-				block(V3Token.TranslationY),
-				block(V3Token.TranslationZ)
-			]
-		};
+	canvasTokens: {
+		width: V3Token.CanvasWidth,
+		height: V3Token.CanvasHeight
 	},
-	canvasOf(_numbers, blocks) {
-		return canvasOfFirstBlock(blocks, V3Token.CanvasWidth, V3Token.CanvasHeight);
-	}
-};
+	distortionOf: (block) => ({
+		radial: [
+			block(V3Token.K1),
+			block(V3Token.K2),
+			block(V3Token.K3)
+		],
+		tangential: [{
+			p1: block(V3Token.P1),
+			p2: block(V3Token.P2)
+		}],
+		thinPrism: []
+	}),
+	radialScale: 1
+});
+/**
+* The radial scale a v6 reading is drawn at, measured on the X6, the one camera seen to stitch
+* through it: Insta360 Studio's far field and the seam's far bins agree on it to 0.3 percent
+* (ADR 0023). Provisional, from one unit; the X5's own v6 strings would want 1.02 to 1.04, but
+* the X5 stitches through its legacy string.
+*/
+var V6_RADIAL_SCALE = 1.008;
+/**
+* `offset_v6`: the Mei tokens, then `k1..k5 p1..p4 s1..s4 width height type` per lens, and a
+* version word with 6 in its high 16 bits; its distortion tokens read by `reading` (ADR 0032).
+*/
+function extendedMeiLayout(reading) {
+	return meiLayout({
+		version: CalibrationVersion.ExtendedMei,
+		lensTokens: 27,
+		canvasTokens: {
+			width: V6Token.CanvasWidth,
+			height: V6Token.CanvasHeight
+		},
+		distortionOf: (block) => reading(v6DistortionTokensOf(block)),
+		radialScale: V6_RADIAL_SCALE
+	});
+}
+/**
+* `offset_v6` as the player reads it: its radial terms and first tangential pair (ADR 0032,
+* provisional).
+*/
+var EXTENDED_MEI_CALIBRATION_LAYOUT = extendedMeiLayout(RADIAL_AND_FIRST_PAIR);
+function v6DistortionTokensOf(block) {
+	return {
+		radial: [
+			block(V6Token.K1),
+			block(V6Token.K2),
+			block(V6Token.K3),
+			block(V6Token.K4),
+			block(V6Token.K5)
+		],
+		tangential: [
+			block(V6Token.P1),
+			block(V6Token.P2),
+			block(V6Token.P3),
+			block(V6Token.P4)
+		],
+		thinPrism: [
+			block(V6Token.S1),
+			block(V6Token.S2),
+			block(V6Token.S3),
+			block(V6Token.S4)
+		]
+	};
+}
 //#endregion
-export { MEI_CALIBRATION_LAYOUT };
+export { EXTENDED_MEI_CALIBRATION_LAYOUT, MEI_CALIBRATION_LAYOUT, extendedMeiLayout, meiLayout };

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

@@ -11,6 +11,7 @@ var POLYNOMIAL_CALIBRATION_LAYOUT = {
 	version: CalibrationVersion.Polynomial,
 	lensTokens: 16,
 	trailingTokens: 1,
+	radialScale: 1,
 	versionWordProblem: (versionWord) => versionWordMismatch(versionWord, CalibrationVersion.Polynomial),
 	parseLens(block, lensIndex) {
 		return {

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

@@ -31,7 +31,10 @@ var V2Token = {
 	CanvasHeight: 14,
 	LensType: 15
 };
-var V3Token = {
+/**
+* The tokens every Mei string (v3, v6) starts its lens block with; each version's own follow.
+*/
+var MeiToken = {
 	Xi: 0,
 	FocalX: 1,
 	FocalY: 2,
@@ -42,7 +45,9 @@ var V3Token = {
 	Roll: 7,
 	TranslationX: 8,
 	TranslationY: 9,
-	TranslationZ: 10,
+	TranslationZ: 10
+};
+var V3Token = {
 	K1: 11,
 	K2: 12,
 	K3: 13,
@@ -53,8 +58,32 @@ var V3Token = {
 	LensType: 18
 };
 /**
+* `offset_v6` after the Mei tokens: five radial terms, four tangential and four thin-prism
+* tokens, then the canvas and the lens type. The order is insta360-rs's (`docs/INSV_FORMAT.md`),
+* confirmed on the X5, whose v6 and v3 strings agree on the Mei tokens, the canvas and the lens
+* type (ADR 0032).
+*/
+var V6Token = {
+	K1: 11,
+	K2: 12,
+	K3: 13,
+	K4: 14,
+	K5: 15,
+	P1: 16,
+	P2: 17,
+	P3: 18,
+	P4: 19,
+	S1: 20,
+	S2: 21,
+	S3: 22,
+	S4: 23,
+	CanvasWidth: 24,
+	CanvasHeight: 25,
+	LensType: 26
+};
+/**
 * Tokens after the lens blocks. v1 ends with canvas width, canvas height and a version word;
-* v2 and v3 end with the version word only.
+* v2, v3 and v6 end with the version word only.
 */
 var V1Trailing = {
 	CanvasWidth: 0,
@@ -62,4 +91,4 @@ var V1Trailing = {
 	VersionWord: 2
 };
 //#endregion
-export { V1Token, V1Trailing, V2Token, V3Token };
+export { MeiToken, V1Token, V1Trailing, V2Token, V3Token, V6Token };