@octane-xplat/camera 0.13.0 → 0.14.0

package/dist/linux/session-backend.linux.js

@@ -0,0 +1,479 @@
+import { CameraCaptureError } from "./types.js";
+import { cameraHost, commitHostMovie, openHostMovie, removeHostReservation, reserveHostMovie } from "./host-movie.web.js";
+import { inspectMovie } from "./movie-metadata.web.js";
+//#region src/session-backend.linux.ts
+var mimeCandidates = [
+	"video/webm;codecs=vp8,opus",
+	"video/webm;codecs=vp9,opus",
+	"video/mp4;codecs=avc1.424028,mp4a.40.2",
+	"video/mp4"
+];
+var owner;
+var error = (kind, operation, message, cause) => new CameraCaptureError({
+	kind,
+	operation,
+	message,
+	cause
+});
+var policyAllows = (kind) => {
+	return (document.permissionsPolicy ?? document.featurePolicy)?.allowsFeature(kind) !== false;
+};
+function createSessionBackend(config) {
+	let currentConfig = { ...config };
+	let observer;
+	let host;
+	let listener;
+	let stream;
+	let ready = false;
+	let released = false;
+	let generation = 0;
+	let recorder;
+	let sink;
+	let startedAt = 0;
+	let stoppedAt = 0;
+	let stopTimer;
+	let watchdog;
+	let recordingAudio = false;
+	let captureFailure;
+	let hostState = "unknown";
+	const hostProbe = cameraHost().then((host) => {
+		hostState = host ? "available" : "absent";
+		return host;
+	});
+	const lease = {};
+	const known = {
+		camera: "unknown",
+		microphone: "unknown"
+	};
+	const supported = () => typeof navigator !== "undefined" && globalThis.isSecureContext === true && !!navigator.mediaDevices?.getUserMedia && typeof MediaRecorder !== "undefined" && !!mimeType() && hostState === "available";
+	const mimeType = () => typeof MediaRecorder === "undefined" ? "" : mimeCandidates.find((mime) => MediaRecorder.isTypeSupported(mime)) ?? "";
+	const markReady = (value) => {
+		ready = value;
+		observer?.previewReady(value);
+	};
+	const dropStream = () => {
+		if (host) host.srcObject = null;
+		stream?.getTracks().forEach((track) => track.stop());
+		stream = void 0;
+		markReady(false);
+		if (owner === lease) owner = void 0;
+	};
+	const onVisibility = () => {
+		if (document.visibilityState === "hidden") {
+			markReady(false);
+			observer?.interruption("began", "background");
+		} else {
+			observer?.interruption("ended", "background");
+			markReady(!!host && stream?.getVideoTracks()[0]?.readyState === "live");
+		}
+	};
+	const onPageHide = () => {
+		markReady(false);
+		observer?.interruption("began", "background");
+	};
+	const observeTracks = (target) => {
+		for (const track of target.getTracks()) {
+			track.addEventListener("ended", () => {
+				if (track.kind === "audio" && (!sink || !recordingAudio)) return;
+				if (stream !== target) return;
+				markReady(false);
+				observer?.availability(false);
+				observer?.interruption("began", "unknown");
+			});
+			track.addEventListener("mute", () => {
+				if (track.kind === "audio" && (!sink || !recordingAudio)) return;
+				if (stream === target) {
+					markReady(false);
+					observer?.interruption("began", "unknown");
+				}
+			});
+			track.addEventListener("unmute", () => {
+				if (stream === target && document.visibilityState !== "hidden") {
+					observer?.interruption("ended", "unknown");
+					observer?.availability(true);
+					markReady(!!host);
+				}
+			});
+		}
+	};
+	const constraints = () => {
+		const camera = currentConfig.camera;
+		return {
+			width: { ideal: 1280 },
+			height: { ideal: 720 },
+			frameRate: { ideal: 30 },
+			...typeof camera === "object" ? { deviceId: { exact: camera.deviceId } } : camera === "front" || camera === "back" ? { facingMode: { exact: camera === "front" ? "user" : "environment" } } : {}
+		};
+	};
+	let acquisition;
+	const acquireCameraOnce = async () => {
+		if (stream?.getVideoTracks()[0]?.readyState === "live") return;
+		if (owner && owner !== lease) throw error("busy", "preview", "Another camera session still owns the source");
+		owner = lease;
+		const epoch = generation;
+		try {
+			const acquired = await navigator.mediaDevices.getUserMedia({
+				video: constraints(),
+				audio: false
+			});
+			if (released || epoch !== generation) {
+				acquired.getTracks().forEach((track) => track.stop());
+				if (!stream && owner === lease) owner = void 0;
+				return;
+			}
+			stream = acquired;
+			known.camera = "granted";
+			observeTracks(acquired);
+			observer?.availability(true);
+		} catch (cause) {
+			if (owner === lease) owner = void 0;
+			throw cause;
+		}
+	};
+	const acquireCamera = () => {
+		acquisition ??= acquireCameraOnce().finally(() => {
+			acquisition = void 0;
+		});
+		return acquisition;
+	};
+	const acquireCombined = async () => {
+		const epoch = generation;
+		const acquired = await navigator.mediaDevices.getUserMedia({
+			video: constraints(),
+			audio: true
+		});
+		if (released || epoch !== generation) {
+			acquired.getTracks().forEach((track) => track.stop());
+			return;
+		}
+		const previous = stream;
+		stream = acquired;
+		previous?.getTracks().forEach((track) => track.stop());
+		observeTracks(acquired);
+		observer?.availability(true);
+	};
+	const ensureAudio = async () => {
+		if (stream?.getAudioTracks().some((track) => track.readyState === "live")) return;
+		if (stream) {
+			await acquireCombined();
+			if (host) await showPreview();
+			return;
+		}
+		(await navigator.mediaDevices.getUserMedia({
+			audio: true,
+			video: false
+		})).getTracks().forEach((track) => track.stop());
+	};
+	const showPreview = async () => {
+		if (!host || released) return;
+		const element = host;
+		const epoch = generation;
+		if (await checkPermission("camera") !== "granted") {
+			listener?.onError?.(error("permissionBlocked", "preview", "Request camera access from a user action before activating this preview"));
+			return;
+		}
+		await acquireCamera();
+		if (host !== element || !stream || released || epoch !== generation) return;
+		element.srcObject = stream;
+		element.muted = true;
+		const facing = stream.getVideoTracks()[0]?.getSettings().facingMode;
+		element.style.transform = facing === "user" ? "scaleX(-1)" : "";
+		await element.play();
+		if (host !== element || released || epoch !== generation) return;
+		markReady(document.visibilityState !== "hidden");
+		listener?.onReady?.();
+	};
+	const hostMediaKind = (kind) => kind === "microphone" ? "microphone" : "camera";
+	async function checkPermission(kind) {
+		if (globalThis.isSecureContext !== true || !navigator.mediaDevices?.getUserMedia) return "unavailable";
+		if (!policyAllows(kind)) return "blocked";
+		const desktop = await hostProbe;
+		if (!desktop) return "unavailable";
+		try {
+			const { status } = await desktop.call("camera", "permissionStatus", { kind: hostMediaKind(kind) });
+			if (status === "granted" || status === "notDetermined") return status;
+			if (status === "restricted") return "restricted";
+			if (status === "denied" || status === "blocked") return "denied";
+			return "unknown";
+		} catch {
+			return "unknown";
+		}
+	}
+	const settle = (value, expected = sink) => {
+		const target = sink;
+		if (!target || target !== expected) return;
+		sink = void 0;
+		recorder = void 0;
+		captureFailure = void 0;
+		clearTimeout(stopTimer);
+		clearTimeout(watchdog);
+		if (!host) dropStream();
+		target.settled(value);
+	};
+	const stop = () => {
+		if (!recorder || !sink) return;
+		stoppedAt ||= performance.now();
+		clearTimeout(watchdog);
+		const target = sink;
+		const fail = captureFailure;
+		watchdog = setTimeout(() => {
+			if (sink !== target) return;
+			dropStream();
+			fail?.(error("finalizationFailed", "stop", "Recorder finalization callback timed out"));
+		}, 3e4);
+		if (recorder.state === "inactive") return;
+		try {
+			recorder.stop();
+		} catch (cause) {
+			fail?.(error("captureFailed", "stop", "The recorder could not stop", cause));
+		}
+	};
+	return {
+		platform: "web",
+		get supported() {
+			return supported();
+		},
+		checkPermission,
+		requestPermission: async (kind) => {
+			const status = await checkPermission(kind);
+			if (status === "blocked" || status === "unavailable") return status;
+			const desktop = await hostProbe;
+			if (!desktop) return "unavailable";
+			const { status: hostStatus } = await desktop.call("camera", "requestPermission", { kind: hostMediaKind(kind) });
+			if (hostStatus !== "granted") {
+				known[kind] = hostStatus === "denied" || hostStatus === "blocked" ? "denied" : hostStatus === "restricted" ? "restricted" : "unknown";
+				return known[kind];
+			}
+			try {
+				if (kind === "camera") await acquireCamera();
+				else if (sink) (await navigator.mediaDevices.getUserMedia({
+					audio: true,
+					video: false
+				})).getTracks().forEach((track) => track.stop());
+				else await ensureAudio();
+				known[kind] = "granted";
+				if (kind === "camera" && host) await showPreview();
+				return "granted";
+			} catch (cause) {
+				known[kind] = cause instanceof DOMException && (cause.name === "NotAllowedError" || cause.name === "SecurityError") ? "blocked" : "unavailable";
+				return known[kind];
+			}
+		},
+		getCapabilities: async () => {
+			const desktop = await hostProbe;
+			const devices = await navigator.mediaDevices?.enumerateDevices?.().catch(() => []) ?? [];
+			const settings = stream?.getVideoTracks()[0]?.getSettings();
+			const mime = mimeType();
+			const storageReady = !!desktop;
+			return {
+				supported: supported(),
+				available: ready && storageReady,
+				reason: !supported() ? "Secure media capture, a supported WebM/MP4 codec, and the packaged Linux host are required" : !storageReady ? "Movie output requires the packaged Linux WebKitGTK host" : !ready ? "An active permitted preview is required" : void 0,
+				cameras: devices.filter((device) => device.kind === "videoinput").map((device) => ({
+					id: device.deviceId,
+					label: device.label
+				})),
+				profiles: settings?.width && settings.height && settings.frameRate ? [{
+					profile: "standard",
+					width: settings.width,
+					height: settings.height,
+					frameRate: settings.frameRate
+				}] : [],
+				audio: devices.some((device) => device.kind === "audioinput"),
+				orientations: [],
+				durationLimit: "bestEffort",
+				elapsedTime: "estimated",
+				output: {
+					mimeType: mime,
+					container: !mime ? "" : mime.startsWith("video/mp4") ? "mp4" : "webm",
+					storage: desktop ? "appPrivateFile" : "originLocal",
+					destinationFileUrl: !!desktop
+				}
+			};
+		},
+		previewReady: () => ready && !!host && !released,
+		validateStart: (options) => {
+			if (hostState === "absent") throw error("destinationUnavailable", "startRecording", "Movie output requires the packaged Linux WebKitGTK host");
+			if (options.orientation && options.orientation !== "unspecified") throw error("unsupportedConfiguration", "startRecording", "This browser cannot lock a recording orientation");
+		},
+		attachPreview: (target, callbacks) => {
+			if (released || sink) throw error("invalidState", "attachPreview", "The camera is disposed or still finalizing");
+			host = target;
+			listener = callbacks;
+			document.addEventListener("visibilitychange", onVisibility);
+			globalThis.addEventListener("pagehide", onPageHide);
+			showPreview().catch((cause) => callbacks?.onError?.(error("unavailable", "preview", "Could not activate camera preview", cause)));
+			return () => {
+				if (host) host.srcObject = null;
+				host = void 0;
+				listener = void 0;
+				generation += 1;
+				markReady(false);
+				document.removeEventListener("visibilitychange", onVisibility);
+				globalThis.removeEventListener("pagehide", onPageHide);
+				if (!sink) dropStream();
+			};
+		},
+		configure: (next) => {
+			const sourceChanged = JSON.stringify(next.camera) !== JSON.stringify(currentConfig.camera) || next.profile !== currentConfig.profile;
+			currentConfig = { ...next };
+			if (sourceChanged) {
+				generation += 1;
+				dropStream();
+				if (host) showPreview().catch((cause) => listener?.onError?.(error("unavailable", "configure", "Could not change camera", cause)));
+			}
+		},
+		startCapture: (request, target) => {
+			sink = target;
+			recordingAudio = request.audio;
+			startedAt = 0;
+			stoppedAt = 0;
+			let desktop = null;
+			let reservation;
+			let stage = "preparation";
+			const chunks = [];
+			let captureError;
+			let limitReached = false;
+			let failing = false;
+			let didStart = false;
+			captureFailure = fail;
+			(async () => {
+				try {
+					desktop = await hostProbe;
+					if (!desktop) throw error("destinationUnavailable", "startRecording", "Movie output requires the packaged Linux WebKitGTK host");
+					if (request.audio) {
+						if (await checkPermission("microphone") !== "granted") throw error("permissionDenied", "startRecording", "Requested microphone access is missing");
+						await ensureAudio().catch((cause) => {
+							throw error("captureFailed", "startRecording", "Could not acquire microphone for recording", cause);
+						});
+					}
+					const source = stream;
+					const video = source?.getVideoTracks()[0];
+					const audio = source?.getAudioTracks().filter((track) => track.readyState === "live") ?? [];
+					if (!video || request.audio && !audio.length) throw error(request.audio ? "permissionDenied" : "unavailable", "startRecording", request.audio ? "Requested microphone access is missing" : "Video source is unavailable");
+					const recordingStream = new MediaStream([video, ...request.audio ? audio : []]);
+					reservation = (await reserveHostMovie(desktop, {
+						destinationFileUrl: request.destinationPath ? `file://${request.destinationPath.split("/").map(encodeURIComponent).join("/")}` : void 0,
+						container: mimeType().startsWith("video/mp4") ? "mp4" : "webm"
+					})).fileUrl;
+					if (!source || video.readyState !== "live" || document.visibilityState === "hidden") throw error("unavailable", "startRecording", "Camera source became inactive before recording");
+					const activeRecorder = new MediaRecorder(recordingStream, { mimeType: mimeType() });
+					recorder = activeRecorder;
+					activeRecorder.ondataavailable = (event) => {
+						if (sink !== target || failing) return;
+						if (event.data.size) chunks.push(event.data);
+					};
+					activeRecorder.onerror = (event) => {
+						if (sink !== target || failing) return;
+						captureError = event;
+						stop();
+					};
+					activeRecorder.onstart = () => {
+						if (sink !== target || failing) return;
+						if (didStart) return;
+						didStart = true;
+						clearTimeout(watchdog);
+						startedAt = performance.now();
+						stage = "capture";
+						const settings = video.getSettings();
+						const effective = {
+							cameraId: settings.deviceId ?? "",
+							audio: request.audio,
+							width: settings.width ?? 0,
+							height: settings.height ?? 0,
+							frameRate: settings.frameRate ?? 0,
+							orientation: "unspecified",
+							mimeType: activeRecorder.mimeType,
+							container: activeRecorder.mimeType.startsWith("video/mp4") ? "mp4" : "webm"
+						};
+						if (request.maximumDurationMs) {
+							const limit = request.maximumDurationMs;
+							const checkLimit = () => {
+								if (sink !== target || failing) return;
+								const remaining = limit - (performance.now() - startedAt);
+								if (remaining > 0) stopTimer = setTimeout(checkLimit, Math.min(remaining, 2147483647));
+								else {
+									limitReached = true;
+									stop();
+								}
+							};
+							stopTimer = setTimeout(checkLimit, Math.min(limit, 2147483647));
+						}
+						target.started(effective);
+					};
+					activeRecorder.onstop = () => {
+						if (sink !== target || failing) return;
+						target.finishing(captureError ? "captureError" : limitReached ? "maximumDuration" : void 0);
+						stoppedAt ||= performance.now();
+						clearTimeout(stopTimer);
+						clearTimeout(watchdog);
+						(async () => {
+							try {
+								stage = "finalization";
+								if (!startedAt) throw error("noMedia", "finalize", "No recording start was observed");
+								const bytes = new Blob(chunks, { type: activeRecorder.mimeType });
+								if (globalThis.__xplatDebugMovie) globalThis.__xplatLastMovieBlob = bytes;
+								const metadata = await inspectMovie(bytes, request.audio);
+								if (sink !== target || failing) return;
+								stage = "storage";
+								const output = await commitHostMovie(desktop, reservation, bytes);
+								const clip = {
+									...metadata,
+									output
+								};
+								settle({
+									kind: "clip",
+									...clip,
+									limitReached,
+									warning: captureError ? error("captureFailed", "capture", "Recorder reported an error; finalized media was verified", captureError) : void 0
+								}, target);
+							} catch (cause) {
+								await fail(cause);
+							}
+						})();
+					};
+					activeRecorder.start(1e3);
+					watchdog = setTimeout(() => {
+						if (!startedAt && sink === target) {
+							stop();
+							fail(error("captureFailed", "startRecording", "Recorder start callback timed out"));
+						}
+					}, 15e3);
+				} catch (cause) {
+					await fail(cause);
+				}
+			})();
+			async function fail(cause) {
+				if (sink !== target || failing) return;
+				failing = true;
+				if (reservation && desktop) await removeHostReservation(desktop, reservation);
+				settle({
+					kind: "failed",
+					stage,
+					issue: cause instanceof CameraCaptureError ? cause : error(stage === "storage" ? "storageFailed" : stage === "preparation" || stage === "capture" ? "captureFailed" : "finalizationFailed", stage, "Movie recording could not complete", cause)
+				}, target);
+			}
+		},
+		stopCapture: stop,
+		elapsedMs: () => startedAt ? Math.max(0, (stoppedAt || performance.now()) - startedAt) : 0,
+		openOutput: async (output) => {
+			if (output.kind !== "nativeFile") throw error("unavailable", "openOutput", "Only host file-backed output exists on this platform");
+			const desktop = await hostProbe;
+			if (!desktop) throw error("unavailable", "openOutput", "File-backed output requires the desktop host that recorded it");
+			return openHostMovie(desktop, output);
+		},
+		release: async () => {
+			released = true;
+			generation += 1;
+			document.removeEventListener("visibilitychange", onVisibility);
+			globalThis.removeEventListener("pagehide", onPageHide);
+			dropStream();
+			host = void 0;
+		},
+		setObserver: (value) => {
+			observer = value;
+		}
+	};
+}
+//#endregion
+export { createSessionBackend };