@bubo-squared/gyroview 0.1.0 → 0.3.0

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

@@ -0,0 +1,67 @@
+import { HandlerType, Mp4BoxType } from "./mp4BoxTypes.js";
+import { keyframeRuleFor } from "./keyframeRules.js";
+import { boxesIn, fullBoxOf, optionalBox, unreadableMovie } from "./movieBoxes.js";
+import { SYNC_SAMPLE } from "./mp4Layouts.js";
+import { readTableColumns } from "./readTable.js";
+import { sampleLocationsOf } from "./sampleLocations.js";
+import { movieTimescaleOf, trackBoxesOf, trackHeadersOf } from "./trackHeaders.js";
+import { sampleTimingOf } from "./sampleTiming.js";
+import { SampleTable } from "../../container/SampleTable.js";
+import { TrackSampleTable } from "../../container/TrackSampleTable.js";
+//#region ../../packages/core/src/domain/format/mp4/parseMovie.ts
+/**
+* The tracks the player plays, by handler; the others (time codes, metadata) are left out.
+*/
+var KIND_OF_HANDLER = {
+	[HandlerType.Video]: "video",
+	[HandlerType.Sound]: "audio"
+};
+/**
+* Sample numbers in the sync sample table count from one.
+*/
+var FIRST_SAMPLE_NUMBER = 1;
+/**
+* The sample table of a whole movie box (`moov`, header included): every sample of every track
+* of picture or sound. A fragmented movie, whose samples are described in movie fragments after
+* it, is refused: the cameras write none.
+*/
+function parseMovie(movieBox) {
+	const [movie] = boxesIn(movieBox);
+	if (movie?.type !== Mp4BoxType.Movie) throw unreadableMovie("is not where the file says it is");
+	const children = boxesIn(movie.body);
+	if (optionalBox(children, Mp4BoxType.MovieExtends)) throw unreadableMovie("is fragmented: its samples are described in movie fragments after it");
+	const movieTimescale = movieTimescaleOf(children);
+	const tracks = children.filter((box) => box.type === Mp4BoxType.Track).flatMap((box) => playedTrackOf(trackBoxesOf(box), movieTimescale));
+	return new SampleTable(tracks);
+}
+function playedTrackOf(boxes, movieTimescale) {
+	const headers = trackHeadersOf(boxes);
+	const kind = KIND_OF_HANDLER[headers.handlerType];
+	if (!kind) return [];
+	const locations = sampleLocationsOf(boxes.sampleTable);
+	const timing = sampleTimingOf(boxes, {
+		media: headers.mediaTimescale,
+		movie: movieTimescale,
+		sampleCount: locations.sizes.length
+	});
+	return [new TrackSampleTable({
+		trackId: headers.trackId,
+		kind,
+		...locations,
+		...timing,
+		syncSamples: syncSamplesOf(boxes.sampleTable),
+		keyframeRule: keyframeRuleFor(headers)
+	})];
+}
+/**
+* The samples decoding may start at, counted from zero; undefined for a track without a sync
+* sample table, whose every sample is one.
+*/
+function syncSamplesOf(sampleTable) {
+	const box = optionalBox(sampleTable, Mp4BoxType.SyncSample);
+	if (!box) return void 0;
+	const { sampleNumber } = readTableColumns(fullBoxOf(box).content, SYNC_SAMPLE);
+	return sampleNumber.map((number) => number - FIRST_SAMPLE_NUMBER);
+}
+//#endregion
+export { parseMovie };

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

