@bubo-squared/gyroview 0.2.0 → 0.3.1

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

@@ -1,6 +1,6 @@
 //#region ../../packages/core/src/shared/errors/GyroViewError.ts
 /**
-* Stable machine-readable failure categories. Embedders switch on these; messages are for humans.
+* Stable machine-readable failure codes. Embedders switch on these; messages are for humans.
 */
 var GYRO_VIEW_ERROR_CODES = [
 	"binary-out-of-bounds",
@@ -23,23 +23,76 @@ var GYRO_VIEW_ERROR_CODES = [
 	"playback-blocked",
 	"range-unsupported",
 	"render-unavailable",
+	"source-changed",
 	"source-truncated",
 	"source-unreadable",
 	"unsupported-calibration",
 	"unsupported-container",
 	"unsupported-gyro-record",
 	"unsupported-info-format",
-	"unsupported-layout"
+	"unsupported-layout",
+	"webcodecs-unavailable"
 ];
+/**
+* Whose side a failure is on, for embedders that handle failures by kind: the browser cannot
+* decode or draw the recording, the file is not one the player can play, its bytes could not be
+* read, the page misused the API, or the player failed in a way it did not expect.
+*/
+var GYRO_VIEW_ERROR_CATEGORIES = [
+	"browser",
+	"recording",
+	"source",
+	"usage",
+	"internal"
+];
+/**
+* A record, so a new code cannot be added without its category.
+*/
+var CATEGORY_OF_CODE = {
+	"binary-out-of-bounds": "recording",
+	"binary-unsafe-integer": "recording",
+	"codec-unsupported": "browser",
+	cors: "source",
+	decode: "browser",
+	"embed-destroyed": "usage",
+	"index-out-of-range": "internal",
+	"invalid-argument": "usage",
+	"invalid-byte-range": "recording",
+	"invalid-calibration": "recording",
+	"invalid-protobuf": "recording",
+	"invalid-trailer": "recording",
+	"invariant-violation": "internal",
+	"missing-second-file": "recording",
+	"no-calibration": "recording",
+	"no-info-record": "recording",
+	"no-key-frame": "recording",
+	"playback-blocked": "browser",
+	"range-unsupported": "source",
+	"render-unavailable": "browser",
+	"source-changed": "source",
+	"source-truncated": "source",
+	"source-unreadable": "source",
+	"unsupported-calibration": "recording",
+	"unsupported-container": "recording",
+	"unsupported-gyro-record": "recording",
+	"unsupported-info-format": "recording",
+	"unsupported-layout": "recording",
+	"webcodecs-unavailable": "browser"
+};
 function isGyroViewErrorCode(value) {
 	return typeof value === "string" && GYRO_VIEW_ERROR_CODES.includes(value);
 }
 var GyroViewError = class extends Error {
 	code;
+	/**
+	* Its own property rather than a getter, so a serialized or logged copy of the error keeps it.
+	*/
+	category;
 	constructor(code, message, options) {
 		super(message, options);
 		this.code = code;
 		this.name = "GyroViewError";
+		this.category = CATEGORY_OF_CODE[code];
 	}
 };
 /**
@@ -78,4 +131,4 @@ function ensureIndexInRange(index, length, subject) {
 	if (!Number.isSafeInteger(index) || index < 0 || index >= length) throw new GyroViewError("index-out-of-range", `${subject} index ${index} is outside 0..${length - 1}`);
 }
 //#endregion
-export { GYRO_VIEW_ERROR_CODES, GyroViewError, asGyroViewError, ensureIndexInRange, ensureInvariant, hasErrorCode, isAbortError, isGyroViewErrorCode, messageOf };
+export { GYRO_VIEW_ERROR_CATEGORIES, GYRO_VIEW_ERROR_CODES, GyroViewError, asGyroViewError, ensureIndexInRange, ensureInvariant, hasErrorCode, isAbortError, isGyroViewErrorCode, messageOf };

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 };

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

@@ -1,11 +1,15 @@
+import { SourceByteStream } from "../../../core/src/application/download/SourceByteStream.js";
 import { Deferred } from "../../../core/src/shared/async/Deferred.js";
 import "../../../core/src/index.js";
 import { BlobRandomAccessSource } from "../../../adapters/blob/src/BlobRandomAccessSource.js";
 import "../../../adapters/blob/src/index.js";
+import { HttpByteStream } from "../../../adapters/fetch/src/HttpByteStream.js";
 import { HttpRangeSource } from "../../../adapters/fetch/src/HttpRangeSource.js";
+import { HttpResource } from "../../../adapters/fetch/src/HttpResource.js";
 import { HttpResourceLocator } from "../../../adapters/fetch/src/HttpResourceLocator.js";
 import "../../../adapters/fetch/src/index.js";
-import { MediabunnyDemuxer } from "../../../adapters/mediabunny/src/MediabunnyDemuxer.js";
+import { MediabunnyCodecReader } from "../../../adapters/mediabunny/src/MediabunnyCodecReader.js";
+import { MediabunnyAudioPackager } from "../../../adapters/mediabunny/src/MediabunnyAudioPackager.js";
 import "../../../adapters/mediabunny/src/index.js";
 import { WebCodecsVideoDecoderPort } from "../../../adapters/webcodecs/src/WebCodecsVideoDecoderPort.js";
 import "../../../adapters/webcodecs/src/index.js";
@@ -20,17 +24,32 @@ function browserPorts(options = {}) {
 	const probeTimeoutMs = options.probeTimeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS;
 	return {
 		sources: browserSources(http),
-		demuxer: new MediabunnyDemuxer(),
+		codecReader: new MediabunnyCodecReader(),
+		audioPackager: new MediabunnyAudioPackager(),
 		decoderPort: new WebCodecsVideoDecoderPort(),
 		locatorFor: (input) => new HttpResourceLocator(requestOptionsFor(http, input)),
 		probeDeadline: () => deadlineIn(probeTimeoutMs)
 	};
 }
 /**
-* URLs are read with HTTP ranges, blobs by slicing.
+* URLs are read with HTTP ranges, both ways over one resource; blobs by slicing, a range whole.
 */
 function browserSources(http) {
-	return { open: (input, signal) => isUrlInput(input) ? new HttpRangeSource(input.url, requestOptionsFor(http, input), signal) : new BlobRandomAccessSource(input.blob) };
+	return { open: (input, signal) => isUrlInput(input) ? urlSource(input, http, signal) : blobSource(input) };
+}
+function urlSource(input, http, signal) {
+	const resource = new HttpResource(input.url, requestOptionsFor(http, input), signal);
+	return {
+		source: new HttpRangeSource(resource),
+		stream: new HttpByteStream(resource)
+	};
+}
+function blobSource(input) {
+	const source = new BlobRandomAccessSource(input.blob);
+	return {
+		source,
+		stream: new SourceByteStream(source)
+	};
 }
 /**
 * The shared request settings, with the input's own credentials in place of theirs when it names

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

@@ -5,6 +5,7 @@ import { buildStitchingSetup } from "../../../core/src/domain/stitching/Stitchin
 import { StabilizingFrameSink } from "../../../core/src/application/stabilization/StabilizingFrameSink.js";
 import { GainMatchingFrameSink } from "../../../core/src/application/gainMatching/GainMatchingFrameSink.js";
 import { WallClock } from "../../../core/src/application/playback/WallClock.js";
+import { isFlowing } from "../../../core/src/domain/playback/PlayerState.js";
 import { PlaybackSession } from "../../../core/src/application/playback/PlaybackSession.js";
 import "../../../core/src/index.js";
 import { MediaSourceAudioClock } from "../../../adapters/mse-audio/src/MediaSourceAudioClock.js";
@@ -37,6 +38,7 @@ async function buildPipeline(parts) {
 		disposables.add(() => {
 			session.dispose();
 		});
+		readAheadOnceFlowing(session, parts.opened);
 		return {
 			session,
 			renderer: drawing.renderer,
@@ -94,10 +96,10 @@ function pictureSettingsOf(drawing, session) {
 * otherwise a wall clock, with a warning saying why there is no sound.
 */
 async function clockFor(parts) {
-	const { audioTrack } = parts.opened;
-	if (!audioTrack) return wallClock(NO_AUDIO_WARNING);
+	const { soundSegments } = parts.opened;
+	if (!soundSegments) return wallClock(NO_AUDIO_WARNING);
 	try {
-		const segments = await audioTrack.openSegments();
+		const segments = soundSegments();
 		if (!MediaSourceAudioClock.isSupported(segments)) return wallClock(AUDIO_UNSUPPORTED_WARNING);
 		parts.signal.throwIfAborted();
 		return {
@@ -138,6 +140,15 @@ function sinkOver(renderer, opened) {
 		stabilizing
 	};
 }
+/**
+* The downloads read only what the picture waits for until playing first starts, so a page of
+* players that were never played stays quiet; from then on they read ahead, paused or not.
+*/
+function readAheadOnceFlowing(session, opened) {
+	session.events.on("statechange", (state) => {
+		if (isFlowing(state)) opened.readAhead();
+	});
+}
 function sessionFor(parts, clock, sink) {
 	return new PlaybackSession({
 		frameSources: parts.opened.frameSources,
@@ -145,6 +156,7 @@ function sessionFor(parts, clock, sink) {
 		clock,
 		sink,
 		duration: parts.opened.duration,
+		buffer: parts.opened.buffer,
 		pipeline: DECODE_PIPELINE_OPTIONS,
 		queueCapacity: 4
 	});

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

@@ -1,130 +1,70 @@
-import { GyroViewError, ensureInvariant, hasErrorCode } from "../../../core/src/shared/errors/GyroViewError.js";
+import { GyroViewError, ensureInvariant } from "../../../core/src/shared/errors/GyroViewError.js";
 import { seconds } from "../../../core/src/shared/units/time.js";
-import { readRecording } from "../../../core/src/application/recording/readRecording.js";
 import { timeRecording } from "../../../core/src/application/recording/timeRecording.js";
 import { detectLensLayout } from "../../../core/src/domain/format/layout/detectLensLayout.js";
 import { lensFrameOrder } from "../../../core/src/domain/stitching/StitchingSetup.js";
+import { startFileDownload } from "../../../core/src/application/download/startFileDownload.js";
+import { downloadPolicyFor } from "../../../core/src/domain/download/DownloadPolicy.js";
+import { RecordingBuffer } from "../../../core/src/application/download/RecordingBuffer.js";
 import "../../../core/src/index.js";
-import { inputName } from "../PlayerSource.js";
 import { Disposables } from "./Disposables.js";
 import { ensureDecodable } from "./ensureDecodable.js";
+import { describedInput, readInputs } from "./readInputs.js";
 //#region ../../packages/player/src/composition/openInputs.ts
 /**
-* Opens the given inputs as one recording, its metadata from the input that carries the
-* trailer. Everything opened is released again when any step fails or the attempt is aborted.
+* Opens the given inputs as one recording (ADR 0029): their sample tables and codecs read, the
+* lens layout and calibration decided, then one download a file, which the decode probe reads
+* through first. Everything opened is released again when any step fails or the attempt is
+* aborted.
 */
 async function openInputs(inputs, attempt) {
 	const disposables = new Disposables();
 	try {
-		const demuxed = await demuxInputs(inputs, attempt, disposables);
-		const layout = detectLensLayout(demuxed.inputs, demuxed.recording.info);
-		const frameSources = lensFrameOrder(layout).map((key) => trackAt(demuxed.inputs, key));
-		const calibration = calibrationOf(demuxed.recording);
+		const read = await readInputs(inputs, attempt);
+		const described = read.inputs.map((input) => describedInput(input));
+		const layout = detectLensLayout(described, read.recording.info);
+		const calibration = calibrationOf(read.recording);
+		const files = startDownloads(read.inputs, disposables);
+		const frameSources = lensFrameOrder(layout).map((key) => trackAt(files, key));
 		await ensureDecodable(frameSources, attempt);
-		const timing = await timeRecording(demuxed.recording, frameSources[0]);
+		const timing = await timeRecording(read.recording, frameSources[0]);
 		attempt.signal.throwIfAborted();
 		return assemble({
-			demuxed,
+			read,
+			files,
 			layout,
 			frameSources,
 			calibration,
 			timing
-		}, disposables);
+		}, attempt.ports.audioPackager, disposables);
 	} catch (error) {
 		disposables.disposeAll();
 		throw error;
 	}
 }
-async function demuxInputs(inputs, attempt, disposables) {
-	const { ports, signal } = attempt;
-	const given = inputs.map((input) => ({
-		input,
-		source: ports.sources.open(input, signal)
-	}));
-	const recording = await readRecordingOf(given, ports);
-	signal.throwIfAborted();
-	const openings = [...given, ...await declaredSecond(given, recording, attempt)];
-	const settled = await Promise.allSettled(openings.map(({ input, source }) => ports.demuxer.open(source, inputName(input))));
-	const opened = settled.flatMap((result) => result.status === "fulfilled" ? [result.value] : []);
-	for (const input of opened) disposables.add(() => {
-		input.dispose();
-	});
-	const failure = settled.find((result) => result.status === "rejected");
-	if (failure) throw failure.reason;
-	signal.throwIfAborted();
-	return {
-		recording,
-		inputs: opened
-	};
-}
-/**
-* The other lens file a lone file's info record says the recording is split into, when the
-* server has it: found before the lone file's tracks are read, which finding it only once they
-* fell short would read twice. A file that does not say so still gets its sibling looked for
-* once its tracks fall short (see openRecording).
-*/
-async function declaredSecond(given, recording, attempt) {
-	if (!(given.length === 1 && recording.info.fileLayout === "split-files") || !attempt.findSecondFile) return [];
-	const input = await attempt.findSecondFile();
-	attempt.signal.throwIfAborted();
-	return input === void 0 ? [] : [{
-		input,
-		source: attempt.ports.sources.open(input, attempt.signal)
-	}];
-}
-/**
-* The layout hints of a file without an info record: the tracks alone decide.
-*/
-var NO_HINTS = {
-	fileLayout: void 0,
-	trackOrder: void 0
-};
-async function readRecordingOf(openings, ports) {
-	try {
-		return await readTrailerCarrier(openings.map(({ source }) => source));
-	} catch (error) {
-		const [only] = openings;
-		if (openings.length === 1 && hasErrorCode(error, "invalid-trailer") && only) await refuseAsLoneHalf(only, ports);
-		throw error;
-	}
-}
 /**
-* A file without a trailer may be the _10_ half of an older camera's pair, which writes the
-* trailer to _00_ alone: its one square track tells, and the refusal asks for the other file
-* instead of calling it damaged. Anything else leaves the trailer's own refusal standing.
+* One download a file, each with its share of the budget.
 */
-async function refuseAsLoneHalf(opening, ports) {
-	let input;
-	try {
-		input = await ports.demuxer.open(opening.source, inputName(opening.input));
-	} catch {
-		return;
-	}
-	try {
-		detectLensLayout([input], NO_HINTS);
-	} catch (error) {
-		if (hasErrorCode(error, "missing-second-file")) throw error;
-	} finally {
-		input.dispose();
-	}
-}
-/**
-* The recording read from the input that carries the trailer: the first, or the second when the
-* first has none, as the _10_ file of an older camera's pair, which writes it to _00_ alone,
-* when the pair is given the other way round.
-*/
-async function readTrailerCarrier(sources) {
-	const [first, second] = sources;
-	ensureInvariant(first !== void 0, "a recording needs at least one input");
-	try {
-		return await readRecording(first);
-	} catch (error) {
-		if (second === void 0 || !hasErrorCode(error, "invalid-trailer")) throw error;
-		return readRecording(second);
-	}
+function startDownloads(inputs, disposables) {
+	return inputs.map(({ opened, table, codecs, size }) => {
+		const policy = downloadPolicyFor({
+			size,
+			duration: table.duration
+		}, inputs.length);
+		const file = startFileDownload({
+			table,
+			stream: opened.stream,
+			codecs,
+			policy
+		});
+		disposables.add(() => {
+			file.dispose();
+		});
+		return file;
+	});
 }
-function trackAt(inputs, key) {
-	const track = inputs[key.inputIndex]?.videoTracks[key.trackIndex];
+function trackAt(files, key) {
+	const track = files[key.inputIndex]?.videoTracks[key.trackIndex];
 	ensureInvariant(track !== void 0, `the layout points at track ${key.trackIndex} of input ${key.inputIndex}, which does not exist`);
 	return track;
 }
@@ -134,26 +74,30 @@ function calibrationOf(recording) {
 	const detail = warnings.length > 0 ? ` (${warnings.join("; ")})` : "";
 	throw new GyroViewError("no-calibration", `the recording carries no usable lens calibration, so it cannot be stitched${detail}`);
 }
-function assemble(parts, disposables) {
-	const { demuxed, layout, frameSources, calibration, timing } = parts;
-	const duration = seconds(Math.min(...demuxed.inputs.map((input) => input.duration)));
-	const [audioTrack] = demuxed.inputs.flatMap((input) => input.audioTracks);
+function assemble(parts, packager, disposables) {
+	const { read, files, layout, frameSources, calibration, timing } = parts;
+	const duration = seconds(Math.min(...files.map((file) => file.duration)));
+	const [sound] = files.flatMap((file) => file.audioTracks);
 	return {
-		recording: demuxed.recording,
+		recording: read.recording,
 		layout,
 		frameSources,
 		calibration,
 		duration,
 		frameTimes: timing.frameTimes,
 		motion: timing.motion,
-		audioTrack,
-		metadata: metadataOf(parts, duration, audioTrack !== void 0),
+		soundSegments: sound && (() => packager.segmentsOf(sound.samples, sound.configuration)),
+		metadata: metadataOf(parts, duration, sound !== void 0),
 		warnings: timing.warnings,
+		readAhead: () => {
+			for (const file of files) file.download.startReadingAhead();
+		},
+		buffer: new RecordingBuffer(files.map((file) => file.download)),
 		dispose: disposables.toDisposer()
 	};
 }
 function metadataOf(parts, duration, hasAudio) {
-	const { info } = parts.demuxed.recording;
+	const { info } = parts.read.recording;
 	const { motion } = parts.timing;
 	return {
 		model: info.model,