@bubo-squared/gyroview 0.2.0 → 0.3.1

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,13 +71,15 @@ 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,
 		"unsupported-container": UNREADABLE,
 		"unsupported-gyro-record": UNREADABLE,
 		"unsupported-info-format": UNREADABLE,
-		"unsupported-layout": UNREADABLE
+		"unsupported-layout": UNREADABLE,
+		"webcodecs-unavailable": UNSUPPORTED_BROWSER
 	}
 };
 /**

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) {