@@ -0,0 +1,31 @@
+import { unreadableMovie } from "./movieBoxes.js";
+//#region ../../packages/core/src/domain/format/mp4/readTable.ts
+/**
+* How each kind of integer in a box layout is read, big-endian.
+*/
+var READERS = {
+	uint32: (reader, offset) => reader.uint32BeAt(offset),
+	uint64: (reader, offset) => reader.uint64BeAt(offset),
+	int32: (reader, offset) => reader.int32BeAt(offset),
+	int64: (reader, offset) => reader.int64BeAt(offset)
+};
+/**
+* The integer a layout puts at `field`, counted from `base`.
+*/
+function readInteger(reader, field, base = 0) {
+	return READERS[field.kind](reader, base + field.offset);
+}
+/**
+* A table box's entries, one column per field, read from its content after the version and
+* flags.
+*/
+function readTableColumns(content, layout) {
+	const count = content.uint32BeAt(0);
+	if (4 + count * layout.entrySize > content.length) throw unreadableMovie(`has a table of ${count} entries that do not fit in its box`);
+	const fields = Object.keys(layout.fields);
+	const columns = {};
+	for (const field of fields) columns[field] = Array.from({ length: count }, (_, index) => readInteger(content, layout.fields[field], 4 + index * layout.entrySize));
+	return columns;
+}
+//#endregion
+export { readTableColumns };

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

@@ -0,0 +1,69 @@
+import { Mp4BoxType } from "./mp4BoxTypes.js";
+import { fullBoxOf, optionalBox, requiredBox, unreadableMovie } from "./movieBoxes.js";
+import { CHUNK_LARGE_OFFSET, CHUNK_OFFSET, SAMPLE_TO_CHUNK } from "./mp4Layouts.js";
+import { readTableColumns } from "./readTable.js";
+//#region ../../packages/core/src/domain/format/mp4/sampleLocations.ts
+/**
+* Chunk numbers in the sample-to-chunk table count from one.
+*/
+var FIRST_CHUNK_NUMBER = 1;
+/**
+* The sample locations a sample table's boxes describe: the sizes of `stsz`, laid out one after
+* another in the chunks `stsc` fills, which start where `stco` or `co64` says.
+*/
+function sampleLocationsOf(sampleTable) {
+	const sizes = sampleSizesOf(requiredBox(sampleTable, Mp4BoxType.SampleSize));
+	const chunkOffsets = chunkOffsetsOf(sampleTable);
+	const sampleToChunk = fullBoxOf(requiredBox(sampleTable, Mp4BoxType.SampleToChunk)).content;
+	return {
+		offsets: offsetsOf({
+			sizes,
+			chunkOffsets,
+			perChunk: samplesPerChunkOf(readTableColumns(sampleToChunk, SAMPLE_TO_CHUNK), chunkOffsets.length)
+		}),
+		sizes
+	};
+}
+function sampleSizesOf(box) {
+	const { content } = fullBoxOf(box);
+	const shared = content.uint32BeAt(0);
+	const count = content.uint32BeAt(4);
+	if (shared !== 0) return new Float64Array(count).fill(shared);
+	if (8 + count * 4 > content.length) throw unreadableMovie(`lists ${count} sample sizes that do not fit in its box`);
+	return Float64Array.from({ length: count }, (_, index) => content.uint32BeAt(8 + index * 4));
+}
+function chunkOffsetsOf(sampleTable) {
+	const large = optionalBox(sampleTable, Mp4BoxType.ChunkLargeOffset);
+	const box = large ?? optionalBox(sampleTable, Mp4BoxType.ChunkOffset);
+	if (!box) throw unreadableMovie("has a sample table without chunk offsets");
+	const layout = large ? CHUNK_LARGE_OFFSET : CHUNK_OFFSET;
+	return readTableColumns(fullBoxOf(box).content, layout).chunkOffset;
+}
+/**
+* How many samples each chunk holds: every entry holds from its first chunk to the next entry's.
+*/
+function samplesPerChunkOf(table, chunkCount) {
+	const perChunk = Array.from({ length: chunkCount }, () => 0);
+	for (const [entry, firstChunk] of table.firstChunk.entries()) {
+		const nextFirst = table.firstChunk[entry + 1] ?? chunkCount + FIRST_CHUNK_NUMBER;
+		const count = table.samplesPerChunk[entry] ?? 0;
+		perChunk.fill(count, firstChunk - FIRST_CHUNK_NUMBER, nextFirst - FIRST_CHUNK_NUMBER);
+	}
+	return perChunk;
+}
+function offsetsOf(layout) {
+	const offsets = new Float64Array(layout.sizes.length);
+	let sample = 0;
+	for (const [chunk, chunkOffset] of layout.chunkOffsets.entries()) {
+		let offset = chunkOffset;
+		const last = Math.min(sample + (layout.perChunk[chunk] ?? 0), offsets.length);
+		for (; sample < last; sample += 1) {
+			offsets[sample] = offset;
+			offset += layout.sizes[sample] ?? 0;
+		}
+	}
+	if (sample < offsets.length) throw unreadableMovie(`has chunks for ${sample} of its ${offsets.length} samples`);
+	return offsets;
+}
+//#endregion
+export { sampleLocationsOf };

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

