@bubo-squared/gyroview 0.4.2 → 0.5.0

package/CHANGELOG.md

@@ -3,6 +3,38 @@
 What changed for a page using the package, newest first. Until 1.0, a minor version may change
 the API.
 
+## 0.5.0 (2026-10-03)
+
+New:
+
+- Antigravity A1 recordings play. The A1 leaves the profile, tier and level of its HEVC
+  configuration blank, so the codec string is read from the stream's SPS instead (ADR 0037), and
+  its IMU frame is measured (ADR 0009): the `ready` event's `imuFrame` is
+  `{ name: 'A1', isVerified: true }`.
+
+What a page may notice:
+
+- An HEVC recording's codec in the `ready` event's `tracks[].codec` begins with the track's
+  sample entry type, `hvc1` on every camera seen, where it began with `hev1`; its profile, tier
+  and level are unchanged (ADR 0037).
+- `off` and `follow` stand a recording upright as its camera stood, where its IMU frame is
+  measured (ADR 0038). An X3, X4 Air, X5 or X6 held upright on a stick or a tripod, its usual
+  pose, holds its body frame a quarter turn from upright, and these modes drew its recordings
+  turned a quarter turn; a camera upside down or with its lens axis vertical stands upright too.
+  Under `horizon`, such a camera's view keeps its heading while the camera pitches.
+- An Insta360 X3 recording is stabilized about the right axes: its IMU frame is measured
+  (ADR 0009). The `ready` event's `imuFrame` is `{ name: 'X3', isVerified: true }` where it was
+  the unverified aligned frame, the load no longer warns that it has not been verified, and an
+  X3 on a stick or a tripod stands upright in `off` and `follow` too.
+- An Insta360 ONE RS recording stands upright under `lock` and `horizon`, which turned it on its
+  side. Its IMU frame is assumed from one recording of a camera that never turned: `imuFrame` is
+  `{ name: 'ONE RS (unverified)', isVerified: false }`, and the load still warns.
+- The view opens where Insta360 Studio centres the recording, in every mode: a half turn from
+  lens 0, where it opened, for a camera whose lens axis lies level, and a quarter turn from lens 0
+  for one whose lens axis is vertical, as the A1's (ADR 0038, ADR 0039). `yaw` 0 looks there: a
+  page that set `yaw` to face a direction faces the opposite one on a level camera until it adds
+  180 degrees. The equirectangular panorama is centred as Studio's export is.
+
 ## 0.4.2 (2026-10-02)
 
 What a page may notice:

package/README.md

@@ -1,9 +1,9 @@
 # @bubo-squared/gyroview
 
