@bubo-squared/gyroview 0.2.0 → 0.3.1

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

@@ -0,0 +1,183 @@
+//#region ../../packages/core/src/domain/format/mp4/mp4Layouts.ts
+/**
+* MovieHeaderBox, `mvhd` (§8.2.2): creation and modification times, the movie timescale (in which
+* edit lists count), the duration, then fields the player does not read.
+*/
+var MOVIE_HEADER = {
+	0: {
+		timescale: 8,
+		duration: {
+			offset: 12,
+			kind: "uint32"
+		},
+		size: 96
+	},
+	1: {
+		timescale: 16,
+		duration: {
+			offset: 20,
+			kind: "uint64"
+		},
+		size: 108
+	}
+};
+/**
+* TrackHeaderBox, `tkhd` (§8.3.2): the track's id sits after the creation and modification times.
+*/
+var TRACK_HEADER_ID = {
+	0: 8,
+	1: 16
+};
+/**
+* MediaHeaderBox, `mdhd` (§8.4.2): the timescale the track's sample tables count in.
+*/
+var MEDIA_HEADER = {
+	0: {
+		timescale: 8,
+		duration: {
+			offset: 12,
+			kind: "uint32"
+		},
+		size: 20
+	},
+	1: {
+		timescale: 16,
+		duration: {
+			offset: 20,
+			kind: "uint64"
+		},
+		size: 32
+	}
+};
+/**
+* TimeToSampleBox, `stts` (§8.6.1.2): runs of samples with the same decode duration.
+*/
+var TIME_TO_SAMPLE = {
+	entrySize: 8,
+	fields: {
+		sampleCount: {
+			offset: 0,
+			kind: "uint32"
+		},
+		sampleDelta: {
+			offset: 4,
+			kind: "uint32"
+		}
+	}
+};
+/**
+* CompositionOffsetBox, `ctts` (§8.6.1.3): runs of samples presented the same time after (and in
+* version 1, possibly before) they are decoded. Version 0 is unsigned by the standard, but
+* writers put negative offsets there too, so both versions are read signed, as mediabunny and
+* FFmpeg read them.
+*/
+var COMPOSITION_OFFSET = {
+	entrySize: 8,
+	fields: {
+		sampleCount: {
+			offset: 0,
+			kind: "uint32"
+		},
+		sampleOffset: {
+			offset: 4,
+			kind: "int32"
+		}
+	}
+};
+/**
+* SyncSampleBox, `stss` (§8.6.2): the 1-based numbers of the samples decoding may start at. A
+* track without one starts anywhere.
+*/
+var SYNC_SAMPLE = {
+	entrySize: 4,
+	fields: { sampleNumber: {
+		offset: 0,
+		kind: "uint32"
+	} }
+};
+/**
+* EditListBox, `elst` (§8.6.6): segments of the movie timeline, each showing the media from
+* `mediaTime` (media timescale) for `segmentDuration` (movie timescale), or nothing where
+* `mediaTime` is -1.
+*/
+var EDIT_LIST = {
+	0: {
+		entrySize: 12,
+		fields: {
+			segmentDuration: {
+				offset: 0,
+				kind: "uint32"
+			},
+			mediaTime: {
+				offset: 4,
+				kind: "int32"
+			},
+			mediaRate: {
+				offset: 8,
+				kind: "uint32"
+			}
+		}
+	},
+	1: {
+		entrySize: 20,
+		fields: {
+			segmentDuration: {
+				offset: 0,
+				kind: "uint64"
+			},
+			mediaTime: {
+				offset: 8,
+				kind: "int64"
+			},
+			mediaRate: {
+				offset: 16,
+				kind: "uint32"
+			}
+		}
+	}
+};
+/**
+* An edit's media rate is 16.16 fixed point; 1 plays the media at its own pace.
+*/
+var UNIT_MEDIA_RATE = 65536;
+/**
+* SampleToChunkBox, `stsc` (§8.7.4): from each 1-based first chunk on, how many samples a chunk
+* holds, until the next entry's first chunk.
+*/
+var SAMPLE_TO_CHUNK = {
+	entrySize: 12,
+	fields: {
+		firstChunk: {
+			offset: 0,
+			kind: "uint32"
+		},
+		samplesPerChunk: {
+			offset: 4,
+			kind: "uint32"
+		},
+		sampleDescriptionIndex: {
+			offset: 8,
+			kind: "uint32"
+		}
+	}
+};
+/**
+* ChunkOffsetBox, `stco`, and ChunkLargeOffsetBox, `co64` (§8.7.5): where each chunk starts in the
+* file, in 32 or 64 bits.
+*/
+var CHUNK_OFFSET = {
+	entrySize: 4,
+	fields: { chunkOffset: {
+		offset: 0,
+		kind: "uint32"
+	} }
+};
+var CHUNK_LARGE_OFFSET = {
+	entrySize: 8,
+	fields: { chunkOffset: {
+		offset: 0,
+		kind: "uint64"
+	} }
+};
+//#endregion
+export { CHUNK_LARGE_OFFSET, CHUNK_OFFSET, COMPOSITION_OFFSET, EDIT_LIST, MEDIA_HEADER, MOVIE_HEADER, SAMPLE_TO_CHUNK, SYNC_SAMPLE, TIME_TO_SAMPLE, TRACK_HEADER_ID, UNIT_MEDIA_RATE };

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

@@ -1,7 +1,7 @@
 import { degrees } from "./shared/units/angle.js";
 import "./domain/optics/EquidistantModel.js";
 import "./domain/format/calibration/CalibrationVersion.js";
-import { GYRO_VIEW_ERROR_CODES, GyroViewError, asGyroViewError, ensureIndexInRange, ensureInvariant, hasErrorCode, isAbortError, isGyroViewErrorCode, messageOf } from "./shared/errors/GyroViewError.js";
+import { GYRO_VIEW_ERROR_CATEGORIES, GYRO_VIEW_ERROR_CODES, GyroViewError, asGyroViewError, ensureIndexInRange, ensureInvariant, hasErrorCode, isAbortError, isGyroViewErrorCode, messageOf } from "./shared/errors/GyroViewError.js";
 import { lazy } from "./shared/lazy.js";
 import { microseconds, microsecondsToSeconds, milliseconds, seconds, secondsToMicroseconds } from "./shared/units/time.js";
 import "./domain/motion/exposure/ExposureRecord.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_CATEGORIES, 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.
 	*/