@@ -0,0 +1,109 @@
+import { seconds } from "../../../shared/units/time.js";
+import { Mp4BoxType } from "./mp4BoxTypes.js";
+import { boxesIn, fullBoxOf, optionalBox, requiredBox, unreadableMovie } from "./movieBoxes.js";
+import { COMPOSITION_OFFSET, EDIT_LIST, TIME_TO_SAMPLE } from "./mp4Layouts.js";
+import { readTableColumns } from "./readTable.js";
+import { inVersion } from "./trackHeaders.js";
+import { presentationOrderOf } from "../../container/presentationOrder.js";
+//#region ../../packages/core/src/domain/format/mp4/sampleTiming.ts
+/**
+* The track's timing as mediabunny reads it, so that both agree to the bit: a sample shows at its
+* decode time plus its composition offset, less the edit list's shift, all in ticks, divided by
+* the timescale once. Where composition offsets reorder the frames, each lasts until the next
+* one shows and the last one shown for its own decode duration.
+*/
+function sampleTimingOf(boxes, context) {
+	const decode = decodeTicksOf(requiredBox(boxes.sampleTable, Mp4BoxType.TimeToSample), context);
+	const offsets = compositionOffsetsOf(boxes.sampleTable, context.sampleCount);
+	const presentation = offsets ? decode.times.map((time, sample) => time + (offsets[sample] ?? 0)) : decode.times;
+	const shift = editShiftOf(boxes.track, context);
+	const timestamps = presentation.map((ticks) => (ticks - shift) / context.media);
+	const durations = (offsets ? presentationGaps(presentation, decode.deltas) : decode.deltas).map((ticks) => ticks / context.media);
+	return {
+		timestamps,
+		durations,
+		end: endOf(timestamps, durations, context.media)
+	};
+}
+/**
+* Each sample's decode time and duration, from the runs of `stts`.
+*/
+function decodeTicksOf(box, context) {
+	const runs = readTableColumns(fullBoxOf(box).content, TIME_TO_SAMPLE);
+	const deltas = expandedRuns(runs.sampleCount, runs.sampleDelta);
+	if (deltas.length !== context.sampleCount) throw unreadableMovie(`times ${deltas.length} samples of a track that has ${context.sampleCount}`);
+	const times = new Float64Array(deltas.length);
+	for (let sample = 1; sample < deltas.length; sample += 1) times[sample] = (times[sample - 1] ?? 0) + (deltas[sample - 1] ?? 0);
+	return {
+		times,
+		deltas
+	};
+}
+/**
+* Each sample's composition offset from the runs of `ctts`, zero past its last run; undefined
+* for a track without the box, whose frames show in decode order.
+*/
+function compositionOffsetsOf(sampleTable, sampleCount) {
+	const box = optionalBox(sampleTable, Mp4BoxType.CompositionOffset);
+	if (!box) return void 0;
+	const runs = readTableColumns(fullBoxOf(box).content, COMPOSITION_OFFSET);
+	const offsets = new Float64Array(sampleCount);
+	offsets.set(expandedRuns(runs.sampleCount, runs.sampleOffset).subarray(0, sampleCount));
+	return offsets;
+}
+function expandedRuns(counts, values) {
+	const total = counts.reduce((sum, count) => sum + count, 0);
+	const expanded = new Float64Array(total);
+	let start = 0;
+	for (const [run, count] of counts.entries()) {
+		expanded.fill(values[run] ?? 0, start, start + count);
+		start += count;
+	}
+	return expanded;
+}
+/**
+* The ticks the edit list moves the media by: the media time of its first edit that shows media
+* at the media's own pace, less the empty edits before it (movie time, rounded to media ticks).
+* Later edits are not followed, as mediabunny does not follow them.
+*/
+function editShiftOf(track, context) {
+	const edit = optionalBox(track, Mp4BoxType.Edit);
+	const list = edit && optionalBox(boxesIn(edit.body), Mp4BoxType.EditList);
+	if (!list) return 0;
+	const box = fullBoxOf(list);
+	const entries = readTableColumns(box.content, inVersion(box, EDIT_LIST, Mp4BoxType.EditList));
+	let emptyDuration = 0;
+	for (const [entry, mediaTime] of entries.mediaTime.entries()) {
+		if (mediaTime === -1) {
+			emptyDuration += entries.segmentDuration[entry] ?? 0;
+			continue;
+		}
+		return entries.mediaRate[entry] === 65536 ? mediaTime - Math.round(emptyDuration / context.movie * context.media) : 0;
+	}
+	return 0;
+}
+/**
+* How long each sample shows: until the next one in presentation order (ties kept in decode
+* order), the last one for its own decode duration.
+*/
+function presentationGaps(presentation, deltas) {
+	const order = presentationOrderOf(presentation);
+	const gaps = Float64Array.from(deltas);
+	for (let position = 0; position < order.length - 1; position += 1) {
+		const sample = order[position] ?? 0;
+		gaps[sample] = (presentation[order[position + 1] ?? 0] ?? 0) - (presentation[sample] ?? 0);
+	}
+	return gaps;
+}
+/**
+* When the last sample shown stops showing, rounded to the timescale as mediabunny rounds a
+* track's duration.
+*/
+function endOf(timestamps, durations, timescale) {
+	const last = presentationOrderOf(timestamps).at(-1);
+	if (last === void 0) return seconds(0);
+	const end = (timestamps[last] ?? 0) + (durations[last] ?? 0);
+	return seconds(Math.round(end * timescale) / timescale);
+}
+//#endregion
+export { sampleTimingOf };

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

