@bubo-squared/gyroview 0.4.1 → 0.5.0

package/dist/packages/core/src/domain/motion/gyro/GyroTrack.js

@@ -38,14 +38,24 @@ var GyroTrack = class {
 	}
 	sampleAt(index) {
 		ensureIndexInRange(index, this.length, "gyro sample");
-		const base = index * 3;
 		return {
 			captureTime: microseconds(this.captureTimeStore[index] ?? 0),
-			acceleration: this.vectorAt(this.accelerationStore, base),
-			angularVelocity: this.vectorAt(this.angularVelocityStore, base)
+			acceleration: this.vectorAt(this.accelerationStore, index),
+			angularVelocity: this.vectorAt(this.angularVelocityStore, index)
 		};
 	}
-	vectorAt(store, base) {
+	/**
+	* A sample's angular velocity alone, for the loops over every sample that need nothing else.
+	*/
+	angularVelocityAt(index) {
+		ensureIndexInRange(index, this.length, "gyro sample");
+		return this.vectorAt(this.angularVelocityStore, index);
+	}
+	/**
+	* The vector at an index already checked.
+	*/
+	vectorAt(store, index) {
+		const base = index * 3;
 		return [
 			store[base] ?? NaN,
 			store[base + 1] ?? NaN,

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

@@ -1,5 +1,5 @@
 import { ensureInvariant } from "../../../shared/errors/GyroViewError.js";
-import { seconds } from "../../../shared/units/time.js";
+import { microseconds, seconds } from "../../../shared/units/time.js";
 import { ZERO_VECTOR3, addVectors, isFiniteVector, scaleVector, subtractVectors } from "../../../shared/math/Vector3.js";
 import { clamp } from "../../../shared/math/clamp.js";
 import { toBodyFrame } from "../imu/ImuFrame.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;
@@ -107,7 +109,7 @@ var OrientationTrack = class OrientationTrack {
 * lookup's binary search holds.
 */
 function sampleVideoTimes(gyro, clock) {
-	return Float64Array.from({ length: gyro.length }, (_unused, index) => clock.gyroVideoTimeOf(gyro.sampleAt(index).captureTime));
+	return gyro.captureTimes.map((captureTime) => clock.gyroVideoTimeOf(microseconds(captureTime)));
 }
 function finiteSample(gyro, index) {
 	const sample = gyro.sampleAt(index);

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

@@ -18,7 +18,7 @@ var FALLBACK_INTERVAL = secondsToMicroseconds(seconds(1));
 function stillestWindow(gyro, frame, length) {
 	const interval = microsecondsToSeconds(gyro.meanSampleInterval ?? FALLBACK_INTERVAL);
 	const size = Math.max(1, Math.min(gyro.length, Math.round(length / interval)));
-	const magnitudes = Float64Array.from({ length: gyro.length }, (_unused, index) => magnitudeOf(toBodyFrame(frame, gyro.sampleAt(index).angularVelocity)));
+	const magnitudes = rateMagnitudesOf(gyro, frame);
 	let windowSum = 0;
 	for (let index = 0; index < size; index += 1) windowSum += magnitudes[index] ?? 0;
 	let best = {
@@ -38,6 +38,14 @@ function stillestWindow(gyro, frame, length) {
 	};
 }
 /**
+* How fast the body turns at each sample, in radians per second.
+*/
+function rateMagnitudesOf(gyro, frame) {
+	const magnitudes = new Float64Array(gyro.length);
+	for (let index = 0; index < gyro.length; index += 1) magnitudes[index] = magnitudeOf(toBodyFrame(frame, gyro.angularVelocityAt(index)));
+	return magnitudes;
+}
+/**
 * The mean of one vector quantity over a window of samples, in the body frame.
 */
 function meanOverWindow({ gyro, frame }, window, quantity) {

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

@@ -10,6 +10,11 @@ var FLOAT64_SIZE = 8;
 var IS_LITTLE_ENDIAN = true;
 var IS_BIG_ENDIAN = false;
 /**
+* The safe integer range as big integers, made once: a gyro record reads a stamp per sample.
+*/
+var MIN_SAFE_BIGINT = BigInt(Number.MIN_SAFE_INTEGER);
+var MAX_SAFE_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+/**
 * Bounds-checked reads over a byte array: little-endian for Insta360's records, big-endian for
 * ISO BMFF boxes. Every read is positional, so callers express the layouts they parse as named
 * offsets rather than as a moving cursor.
@@ -36,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);
@@ -84,7 +93,7 @@ var ByteReader = class {
 		return Array.from(this.bytesAt(offset, length), (byte) => String.fromCodePoint(byte)).join("");
 	}
 	toSafeNumber(value, offset) {
-		if (!(value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER))) throw new GyroViewError("binary-unsafe-integer", `64-bit integer at offset ${offset} (${value.toString()}) exceeds the safe integer range`);
+		if (!(value >= MIN_SAFE_BIGINT && value <= MAX_SAFE_BIGINT)) throw new GyroViewError("binary-unsafe-integer", `64-bit integer at offset ${offset} (${value.toString()}) exceeds the safe integer range`);
 		return Number(value);
 	}
 	ensureAvailable(offset, length) {

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/Quaternion.js

@@ -62,7 +62,7 @@ function conjugateQuaternion(q) {
 }
 function normalizeQuaternion(q) {
 	const [x, y, z, w] = q;
-	const length = Math.hypot(x, y, z, w);
+	const length = Math.sqrt(x * x + y * y + z * z + w * w);
 	return length === 0 ? IDENTITY_QUATERNION : [
 		x / length,
 		y / length,

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

@@ -4,8 +4,12 @@ var ZERO_VECTOR3 = [
 	0,
 	0
 ];
+/**
+* The square root of the squares, not `Math.hypot`: several times slower in V8, it guards against
+* overflow no reading or direction here comes near, and gyro integration takes a million of these.
+*/
 function magnitudeOf(vector) {
-	return Math.hypot(vector[0], vector[1], vector[2]);
+	return Math.sqrt(dotProduct(vector, vector));
 }
 function dotProduct(a, b) {
 	return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];

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/AnimationFrameDraws.js

@@ -0,0 +1,38 @@
+import { ANIMATION_FRAMES } from "./animationFrames.js";
+//#region ../../packages/player/src/composition/AnimationFrameDraws.ts
+/**
+* Draws a renderer's changed settings once at the next animation frame, however many changes
+* come before it (ADR 0035): the screen shows one picture a frame, and WebKit hands the page
+* every pointer move of a drag, thousands a second from a fast mouse, which drawn one by one
+* leave no time for the frames of the recording. One schedule serves one renderer.
+*/
+var AnimationFrameDraws = class {
+	frames;
+	pendingDraw;
+	handle;
+	constructor(frames = ANIMATION_FRAMES) {
+		this.frames = frames;
+	}
+	/**
+	* The latest draw asked for is the one drawn.
+	*/
+	request(draw) {
+		const isFrameRequested = this.pendingDraw !== void 0;
+		this.pendingDraw = draw;
+		if (!isFrameRequested) this.handle = this.frames.request(this.drawPending);
+	}
+	cancel() {
+		this.pendingDraw = void 0;
+		if (this.handle === void 0) return;
+		this.frames.cancel(this.handle);
+		this.handle = void 0;
+	}
+	drawPending = () => {
+		const draw = this.pendingDraw;
+		this.pendingDraw = void 0;
+		this.handle = void 0;
+		draw?.();
+	};
+};
+//#endregion
+export { AnimationFrameDraws };

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

@@ -0,0 +1,9 @@
+//#region ../../packages/player/src/composition/animationFrames.ts
+var ANIMATION_FRAMES = {
+	request: (callback) => requestAnimationFrame(callback),
+	cancel: (handle) => {
+		cancelAnimationFrame(handle);
+	}
+};
+//#endregion
+export { ANIMATION_FRAMES };

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";
@@ -12,6 +13,7 @@ import { MediaSourceAudioClock } from "../../../adapters/mse-audio/src/MediaSour
 import "../../../adapters/mse-audio/src/index.js";
 import { ThreeFrameRenderer } from "../../../adapters/three/src/ThreeFrameRenderer.js";
 import "../../../adapters/three/src/index.js";
+import { AnimationFrameDraws } from "./AnimationFrameDraws.js";
 import { Disposables } from "./Disposables.js";
 var DECODE_PIPELINE_OPTIONS = {
 	maxPendingPackets: 4,
@@ -53,10 +55,11 @@ async function buildPipeline(parts) {
 }
 /**
 * The GPU stitcher on the host canvas, behind the stabilizing sink when there is a gyro, behind
-* gain matching, which measures what the stitcher drew.
+* gain matching, which measures what the stitcher drew. A change of the view or the gains is
+* drawn once at the next animation frame, where a frame presented in it draws it anyway.
 */
 function drawingFor(parts, disposables) {
-	const renderer = ThreeFrameRenderer.create(parts.host.canvas, stitchingSetupOf(parts.opened));
+	const renderer = ThreeFrameRenderer.create(parts.host.canvas, stitchingSetupOf(parts.opened), { drawSchedule: new AnimationFrameDraws() });
 	disposables.add(() => {
 		renderer.dispose();
 	});
@@ -127,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 {

package/dist/packages/player/src/player/FrameLoop.js

@@ -1,10 +1,5 @@
+import { ANIMATION_FRAMES } from "../composition/animationFrames.js";
 //#region ../../packages/player/src/player/FrameLoop.ts
-var ANIMATION_FRAMES = {
-	request: (callback) => requestAnimationFrame(callback),
-	cancel: (handle) => {
-		cancelAnimationFrame(handle);
-	}
-};
 /**
 * Calls `tick` once per animation frame between {@link start} and {@link stop}.
 */