@bubo-squared/gyroview 0.2.0 → 0.3.0

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,

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

@@ -0,0 +1,111 @@
+import { ensureInvariant, hasErrorCode } from "../../../core/src/shared/errors/GyroViewError.js";
+import { readRecording } from "../../../core/src/application/recording/readRecording.js";
+import { readSampleTable } from "../../../core/src/application/recording/readSampleTable.js";
+import { detectLensLayout } from "../../../core/src/domain/format/layout/detectLensLayout.js";
+import "../../../core/src/index.js";
+import { inputName } from "../PlayerSource.js";
+//#region ../../packages/player/src/composition/readInputs.ts
+/**
+* Reads the given inputs, and the other lens file an info record declares, as one recording: its
+* metadata from the input that carries the trailer, and every input's sample table and codecs.
+*/
+async function readInputs(inputs, attempt) {
+	const { ports, signal } = attempt;
+	const given = inputs.map((input) => ({
+		input,
+		opened: ports.sources.open(input, signal)
+	}));
+	const recording = await readRecordingOf(given, ports);
+	signal.throwIfAborted();
+	const openings = [...given, ...await declaredSecond(given, recording, attempt)];
+	const read = await Promise.all(openings.map((opening) => readInput(opening, ports)));
+	signal.throwIfAborted();
+	return {
+		recording,
+		inputs: read
+	};
+}
+function describedInput(read) {
+	const videoTracks = read.codecs.video.map(({ description }) => ({ description }));
+	return {
+		name: inputName(read.input),
+		videoTracks
+	};
+}
+async function readInput(opening, ports) {
+	const { source } = opening.opened;
+	const { table, movieBytes } = await readSampleTable(source);
+	const codecs = await ports.codecReader.read(movieBytes);
+	return {
+		...opening,
+		table,
+		codecs,
+		size: await source.size()
+	};
+}
+/**
+* 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,
+		opened: 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(({ opened }) => opened.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.
+*/
+async function refuseAsLoneHalf(opening, ports) {
+	let read;
+	try {
+		read = await readInput(opening, ports);
+	} catch {
+		return;
+	}
+	try {
+		detectLensLayout([describedInput(read)], NO_HINTS);
+	} catch (error) {
+		if (hasErrorCode(error, "missing-second-file")) throw error;
+	}
+}
+/**
+* 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);
+	}
+}
+//#endregion
+export { describedInput, readInputs };

package/dist/packages/player/src/controls/messages.js

@@ -71,6 +71,7 @@ var DEFAULT_MESSAGES = {
 		"playback-blocked": FAILED,
 		"range-unsupported": UNREACHABLE,
 		"render-unavailable": UNSUPPORTED_BROWSER,
+		"source-changed": "The video was replaced while it played.",
 		"source-truncated": UNREACHABLE,
 		"source-unreadable": UNREACHABLE,
 		"unsupported-calibration": UNREADABLE,

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

@@ -9,7 +9,7 @@ import { browserSources } from "./composition/browserPorts.js";
 */
 function inspectRecording(recording, options = {}) {
 	const signal = options.signal ?? new AbortController().signal;
-	const source = browserSources(options.http ?? {}).open(inputOf(recording), signal);
+	const { source } = browserSources(options.http ?? {}).open(inputOf(recording), signal);
 	return inspectRecording$1(source);
 }
 function inputOf(recording) {