@@ -0,0 +1,75 @@
+import { HandlerType, Mp4BoxType } from "./mp4BoxTypes.js";
+import { boxesIn, fullBoxOf, requiredBox, unreadableMovie } from "./movieBoxes.js";
+import { MEDIA_HEADER, MOVIE_HEADER, TRACK_HEADER_ID } from "./mp4Layouts.js";
+//#region ../../packages/core/src/domain/format/mp4/trackHeaders.ts
+var FOUR_CHARACTERS = 4;
+/**
+* Where the length size of each codec family's NAL units is kept, by its configuration box.
+*/
+var LENGTH_SIZE_OFFSETS = /* @__PURE__ */ new Map([[Mp4BoxType.AvcConfiguration, 4], [Mp4BoxType.HevcConfiguration, 21]]);
+/**
+* The timescale of the movie header, in which edit lists count.
+*/
+function movieTimescaleOf(movie) {
+	const header = fullBoxOf(requiredBox(movie, Mp4BoxType.MovieHeader));
+	return header.content.uint32BeAt(inVersion(header, MOVIE_HEADER, Mp4BoxType.MovieHeader).timescale);
+}
+function trackBoxesOf(trackBox) {
+	const track = boxesIn(trackBox.body);
+	const media = boxesIn(requiredBox(track, Mp4BoxType.Media).body);
+	const information = boxesIn(requiredBox(media, Mp4BoxType.MediaInformation).body);
+	return {
+		track,
+		media,
+		sampleTable: boxesIn(requiredBox(information, Mp4BoxType.SampleTable).body)
+	};
+}
+function trackHeadersOf(boxes) {
+	const handlerType = handlerTypeOf(boxes.media);
+	const entry = firstSampleEntryOf(boxes.sampleTable);
+	return {
+		trackId: trackIdOf(boxes.track),
+		handlerType,
+		mediaTimescale: mediaTimescaleOf(boxes.media),
+		sampleEntryType: entry.type,
+		nalLengthSize: handlerType === HandlerType.Video ? nalLengthSizeOf(entry) : void 0
+	};
+}
+/**
+* The layout of a box in its version; a version the standard does not define is refused.
+*/
+function inVersion(box, layouts, type) {
+	const layout = box.version === 0 || box.version === 1 ? layouts[box.version] : void 0;
+	if (layout === void 0) throw unreadableMovie(`has a ${type} box of version ${box.version}`);
+	return layout;
+}
+function trackIdOf(track) {
+	const header = fullBoxOf(requiredBox(track, Mp4BoxType.TrackHeader));
+	return header.content.uint32BeAt(inVersion(header, TRACK_HEADER_ID, Mp4BoxType.TrackHeader));
+}
+function mediaTimescaleOf(media) {
+	const header = fullBoxOf(requiredBox(media, Mp4BoxType.MediaHeader));
+	return header.content.uint32BeAt(inVersion(header, MEDIA_HEADER, Mp4BoxType.MediaHeader).timescale);
+}
+function handlerTypeOf(media) {
+	const { content } = fullBoxOf(requiredBox(media, Mp4BoxType.Handler));
+	return content.asciiAt(4, FOUR_CHARACTERS);
+}
+function firstSampleEntryOf(sampleTable) {
+	const { content } = fullBoxOf(requiredBox(sampleTable, Mp4BoxType.SampleDescription));
+	const entriesLength = content.length - 4;
+	const [entry] = boxesIn(content.bytesAt(4, entriesLength));
+	if (!entry) throw unreadableMovie("has a track without a sample entry");
+	return entry;
+}
+/**
+* The bytes before each NAL unit that give its length, from the codec configuration inside the
+* visual sample entry; undefined for a codec without one (the codec reader then refuses it).
+*/
+function nalLengthSizeOf(entry) {
+	const configuration = boxesIn(entry.body.subarray(78)).find((box) => LENGTH_SIZE_OFFSETS.has(box.type));
+	const byte = configuration?.body[LENGTH_SIZE_OFFSETS.get(configuration.type) ?? 0];
+	return byte === void 0 ? void 0 : (byte & 3) + 1;
+}
+//#endregion
+export { inVersion, movieTimescaleOf, trackBoxesOf, trackHeadersOf };