-Play raw Insta360 `.insv` recordings (X3, X4, X5, X6) in the browser. `<gyro-view>` reads the
-camera's dual-fisheye file directly, over HTTP byte ranges or from a local file, decodes both
-lenses in hardware with WebCodecs, and stitches and gyro-stabilizes them on the GPU. No Insta360
-Studio export step.
+Play raw `.insv` recordings of Insta360 cameras (X3, X4, X5, X6, ONE RS) and the Antigravity A1
+in the browser. `<gyro-view>` reads the camera's dual-fisheye file directly, over HTTP byte
+ranges or from a local file, decodes both lenses in hardware with WebCodecs, and stitches and
+gyro-stabilizes them on the GPU. No Insta360 Studio export step.
 
 **Try it first:** [insv-player.com](https://insv-player.com/) plays `.insv` files with this
 package. Drop your own recording to check that your camera and browser work before you install.
@@ -45,10 +45,10 @@ A page without a bundler loads the standalone file, which has Three.js and media
 ```html
 <script
   type="module"
-  src="https://cdn.jsdelivr.net/npm/@bubo-squared/gyroview@0.4/dist/standalone.js"
+  src="https://cdn.jsdelivr.net/npm/@bubo-squared/gyroview@0.5/dist/standalone.js"
 ></script>
 <script type="module">
-  import { inspectRecording } from 'https://cdn.jsdelivr.net/npm/@bubo-squared/gyroview@0.4/dist/standalone.js';
+  import { inspectRecording } from 'https://cdn.jsdelivr.net/npm/@bubo-squared/gyroview@0.5/dist/standalone.js';
 </script>
 ```
 

package/dist/packages/adapters/mediabunny/src/MediabunnyCodecReader.js

@@ -1,6 +1,6 @@
 import { GyroViewError, isAbortError } from "../../../core/src/shared/errors/GyroViewError.js";
 import "../../../core/src/index.js";
-import { audioConfigurationOf, videoConfigurationOf } from "./decoderConfigurations.js";
+import { audioConfigurationOf, codecStringOf, videoConfigurationOf } from "./decoderConfigurations.js";
 import { trackColourOf } from "./trackColour.js";
 import { BufferSource, Input, MP4, QTFF } from "mediabunny";
 //#region ../../packages/adapters/mediabunny/src/MediabunnyCodecReader.ts
@@ -46,7 +46,7 @@ async function videoCodecOf(track, trackIndex) {
 		trackIndex,
 		codedWidth,
 		codedHeight,
-		codec: config.codec,
+		codec: await codecStringOf(track, config),
 		colour: trackColourOf(config.colorSpace)
 	};
 	return {

package/dist/packages/adapters/mediabunny/src/decoderConfigurations.js

@@ -1,12 +1,28 @@
+import { hevcCodecStringOf } from "../../../core/src/domain/format/mp4/hevcCodecString.js";
+import "../../../core/src/index.js";
 import { copyOfBytes } from "./bufferSources.js";
 //#region ../../packages/adapters/mediabunny/src/decoderConfigurations.ts
 /**
-* A WebCodecs video decoder configuration in the core's terms; the coded size comes from the
-* track where the configuration leaves it out, the colour from the track's description.
+* The sample entry types an HEVC track's codec string begins with (ISO/IEC 14496-15 §8.4.1,
+* Annex E.3). An encrypted track's entry, `encv`, names its protection instead.
+*/
+var HEVC_SAMPLE_ENTRY_TYPES = /* @__PURE__ */ new Set(["hvc1", "hev1"]);
+/**
+* A video track's codec string: mediabunny's, but for an HEVC track, whose codec mediabunny
+* names from the configuration's header alone, the core's, which reads a blank header's SPS.
+*/
+async function codecStringOf(track, config) {
+	const [codec, sampleEntryType] = await Promise.all([track.getCodec(), track.getInternalCodecId()]);
+	return codec === "hevc" && typeof sampleEntryType === "string" && HEVC_SAMPLE_ENTRY_TYPES.has(sampleEntryType) && config.description !== void 0 ? hevcCodecStringOf(sampleEntryType, copyOfBytes(config.description)) : config.codec;
+}
+/**
+* A WebCodecs video decoder configuration in the core's terms; the codec string and the colour
+* come from the track's description, the coded size from the track where the configuration
+* leaves it out.
 */
 function videoConfigurationOf(config, description) {
 	return {
-		codec: config.codec,
+		codec: description.codec,
 		codedWidth: config.codedWidth ?? description.codedWidth,
 		codedHeight: config.codedHeight ?? description.codedHeight,
 		description: config.description === void 0 ? void 0 : copyOfBytes(config.description),
@@ -25,4 +41,4 @@ function audioConfigurationOf(config) {
 	};
 }
 //#endregion
-export { audioConfigurationOf, videoConfigurationOf };
+export { audioConfigurationOf, codecStringOf, videoConfigurationOf };

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

@@ -1,4 +1,5 @@
 import { imuFrameFor } from "../../domain/motion/imu/ImuFrame.js";
+import { mountingOf, uprightImuFrame } from "../../domain/motion/mounting/Mounting.js";
 import { OrientationTrack } from "../../domain/motion/orientation/OrientationTrack.js";
 //#region ../../packages/core/src/application/recording/motionOf.ts
 var NO_GYRO_WARNING = "the recording has no gyro record; stabilization is unavailable";
@@ -14,15 +15,18 @@ async function motionOf(recording, clock) {
 		warnings: [NO_GYRO_WARNING]
 	};
 	const imuFrame = imuFrameFor(recording.info);
+	const mounting = mountingOf(gyro.track, imuFrame);
+	const frame = uprightImuFrame(imuFrame, mounting);
 	const orientations = OrientationTrack.integrate({
 		gyro: gyro.track,
 		clock,
-		frame: imuFrame
+		frame
 	});
 	const warnings = [...unverifiedWarningsOf(imuFrame, recording), ...damageWarningsOf(gyro)];
 	return {
 		setup: {
 			orientations,
+			mounting,
 			imuFrame
 		},
 		warnings

package/dist/packages/core/src/application/stabilization/StabilizingFrameSink.js

@@ -1,3 +1,4 @@
+import { rotationIntoBody } from "../../domain/motion/mounting/Mounting.js";
 import { OffStabilization } from "../../domain/motion/stabilization/stabilizers.js";
 //#region ../../packages/core/src/application/stabilization/StabilizingFrameSink.ts
 /**
@@ -15,8 +16,9 @@ var StabilizingFrameSink = class {
 	}
 	present(presentation) {
 		const time = this.exposureTimeOf(presentation);
-		const orientation = this.parts.orientations.orientationAt(time);
-		this.parts.sink.setStabilization(this.stabilizer.nextRotation(orientation, time));
+		const { orientations, mounting } = this.parts.motion;
+		const rotation = this.stabilizer.nextRotation(orientations.orientationAt(time), time);
+		this.parts.sink.setStabilization(rotationIntoBody(mounting, rotation));
 		this.parts.sink.present(presentation);
 	}
 	/**

package/dist/packages/core/src/domain/format/mp4/hevcCodecString.js

@@ -0,0 +1,161 @@
+import { hasErrorCode } from "../../../shared/errors/GyroViewError.js";
+import { ByteReader } from "../../../shared/binary/ByteReader.js";
+//#region ../../packages/core/src/domain/format/mp4/hevcCodecString.ts
+/**
+* The general part of profile_tier_level (ITU-T H.265 §7.3.3), as an SPS carries it and an HEVC
+* configuration's header repeats it: two bits of profile space, the tier flag and five bits of
+* profile; 32 compatibility flags; 48 bits of constraint flags; the level.
+*/
+var PROFILE_SPACE_SHIFT = 6;
+var HIGH_TIER_FLAG = 32;
+var PROFILE_MASK = 31;
+var COMPATIBILITY_FLAGS_OFFSET = 1;
+var CONSTRAINT_FLAGS_OFFSET = 5;
+var CONSTRAINT_FLAGS_LENGTH = 6;
+var LEVEL_OFFSET = 11;
+var COMPATIBILITY_FLAG_COUNT = 32;
+/**
+* No profile has the number zero (ITU-T H.265 Annex A): a header naming it was left blank.
+*/
+var NO_PROFILE = 0;
+/**
+* An SPS (NAL unit type 33, ITU-T H.265 Table 7-1) opens with its two-byte NAL unit header and
+* a byte of parameter-set id, sub-layer count and nesting flag; its profile_tier_level follows
+* (§7.3.2.2.1).
+*/
+var SPS_NAL_UNIT_TYPE = 33;
+var SPS_PROFILE_TIER_LEVEL_OFFSET = 3;
+/**
+* Inside a NAL unit, the encoder writes an emulation_prevention_three_byte after two zero bytes
+* that a byte of 0 to 3 would follow, and the decoder drops it (ITU-T H.265 §7.4.2). The SPS's
+* flags are mostly zeros, so they hold such bytes, and are read with them dropped.
+*/
+var EMULATION_PREVENTION_BYTE = 3;
+var ZEROS_BEFORE_EMULATION_PREVENTION = 2;
+/**
+* ISO/IEC 14496-15 Annex E.3: the profile space as no letter or A to C, the tier as L or H, the
+* flags in hexadecimal.
+*/
+var PROFILE_SPACE_CODES = [
+	"",
+	"A",
+	"B",
+	"C"
+];
+var MAIN_TIER_CODE = "L";
+var HIGH_TIER_CODE = "H";
+var HEXADECIMAL = 16;
+/**
+* The WebCodecs codec string of an HEVC track (ISO/IEC 14496-15 Annex E.3), from its sample
+* entry type and its configuration (the `hvcC` box's payload). The configuration's header is
+* meant to repeat the profile, tier and level of the stream's SPS; where it names no profile, as
+* the Antigravity A1 leaves it, the SPS the configuration carries is read instead, since browsers
+* refuse a codec string without a profile although they decode the stream.
+*/
+function hevcCodecStringOf(sampleEntryType, configuration) {
+	return codecStringOf(sampleEntryType, declaredProfileTierLevelOf(configuration));
+}
+function declaredProfileTierLevelOf(configuration) {
+	const header = profileTierLevelAt(new ByteReader(configuration), 1);
+	return header.profile === NO_PROFILE ? spsProfileTierLevelIn(configuration) ?? header : header;
+}
+/**
+* The profile, tier and level of the first SPS the configuration carries; undefined where it
+* carries none, or where its parameter sets run past its end. The header's blank string then
+* stands, which browsers refuse as a codec they do not support.
+*/
+function spsProfileTierLevelIn(configuration) {
+	try {
+		const sps = spsIn(configuration);
+		return sps === void 0 ? void 0 : spsProfileTierLevelOf(sps);
+	} catch (error) {
+		if (hasErrorCode(error, "binary-out-of-bounds")) return void 0;
+		throw error;
+	}
+}
+function profileTierLevelAt(reader, offset) {
+	const first = reader.uint8At(offset);
+	return {
+		profileSpace: first >> PROFILE_SPACE_SHIFT,
+		isHighTier: (first & HIGH_TIER_FLAG) !== 0,
+		profile: first & PROFILE_MASK,
+		compatibilityFlags: reader.uint32BeAt(offset + COMPATIBILITY_FLAGS_OFFSET),
+		constraintFlags: [...reader.bytesAt(offset + CONSTRAINT_FLAGS_OFFSET, CONSTRAINT_FLAGS_LENGTH)],
+		level: reader.uint8At(offset + LEVEL_OFFSET)
+	};
+}
+function spsProfileTierLevelOf(sps) {
+	return profileTierLevelAt(new ByteReader(withoutEmulationPrevention(sps)), SPS_PROFILE_TIER_LEVEL_OFFSET);
+}
+/**
+* The first SPS among the configuration's parameter sets; undefined where it carries none, as an
+* `hev1` track may, keeping its parameter sets in the stream.
+*/
+function spsIn(configuration) {
+	const reader = new ByteReader(configuration);
+	let offset = 23;
+	for (let index = 0; index < reader.uint8At(22); index += 1) {
+		const array = parameterSetArrayAt(reader, offset);
+		const [sps] = array.nalUnitType === SPS_NAL_UNIT_TYPE ? array.nalUnits : [];
+		if (sps !== void 0) return sps;
+		offset = array.end;
+	}
+}
+function parameterSetArrayAt(reader, offset) {
+	const nalUnitType = reader.uint8At(offset) & 63;
+	const count = reader.uint16BeAt(offset + 1);
+	const nalUnits = [];
+	let unitOffset = offset + 3;
+	for (let index = 0; index < count; index += 1) {
+		const length = reader.uint16BeAt(unitOffset);
+		nalUnits.push(reader.bytesAt(unitOffset + 2, length));
+		unitOffset += 2 + length;
+	}
+	return {
+		nalUnitType,
+		nalUnits,
+		end: unitOffset
+	};
+}
+/**
+* A NAL unit as the decoder reads it, its emulation prevention bytes dropped.
+*/
+function withoutEmulationPrevention(nalUnit) {
+	const kept = [];
+	let zeros = 0;
+	for (const byte of nalUnit) {
+		if (!(zeros >= ZEROS_BEFORE_EMULATION_PREVENTION && byte === EMULATION_PREVENTION_BYTE)) kept.push(byte);
+		zeros = byte === 0 ? zeros + 1 : 0;
+	}
+	return Uint8Array.from(kept);
+}
+function codecStringOf(sampleEntryType, declared) {
+	const profile = `${PROFILE_SPACE_CODES[declared.profileSpace] ?? ""}${declared.profile}`;
+	const tier = declared.isHighTier ? HIGH_TIER_CODE : MAIN_TIER_CODE;
+	const constraints = withoutTrailingZeros(declared.constraintFlags).map((byte) => hexadecimalOf(byte));
+	return [
+		sampleEntryType,
+		profile,
+		hexadecimalOf(reversedBitsOf(declared.compatibilityFlags)),
+		`${tier}${declared.level}`,
+		...constraints
+	].join(".");
+}
+/**
+* The compatibility flags as Annex E.3 writes them: flag 0, the configuration's most significant
+* bit, becomes the least significant.
+*/
+function reversedBitsOf(flags) {
+	let reversed = 0;
+	for (let bit = 0; bit < COMPATIBILITY_FLAG_COUNT; bit += 1) reversed = reversed << 1 | flags >>> bit & 1;
+	return reversed >>> 0;
+}
+function withoutTrailingZeros(bytes) {
+	const lastSet = bytes.findLastIndex((byte) => byte !== 0);
+	return bytes.slice(0, lastSet + 1);
+}
+function hexadecimalOf(value) {
+	return value.toString(HEXADECIMAL).toUpperCase();
+}
+//#endregion
+export { hevcCodecStringOf };

package/dist/packages/core/src/domain/motion/imu/ImuFrame.js

@@ -107,6 +107,34 @@ var X6_IMU_FRAME = measuredImuFrame("X6", QUARTER_TURN_ABOUT_LATERAL);
 */
 var X4_AIR_IMU_FRAME = measuredImuFrame("X4 Air", QUARTER_TURN_ABOUT_LATERAL);
 /**
+* Measured on one Antigravity A1 recording (ADR 0009): the drone's lens axis is its vertical, the
+* IMU's y, lens 0 facing up; the ranking puts this quarter turn about that axis first, the X5's
+* arrangement fourth.
+*/
+var A1_IMU_FRAME = measuredImuFrame("A1", [
+	"-z",
+	"-x",
+	"y"
+]);
+/**
+* Measured on one X3 recording (ADR 0009): the X5's arrangement again. The camera stood still on
+* its side, so the levelling ranking decided it rather than the stillness ranking: it alone of
+* the four that put gravity on the body's axis stands the picture as level as Studio's.
+*/
+var X3_IMU_FRAME = measuredImuFrame("X3", QUARTER_TURN_ABOUT_LATERAL);
+/**
+* Assumed for the ONE RS until a recording that turns is ranked (ADR 0009). On one tripod
+* recording of the 1-inch 360 edition, standing upright, gravity lies along the IMU's x, so the
+* body's down is the IMU's x; of the four arrangements that agree, the levelling ranking puts
+* this quarter turn about the lens axis first in both browsers, by too little to decide it. The
+* model name covers the 360 lens module too, assumed alike.
+*/
+var ONE_RS_IMU_FRAME = assumedImuFrame("ONE RS (unverified)", [
+	"-y",
+	"x",
+	"z"
+]);
+/**
 * Until a recording proves otherwise, the IMU is assumed aligned with the body.
 */
 var ALIGNED_IMU_FRAME = assumedImuFrame("aligned (unverified)", [
@@ -116,12 +144,16 @@ var ALIGNED_IMU_FRAME = assumedImuFrame("aligned (unverified)", [
 ]);
 /**
 * Keyed by the whole model name: a name that extends a measured one ("X4 Air" of "X4", an "X5
-* Pro") is another camera, unmeasured until a recording of it is ranked.
+* Pro") is another camera, unmeasured until a recording of it is ranked. Every frame is measured
+* but the ONE RS's, assumed and reported as such.
 */
 var IMU_FRAMES_BY_MODEL = /* @__PURE__ */ new Map([
+	["Antigravity A1", A1_IMU_FRAME],
+	["Insta360 X3", X3_IMU_FRAME],
 	["Insta360 X4 Air", X4_AIR_IMU_FRAME],
 	["Insta360 X5", X5_IMU_FRAME],
-	["Insta360 X6", X6_IMU_FRAME]
+	["Insta360 X6", X6_IMU_FRAME],
+	["Insta360 OneRS", ONE_RS_IMU_FRAME]
 ]);
 /**
 * The IMU frame for a recording, chosen from the camera model the file names. A starting point
@@ -131,4 +163,4 @@ function imuFrameFor(hints) {
 	return IMU_FRAMES_BY_MODEL.get(hints.model?.trim() ?? "") ?? ALIGNED_IMU_FRAME;
 }
 //#endregion
-export { ALIGNED_IMU_FRAME, X4_AIR_IMU_FRAME, X5_IMU_FRAME, X6_IMU_FRAME, assumedImuFrame, imuFrameFor, isProperRotation, toBodyFrame };
+export { A1_IMU_FRAME, ALIGNED_IMU_FRAME, ONE_RS_IMU_FRAME, X3_IMU_FRAME, X4_AIR_IMU_FRAME, X5_IMU_FRAME, X6_IMU_FRAME, assumedImuFrame, imuFrameFor, isProperRotation, toBodyFrame };

package/dist/packages/core/src/domain/motion/mounting/Mounting.js

@@ -0,0 +1,117 @@
+import { HALF_TURN, QUARTER_TURN, degrees, degreesToRadians, radians } from "../../../shared/units/angle.js";
+import { ZERO_VECTOR3, addVectors, dotProduct, magnitudeOf } from "../../../shared/math/Vector3.js";
+import { multiplyMatrices, rotationAboutX, rotationAboutY, rotationAboutZ, transformVector, transposeMatrix } from "../../../shared/math/Matrix3.js";
+import { toBodyFrame } from "../imu/ImuFrame.js";
+import { indexOfLeast } from "../../../shared/math/minimum.js";
+import { measuredGravity } from "../orientation/gravity.js";
+//#region ../../packages/core/src/domain/motion/mounting/Mounting.ts
+var QUARTER_TURN_ANGLE = degreesToRadians(QUARTER_TURN);
+var MINUS_QUARTER_TURN_ANGLE = degreesToRadians(degrees(-QUARTER_TURN));
+var HALF_TURN_ANGLE = degreesToRadians(HALF_TURN);
+/**
+* Also how a recording stands whose gravity cannot be read: one without a gyro record, or whose
+* IMU frame is a guess.
+*/
+var UPRIGHT_MOUNTING = {
+	name: "upright",
+	toBody: lensLevel(radians(0))
+};
+var DOWN = [
+	0,
+	1,
+	0
+];
+var LENS_AXIS = [
+	0,
+	0,
+	1
+];
+/**
+* The four ways a camera can stand with its lens axis level, one for each body axis across it
+* that gravity can lie along.
+*/
+var LENS_LEVEL_MOUNTINGS = [
+	UPRIGHT_MOUNTING,
+	{
+		name: "upside down",
+		toBody: lensLevel(HALF_TURN_ANGLE)
+	},
+	{
+		name: "on its right side",
+		toBody: lensLevel(MINUS_QUARTER_TURN_ANGLE)
+	},
+	{
+		name: "on its left side",
+		toBody: lensLevel(QUARTER_TURN_ANGLE)
+	}
+];
+/**
+* The two ways a camera can stand with its lens axis the vertical.
+*/
+var LENS_VERTICAL_MOUNTINGS = [{
+	name: "with lens 0 up",
+	toBody: lensVertical(MINUS_QUARTER_TURN_ANGLE)
+}, {
+	name: "with lens 0 down",
+	toBody: lensVertical(QUARTER_TURN_ANGLE)
+}];
+var LENS_VERTICAL_CONE_COSINE = Math.cos(degreesToRadians(degrees(30)));
+/**
+* A half turn about the vertical faces the upright frame away from lens 0, then a turn about the
+* lens axis stands the body as it stood.
+*/
+function lensLevel(roll) {
+	return multiplyMatrices(rotationAboutZ(roll), rotationAboutY(HALF_TURN_ANGLE));
+}
+/**
+* A quarter turn about the vertical faces the upright frame along the body's minus x, then a
+* quarter turn about the lateral axis stands lens 0's axis up or down.
+*/
+function lensVertical(tilt) {
+	return multiplyMatrices(rotationAboutX(tilt), rotationAboutY(MINUS_QUARTER_TURN_ANGLE));
+}
+/**
+* The mounting whose down lies nearest the gravity the accelerometer measured whenever the camera
+* rested, read through the IMU frame: lens-vertical within its cone of the lens axis, lens-level
+* outside it. Quarter turns only, so the picture keeps every tilt the camera really took.
+* Upright for a camera that never rests, and for one whose IMU frame is a guess: read through a
+* wrong frame, gravity would stand the picture on its side or on its head.
+*/
+function mountingOf(gyro, frame) {
+	if (!frame.isVerified) return UPRIGHT_MOUNTING;
+	const gravity = restingGravitySumOf(gyro, frame);
+	const mountings = isNearLensAxis(gravity) ? LENS_VERTICAL_MOUNTINGS : LENS_LEVEL_MOUNTINGS;
+	const misalignments = mountings.map((mounting) => -dotProduct(transformVector(mounting.toBody, DOWN), gravity));
+	return mountings[indexOfLeast(misalignments)] ?? UPRIGHT_MOUNTING;
+}
+function isNearLensAxis(gravity) {
+	return Math.abs(dotProduct(gravity, LENS_AXIS)) > LENS_VERTICAL_CONE_COSINE * magnitudeOf(gravity);
+}
+/**
+* The IMU frame as it lies in the mounting's upright frame: what the camera's orientation is
+* integrated in, so that levelling and heading start from the camera as it stood. Its `toBody`
+* reads into the upright frame, which stands for the body throughout the integration.
+*/
+function uprightImuFrame(frame, mounting) {
+	return {
+		...frame,
+		toBody: multiplyMatrices(transposeMatrix(mounting.toBody), frame.toBody)
+	};
+}
+/**
+* A rotation into the mounting's upright frame, such as a stabilizer's, carried on into the body
+* the lenses are posed in.
+*/
+function rotationIntoBody(mounting, uprightRotation) {
+	return multiplyMatrices(mounting.toBody, uprightRotation);
+}
+function restingGravitySumOf(gyro, frame) {
+	let sum = ZERO_VECTOR3;
+	for (let index = 0; index < gyro.length; index += 1) {
+		const gravity = measuredGravity(toBodyFrame(frame, gyro.sampleAt(index).acceleration));
+		if (gravity) sum = addVectors(sum, gravity);
+	}
+	return sum;
+}
+//#endregion
+export { UPRIGHT_MOUNTING, mountingOf, rotationIntoBody, uprightImuFrame };

package/dist/packages/core/src/domain/motion/orientation/OrientationTrack.js

@@ -24,8 +24,10 @@ var QUATERNION_COMPONENTS = 4;
 */
 var MAX_STEP_SECONDS = .05;
 /**
-* The camera's orientation over the whole recording, body frame to world frame, one quaternion
-* per gyro sample. World: y down along gravity, z along the body's forward axis at the start.
+* The camera's orientation over the whole recording, from the frame its IMU frame reads into (the
+* body, or the upright frame of its mounting, as the player integrates it) to the world, one
+* quaternion per gyro sample. World: y down along gravity, z along that frame's forward axis at
+* the start.
 */
 var OrientationTrack = class OrientationTrack {
 	videoTimes;

package/dist/packages/core/src/domain/motion/orientation/gravity.js

@@ -94,4 +94,4 @@ function anyPerpendicular(v) {
 	];
 }
 //#endregion
-export { WORLD_DOWN, gravityCorrection, initialOrientation };
+export { WORLD_DOWN, gravityCorrection, initialOrientation, measuredGravity };

package/dist/packages/core/src/index.js

@@ -15,7 +15,9 @@ import { clamp } from "./shared/math/clamp.js";
 import "./domain/motion/timing/FrameTimes.js";
 import { IDENTITY_MATRIX3 } from "./shared/math/Matrix3.js";
 import "./domain/motion/imu/ImuFrame.js";
+import "./shared/math/minimum.js";
 import "./shared/math/Quaternion.js";
+import { UPRIGHT_MOUNTING } from "./domain/motion/mounting/Mounting.js";
 import "./domain/motion/orientation/OrientationTrack.js";
 import { timeRecording } from "./application/recording/timeRecording.js";
 import "./domain/format/naming/RecordingFileName.js";
@@ -26,6 +28,7 @@ import "./domain/container/TrackSampleTable.js";
 import { readSampleTable } from "./application/recording/readSampleTable.js";
 import "./domain/stitching/LensLayout.js";
 import { detectLensLayout } from "./domain/format/layout/detectLensLayout.js";
+import { hevcCodecStringOf } from "./domain/format/mp4/hevcCodecString.js";
 import { DEFAULT_STABILIZATION_MODE, STABILIZATION_MODES } from "./domain/motion/stabilization/Stabilizer.js";
 import { stabilizerFor } from "./domain/motion/stabilization/stabilizers.js";
 import "./domain/optics/lensPose.js";
@@ -68,4 +71,4 @@ import { WallClock } from "./application/playback/WallClock.js";
 import { isFlowing } from "./domain/playback/PlayerState.js";
 import { TypedEmitter } from "./shared/events/TypedEmitter.js";
 import { PlaybackSession } from "./application/playback/PlaybackSession.js";
-export { BT709_LUMINANCE, ByteRange, COLOUR_PRIMARIES, DEFAULT_FRAMING, DEFAULT_PICTURE_QUALITY, DEFAULT_STABILIZATION_MODE, DEFAULT_VIEW_MODE, Deferred, Ending, GYRO_VIEW_ERROR_CATEGORIES, GYRO_VIEW_ERROR_CODES, GainMatchingFrameSink, GyroViewError, HLG_OETF, IDENTITY_MATRIX3, ITERATION_END, MATRIX_COEFFICIENTS, MEI_TERM_CAPACITY, Outbox, PICTURE_QUALITIES, PlaybackSession, RecordingBuffer, RunStop, SCREEN_CENTRE, STABILIZATION_MODES, STOPPED, SourceByteStream, StabilizingFrameSink, TRANSFER_CHARACTERISTICS, TypedEmitter, VIEW_MODES, WallClock, asGyroViewError, aspectOf, aspectOfArea, buildStitchingSetup, clamp, clampView, degrees, detectLensLayout, displayConversionsOf, downloadPolicyFor, ensureIndexInRange, ensureInvariant, fileNameOfUrl, hasErrorCode, inspectRecording, isAbortError, isFlowing, isGyroViewErrorCode, isSameFraming, isSameView, keysOf, lazy, lensFrameOrder, locateOtherLensFile, lookAt, matrixCorrectionOf, messageOf, microseconds, microsecondsToSeconds, milliseconds, namedOrUnspecified, pixelRatioCapOf, planeHalfExtentOf, probeDecoding, readRecording, readSampleTable, seconds, secondsToMicroseconds, stabilizerFor, startFileDownload, timeRecording, viewModeRulesFor, zoomStepsForPinch };
+export { BT709_LUMINANCE, ByteRange, COLOUR_PRIMARIES, DEFAULT_FRAMING, DEFAULT_PICTURE_QUALITY, DEFAULT_STABILIZATION_MODE, DEFAULT_VIEW_MODE, Deferred, Ending, GYRO_VIEW_ERROR_CATEGORIES, GYRO_VIEW_ERROR_CODES, GainMatchingFrameSink, GyroViewError, HLG_OETF, IDENTITY_MATRIX3, ITERATION_END, MATRIX_COEFFICIENTS, MEI_TERM_CAPACITY, Outbox, PICTURE_QUALITIES, PlaybackSession, RecordingBuffer, RunStop, SCREEN_CENTRE, STABILIZATION_MODES, STOPPED, SourceByteStream, StabilizingFrameSink, TRANSFER_CHARACTERISTICS, TypedEmitter, UPRIGHT_MOUNTING, VIEW_MODES, WallClock, asGyroViewError, aspectOf, aspectOfArea, buildStitchingSetup, clamp, clampView, degrees, detectLensLayout, displayConversionsOf, downloadPolicyFor, ensureIndexInRange, ensureInvariant, fileNameOfUrl, hasErrorCode, hevcCodecStringOf, inspectRecording, isAbortError, isFlowing, isGyroViewErrorCode, isSameFraming, isSameView, keysOf, lazy, lensFrameOrder, locateOtherLensFile, lookAt, matrixCorrectionOf, messageOf, microseconds, microsecondsToSeconds, milliseconds, namedOrUnspecified, pixelRatioCapOf, planeHalfExtentOf, probeDecoding, readRecording, readSampleTable, seconds, secondsToMicroseconds, stabilizerFor, startFileDownload, timeRecording, viewModeRulesFor, zoomStepsForPinch };

package/dist/packages/core/src/shared/binary/ByteReader.js

@@ -41,6 +41,10 @@ var ByteReader = class {
 		this.ensureAvailable(offset, UINT32_SIZE);
 		return this.view.getUint32(offset, IS_LITTLE_ENDIAN);
 	}
+	uint16BeAt(offset) {
+		this.ensureAvailable(offset, UINT16_SIZE);
+		return this.view.getUint16(offset, IS_BIG_ENDIAN);
+	}
 	uint32BeAt(offset) {
 		this.ensureAvailable(offset, UINT32_SIZE);
 		return this.view.getUint32(offset, IS_BIG_ENDIAN);

package/dist/packages/core/src/shared/index.js

@@ -5,6 +5,7 @@ import { microseconds, microsecondsToSeconds, milliseconds, seconds, secondsToMi
 import "./math/Vector3.js";
 import { clamp } from "./math/clamp.js";
 import { IDENTITY_MATRIX3 } from "./math/Matrix3.js";
+import "./math/minimum.js";
 import "./math/Quaternion.js";
 import { keysOf } from "./keysOf.js";
 import { Outbox } from "./events/Outbox.js";

package/dist/packages/core/src/shared/math/Matrix3.js

@@ -73,6 +73,23 @@ function multiplyMatrices(a, b) {
 		a20 * b02 + a21 * b12 + a22 * b22
 	];
 }
+/**
+* The transpose, which for a rotation is its inverse.
+*/
+function transposeMatrix(m) {
+	const [m00, m01, m02, m10, m11, m12, m20, m21, m22] = m;
+	return [
+		m00,
+		m10,
+		m20,
+		m01,
+		m11,
+		m21,
+		m02,
+		m12,
+		m22
+	];
+}
 function transformVector(m, v) {
 	const [m00, m01, m02, m10, m11, m12, m20, m21, m22] = m;
 	const [x, y, z] = v;
@@ -90,4 +107,4 @@ function determinantOf(m) {
 	return m00 * (m11 * m22 - m12 * m21) - m01 * (m10 * m22 - m12 * m20) + m02 * (m10 * m21 - m11 * m20);
 }
 //#endregion
-export { IDENTITY_MATRIX3, determinantOf, multiplyMatrices, rotationAboutX, rotationAboutY, rotationAboutZ, transformVector };
+export { IDENTITY_MATRIX3, determinantOf, multiplyMatrices, rotationAboutX, rotationAboutY, rotationAboutZ, transformVector, transposeMatrix };

package/dist/packages/core/src/shared/math/minimum.js

@@ -0,0 +1,17 @@
+//#region ../../packages/core/src/shared/math/minimum.ts
+/**
+* The index of the least of the values, the first on a tie; values that are not finite never
+* win, so a list of them all gives index 0.
+*/
+function indexOfLeast(values) {
+	let best = 0;
+	let least = Infinity;
+	for (const [index, value] of values.entries()) {
+		if (!Number.isFinite(value) || !(value < least)) continue;
+		best = index;
+		least = value;
+	}
+	return best;
+}
+//#endregion
+export { indexOfLeast };

package/dist/packages/player/src/composition/buildPipeline.js

@@ -1,5 +1,6 @@
 import { messageOf } from "../../../core/src/shared/errors/GyroViewError.js";
 import { milliseconds, seconds } from "../../../core/src/shared/units/time.js";
+import { UPRIGHT_MOUNTING } from "../../../core/src/domain/motion/mounting/Mounting.js";
 import { stabilizerFor } from "../../../core/src/domain/motion/stabilization/stabilizers.js";
 import { buildStitchingSetup } from "../../../core/src/domain/stitching/StitchingSetup.js";
 import { StabilizingFrameSink } from "../../../core/src/application/stabilization/StabilizingFrameSink.js";
@@ -129,13 +130,16 @@ function stitchingSetupOf(opened) {
 	});
 }
 function sinkOver(renderer, opened) {
-	if (!opened.motion) return {
-		sink: renderer,
-		stabilizing: void 0
-	};
+	if (!opened.motion) {
+		renderer.setStabilization(UPRIGHT_MOUNTING.toBody);
+		return {
+			sink: renderer,
+			stabilizing: void 0
+		};
+	}
 	const stabilizing = new StabilizingFrameSink({
 		sink: renderer,
-		orientations: opened.motion.orientations,
+		motion: opened.motion,
 		frameTimes: opened.frameTimes
 	});
 	return {