package/dist/packages/core/src/domain/view/lensTilesView.js

@@ -44,8 +44,8 @@ function magnifiedTiles(framing, context) {
 	}));
 }
 /**
-* The decoded images as the camera recorded them, magnified up to four times toward the pointer
-* and moved within their edges once zoomed; never turned or stitched.
+* The decoded images as the camera recorded them, magnified up to `MAX_MAGNIFICATION` toward the
+* pointer and moved within their edges once zoomed; never turned or stitched.
 */
 var LENS_TILES_VIEW = {
 	isStabilized: false,

package/dist/packages/core/src/domain/view/magnification.js

@@ -40,7 +40,7 @@ function magnifiedArea(fitted, magnification) {
 * keeps the picture centred along an axis where it is smaller.
 */
 function clampMagnification(fitted, magnification) {
-	const limited = clamp(magnification.scale, 1, 4);
+	const limited = clamp(magnification.scale, 1, 8);
 	const scale = limited - 1 < FITTED_TOLERANCE ? 1 : limited;
 	return {
 		scale,

package/dist/packages/core/src/domain/view/panoramaView.js

@@ -74,7 +74,7 @@ function zoomPanorama(framing, zoom, context) {
 }
 /**
 * Level, as an exported equirectangular video: the yaw picks the direction at the centre, and the
-* panorama magnifies up to four times and moves up and down within itself.
+* panorama magnifies up to `MAX_MAGNIFICATION` and moves up and down within itself.
 */
 var PANORAMA_VIEW = {
 	isStabilized: true,

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

@@ -21,6 +21,9 @@ import { timeRecording } from "./application/recording/timeRecording.js";
 import "./domain/format/naming/RecordingFileName.js";
 import { fileNameOfUrl } from "./shared/text/urlPath.js";
 import { locateOtherLensFile } from "./application/recording/locateOtherLensFile.js";
+import "./domain/container/SampleTable.js";
+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 { DEFAULT_STABILIZATION_MODE, STABILIZATION_MODES } from "./domain/motion/stabilization/Stabilizer.js";
@@ -47,6 +50,11 @@ import "./domain/stitching/seamDisparityField.js";
 import "./domain/stitching/seamJoin.js";
 import { keysOf } from "./shared/keysOf.js";
 import { Outbox } from "./shared/events/Outbox.js";
+import { Ending, ITERATION_END } from "./shared/async/iteration.js";
+import { SourceByteStream } from "./application/download/SourceByteStream.js";
+import { startFileDownload } from "./application/download/startFileDownload.js";
+import { downloadPolicyFor } from "./domain/download/DownloadPolicy.js";
+import { RecordingBuffer } from "./application/download/RecordingBuffer.js";
 import "./application/playback/FramePairQueue.js";
 import { Deferred } from "./shared/async/Deferred.js";
 import { RunStop, STOPPED } from "./shared/async/RunStop.js";
@@ -56,4 +64,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 { ByteRange, DEFAULT_FRAMING, DEFAULT_PICTURE_QUALITY, DEFAULT_STABILIZATION_MODE, DEFAULT_VIEW_MODE, Deferred, GYRO_VIEW_ERROR_CODES, GainMatchingFrameSink, GyroViewError, IDENTITY_MATRIX3, Outbox, PICTURE_QUALITIES, PlaybackSession, RunStop, SCREEN_CENTRE, STABILIZATION_MODES, STOPPED, StabilizingFrameSink, TypedEmitter, VIEW_MODES, WallClock, asGyroViewError, aspectOf, aspectOfArea, buildStitchingSetup, clamp, clampView, degrees, detectLensLayout, ensureIndexInRange, ensureInvariant, fileNameOfUrl, hasErrorCode, inspectRecording, isAbortError, isFlowing, isGyroViewErrorCode, isSameFraming, isSameView, keysOf, lazy, lensFrameOrder, locateOtherLensFile, lookAt, messageOf, microseconds, microsecondsToSeconds, milliseconds, pixelRatioCapOf, planeHalfExtentOf, probeDecoding, readRecording, seconds, secondsToMicroseconds, stabilizerFor, timeRecording, viewModeRulesFor, zoomStepsForPinch };
+export { ByteRange, DEFAULT_FRAMING, DEFAULT_PICTURE_QUALITY, DEFAULT_STABILIZATION_MODE, DEFAULT_VIEW_MODE, Deferred, Ending, GYRO_VIEW_ERROR_CODES, GainMatchingFrameSink, GyroViewError, IDENTITY_MATRIX3, ITERATION_END, Outbox, PICTURE_QUALITIES, PlaybackSession, RecordingBuffer, RunStop, SCREEN_CENTRE, STABILIZATION_MODES, STOPPED, SourceByteStream, StabilizingFrameSink, TypedEmitter, VIEW_MODES, WallClock, asGyroViewError, aspectOf, aspectOfArea, buildStitchingSetup, clamp, clampView, degrees, detectLensLayout, downloadPolicyFor, ensureIndexInRange, ensureInvariant, fileNameOfUrl, hasErrorCode, inspectRecording, isAbortError, isFlowing, isGyroViewErrorCode, isSameFraming, isSameView, keysOf, lazy, lensFrameOrder, locateOtherLensFile, lookAt, messageOf, microseconds, microsecondsToSeconds, milliseconds, pixelRatioCapOf, planeHalfExtentOf, probeDecoding, readRecording, readSampleTable, seconds, secondsToMicroseconds, stabilizerFor, startFileDownload, timeRecording, viewModeRulesFor, zoomStepsForPinch };

package/dist/packages/core/src/shared/async/iteration.js

@@ -0,0 +1,24 @@
+//#region ../../packages/core/src/shared/async/iteration.ts
+/**
+* What an iteration answers once it has ended.
+*/
+var ITERATION_END = {
+	done: true,
+	value: void 0
+};
+/**
+* Whether an iteration has ended, asked by a call after every wait: TypeScript takes a field read
+* before an `await` for the same value after it, though a `return()` may have ended the iteration
+* meanwhile.
+*/
+var Ending = class {
+	isEnded = false;
+	end() {
+		this.isEnded = true;
+	}
+	hasEnded() {
+		return this.isEnded;
+	}
+};
+//#endregion
+export { Ending, ITERATION_END };

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

@@ -26,6 +26,18 @@ var ByteRange = class ByteRange {
 		return this.offset + this.length;
 	}
 	/**
+	* Whether the two share a byte; an empty range shares none.
+	*/
+	overlaps(other) {
+		return Math.max(this.offset, other.offset) < Math.min(this.end, other.end);
+	}
+	/**
+	* Whether `other` lies wholly within this range.
+	*/
+	contains(other) {
+		return this.offset <= other.offset && other.end <= this.end;
+	}
+	/**
 	* Refuses a range that runs past the end of a `totalSize`-byte source with the error the
 	* `RandomAccessSource` contract asks for; `source` names the source in the message.
 	*/

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

@@ -0,0 +1,85 @@
+import { ByteRange } from "./ByteRange.js";
+//#region ../../packages/core/src/shared/binary/ByteRangeSet.ts
+/**
+* A set of bytes held as disjoint ranges in order, with overlapping and touching ones joined:
+* the bytes a download holds, has asked for, or still needs. Immutable; every operation answers
+* with a new set.
+*/
+var ByteRangeSet = class ByteRangeSet {
+	ranges;
+	static empty = new ByteRangeSet([]);
+	constructor(ranges) {
+		this.ranges = ranges;
+	}
+	static of(ranges) {
+		const ordered = ranges.filter((range) => range.length > 0).toSorted((left, right) => left.offset - right.offset);
+		return new ByteRangeSet(joined(ordered, 0));
+	}
+	get isEmpty() {
+		return this.ranges.length === 0;
+	}
+	get totalLength() {
+		return this.ranges.reduce((total, range) => total + range.length, 0);
+	}
+	union(other) {
+		return ByteRangeSet.of([...this.ranges, ...other.ranges]);
+	}
+	subtract(other) {
+		return new ByteRangeSet(this.ranges.flatMap((range) => withoutAny(range, other.ranges)));
+	}
+	/**
+	* Whether every byte of `range` is in the set; an empty range always is.
+	*/
+	covers(range) {
+		return range.length === 0 || this.ranges.some((held) => held.contains(range));
+	}
+	/**
+	* Whether any byte of `range` is in the set; an empty range never is.
+	*/
+	overlaps(range) {
+		return this.ranges.some((held) => held.overlaps(range));
+	}
+	/**
+	* The set with every gap between two of its ranges shorter than `length` filled: fetching a
+	* few unneeded bytes costs less than asking for the ranges on either side apart.
+	*/
+	bridgingGapsBelow(length) {
+		return new ByteRangeSet(joined(this.ranges, length));
+	}
+};
+/**
+* Ranges in order, each joined with the next when the gap between them is shorter than
+* `bridgedGap` (or when they overlap or touch, for a gap of zero).
+*/
+function joined(ordered, bridgedGap) {
+	const result = [];
+	for (const range of ordered) {
+		const last = result.at(-1);
+		const isJoined = last !== void 0 && range.offset - last.end < Math.max(bridgedGap, 1);
+		if (last && isJoined) result[result.length - 1] = spanning(last.offset, range.end, last.end);
+		else result.push(range);
+	}
+	return result;
+}
+/**
+* `range` with every byte of `holes` taken out, in pieces in order.
+*/
+function withoutAny(range, holes) {
+	const pieces = [];
+	let start = range.offset;
+	for (const hole of holes) {
+		if (hole.end <= start || hole.offset >= range.end) continue;
+		if (hole.offset > start) pieces.push(ByteRange.of(start, hole.offset - start));
+		start = Math.max(start, hole.end);
+	}
+	if (start < range.end) pieces.push(ByteRange.of(start, range.end - start));
+	return pieces;
+}
+/**
+* The range from `offset` to the further of two ends.
+*/
+function spanning(offset, end, otherEnd) {
+	return ByteRange.of(offset, Math.max(end, otherEnd) - offset);
+}
+//#endregion
+export { ByteRangeSet };

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

@@ -4,12 +4,15 @@ var UINT8_SIZE = 1;
 var UINT16_SIZE = 2;
 var UINT32_SIZE = 4;
 var UINT64_SIZE = 8;
+var INT32_SIZE = 4;
+var INT64_SIZE = 8;
 var FLOAT64_SIZE = 8;
 var IS_LITTLE_ENDIAN = true;
 var IS_BIG_ENDIAN = false;
 /**
-* Bounds-checked, little-endian reads over a byte array. Every read is positional, so callers
-* express the record layouts they parse as named offsets rather than as a moving cursor.
+* 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.
 */
 var ByteReader = class {
 	bytes;
@@ -38,6 +41,13 @@ var ByteReader = class {
 		return this.view.getUint32(offset, IS_BIG_ENDIAN);
 	}
 	/**
+	* A signed big-endian 32-bit integer, as edit lists and composition offsets store them.
+	*/
+	int32BeAt(offset) {
+		this.ensureAvailable(offset, INT32_SIZE);
+		return this.view.getInt32(offset, IS_BIG_ENDIAN);
+	}
+	/**
 	* Reads an unsigned 64-bit integer as a JavaScript number; rejects values beyond 2^53 - 1.
 	*/
 	uint64LeAt(offset) {
@@ -51,6 +61,14 @@ var ByteReader = class {
 		this.ensureAvailable(offset, UINT64_SIZE);
 		return this.toSafeNumber(this.view.getBigUint64(offset, IS_BIG_ENDIAN), offset);
 	}
+	/**
+	* A signed big-endian 64-bit integer (a version 1 edit list's media time) as a safe
+	* JavaScript number; rejects values beyond ±(2^53 - 1).
+	*/
+	int64BeAt(offset) {
+		this.ensureAvailable(offset, INT64_SIZE);
+		return this.toSafeNumber(this.view.getBigInt64(offset, IS_BIG_ENDIAN), offset);
+	}
 	float64LeAt(offset) {
 		this.ensureAvailable(offset, FLOAT64_SIZE);
 		return this.view.getFloat64(offset, IS_LITTLE_ENDIAN);
@@ -66,7 +84,7 @@ var ByteReader = class {
 		return Array.from(this.bytesAt(offset, length), (byte) => String.fromCodePoint(byte)).join("");
 	}
 	toSafeNumber(value, offset) {
-		if (value > BigInt(Number.MAX_SAFE_INTEGER)) throw new GyroViewError("binary-unsafe-integer", `uint64 at offset ${offset} (${value.toString()}) exceeds the safe integer range`);
+		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`);
 		return Number(value);
 	}
 	ensureAvailable(offset, length) {

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

@@ -0,0 +1,15 @@
+//#region ../../packages/core/src/shared/binary/concatenated.ts
+/**
+* The parts one after the other in a single array.
+*/
+function concatenated(parts) {
+	const whole = new Uint8Array(parts.reduce((total, part) => total + part.byteLength, 0));
+	let offset = 0;
+	for (const part of parts) {
+		whole.set(part, offset);
+		offset += part.byteLength;
+	}
+	return whole;
+}
+//#endregion
+export { concatenated };

package/dist/packages/core/src/shared/errors/GyroViewError.js

@@ -23,6 +23,7 @@ var GYRO_VIEW_ERROR_CODES = [
 	"playback-blocked",
 	"range-unsupported",
 	"render-unavailable",
+	"source-changed",
 	"source-truncated",
 	"source-unreadable",
 	"unsupported-calibration",

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

@@ -0,0 +1,17 @@
+//#region ../../packages/core/src/shared/math/countAtOrBelow.ts
+/**
+* How many of `count` values in ascending order, read through `valueAt`, are at or below
+* `target`: the index of the first value above it. Binary search, for long sorted columns.
+*/
+function countAtOrBelow(count, valueAt, target) {
+	let low = 0;
+	let high = count;
+	while (low < high) {
+		const middle = low + high >>> 1;
+		if (valueAt(middle) <= target) low = middle + 1;
+		else high = middle;
+	}
+	return low;
+}
+//#endregion
+export { countAtOrBelow };