@bubo-squared/gyroview 0.1.0

package/dist/packages/adapters/mediabunny/src/MediabunnyVideoTrackReader.js

@@ -0,0 +1,84 @@
+import { GyroViewError } from "../../../core/src/shared/errors/GyroViewError.js";
+import { seconds } from "../../../core/src/shared/units/time.js";
+import "../../../core/src/index.js";
+import { copyOfBytes } from "./bufferSources.js";
+import { EncodedPacketSink } from "mediabunny";
+//#region ../../packages/adapters/mediabunny/src/MediabunnyVideoTrackReader.ts
+/**
+* Container metadata may mark a packet as a key packet that is not one; the bitstream decides.
+*/
+var VERIFIED = { verifyKeyPackets: true };
+/**
+* VideoTrackReader over one mediabunny video track. Packets handed out are plain data; the
+* mediabunny packet behind each is remembered so iteration can resume from it.
+*/
+var MediabunnyVideoTrackReader = class MediabunnyVideoTrackReader {
+	track;
+	description;
+	sink;
+	originals = /* @__PURE__ */ new WeakMap();
+	constructor(track, description) {
+		this.track = track;
+		this.description = description;
+		this.sink = new EncodedPacketSink(track);
+	}
+	static async open(track, trackIndex) {
+		const [codec, codedWidth, codedHeight] = await Promise.all([
+			track.getCodecParameterString(),
+			track.getCodedWidth(),
+			track.getCodedHeight()
+		]);
+		if (codec === null) throw new GyroViewError("codec-unsupported", `video track ${trackIndex} has an unknown codec`);
+		return new MediabunnyVideoTrackReader(track, {
+			trackIndex,
+			codedWidth,
+			codedHeight,
+			codec
+		});
+	}
+	async decoderConfiguration() {
+		const config = await this.track.getDecoderConfig();
+		if (config === null) throw new GyroViewError("codec-unsupported", `video track ${this.description.trackIndex} (${this.description.codec}) cannot be configured for decoding`);
+		return {
+			codec: config.codec,
+			codedWidth: config.codedWidth ?? this.description.codedWidth,
+			codedHeight: config.codedHeight ?? this.description.codedHeight,
+			description: config.description === void 0 ? void 0 : copyOfBytes(config.description),
+			isFullRange: config.colorSpace?.fullRange ?? void 0
+		};
+	}
+	async keyPacketAt(time) {
+		const packet = await this.sink.getKeyPacket(time, VERIFIED);
+		return packet === null ? void 0 : this.wrap(packet);
+	}
+	async firstKeyPacket() {
+		const packet = await this.sink.getFirstKeyPacket(VERIFIED);
+		return packet === null ? void 0 : this.wrap(packet);
+	}
+	async *packetsFrom(start) {
+		const original = this.originals.get(start);
+		if (!original) throw new GyroViewError("invariant-violation", "packetsFrom needs a packet handed out by this reader");
+		for await (const packet of this.sink.packets(original)) yield this.wrap(packet);
+	}
+	async sampleTimestamps() {
+		const timestamps = [];
+		const metadataOnly = this.sink.packets(void 0, void 0, { metadataOnly: true });
+		for await (const packet of metadataOnly) timestamps.push(seconds(packet.timestamp));
+		return timestamps.toSorted((left, right) => left - right);
+	}
+	async frameCount() {
+		return (await this.track.computePacketStats()).packetCount;
+	}
+	wrap(packet) {
+		const wrapped = {
+			timestamp: seconds(packet.timestamp),
+			duration: seconds(packet.duration),
+			isKeyFrame: packet.type === "key",
+			data: packet.data
+		};
+		this.originals.set(wrapped, packet);
+		return wrapped;
+	}
+};
+//#endregion
+export { MediabunnyVideoTrackReader };

package/dist/packages/adapters/mediabunny/src/SegmentChannel.js

@@ -0,0 +1,84 @@
+import { GyroViewError, ensureInvariant } from "../../../core/src/shared/errors/GyroViewError.js";
+import "../../../core/src/index.js";
+//#region ../../packages/adapters/mediabunny/src/SegmentChannel.ts
+/**
+* Hands segments from the muxer's synchronous callbacks to one asynchronous consumer, with a
+* bound on how many may wait unconsumed so re-packaging never runs far ahead of playback.
+* Closing from either side ends the exchange; a producer failure reaches the consumer as a
+* thrown error once the segments before it are drained. A second concurrent consumer is a
+* programming error.
+*/
+var SegmentChannel = class {
+	capacity;
+	queue = [];
+	roomWaiters = [];
+	takeWaiter;
+	isClosedNow = false;
+	failure;
+	constructor(capacity) {
+		this.capacity = capacity;
+	}
+	get isClosed() {
+		return this.isClosedNow;
+	}
+	push(segment) {
+		if (this.isClosedNow) return;
+		this.queue.push(segment);
+		this.wakeTaker();
+	}
+	/**
+	* Resolves once fewer than `capacity` segments wait, or at once when the channel is closed.
+	*/
+	waitForRoom() {
+		return this.queue.length < this.capacity || this.isClosedNow ? Promise.resolve() : new Promise((resolve) => {
+			this.roomWaiters.push(resolve);
+		});
+	}
+	close() {
+		this.isClosedNow = true;
+		this.wakeTaker();
+		this.wakeRoomWaiters();
+	}
+	fail(error) {
+		this.failure ??= error instanceof Error ? error : new GyroViewError("decode", "audio re-packaging failed", { cause: error });
+		this.close();
+	}
+	async *segments() {
+		let next = await this.take();
+		while (next) {
+			yield next;
+			next = await this.take();
+		}
+	}
+	/**
+	* The next segment; undefined once closed and drained; the producer's failure, if it had one.
+	*/
+	async take() {
+		while (this.queue.length === 0 && !this.isClosedNow) await this.nextPush();
+		const next = this.queue.shift();
+		if (next) {
+			this.wakeRoomWaiters();
+			return next;
+		}
+		if (this.failure) throw this.failure;
+	}
+	nextPush() {
+		ensureInvariant(this.takeWaiter === void 0, "a segment channel has one consumer");
+		return new Promise((resolve) => {
+			this.takeWaiter = resolve;
+		});
+	}
+	wakeTaker() {
+		const waiter = this.takeWaiter;
+		this.takeWaiter = void 0;
+		waiter?.();
+	}
+	wakeRoomWaiters() {
+		if (this.queue.length >= this.capacity && !this.isClosedNow) return;
+		const waiters = this.roomWaiters;
+		this.roomWaiters = [];
+		for (const resolve of waiters) resolve();
+	}
+};
+//#endregion
+export { SegmentChannel };

package/dist/packages/adapters/mediabunny/src/bufferSources.js

@@ -0,0 +1,12 @@
+//#region ../../packages/adapters/mediabunny/src/bufferSources.ts
+/**
+* A copy of a buffer source as a plain Uint8Array. Decoder descriptions are small; the copy keeps
+* them independent of mediabunny's own buffers and never on shared memory. SharedArrayBuffer is
+* not named, since browsers define it only under cross-origin isolation.
+*/
+function copyOfBytes(source) {
+	const view = ArrayBuffer.isView(source) ? new Uint8Array(source.buffer, source.byteOffset, source.byteLength) : new Uint8Array(source);
+	return Uint8Array.from(view);
+}
+//#endregion
+export { copyOfBytes };

package/dist/packages/adapters/mediabunny/src/index.js

@@ -0,0 +1,2 @@
+import { MediabunnyDemuxer } from "./MediabunnyDemuxer.js";
+export { MediabunnyDemuxer };

package/dist/packages/adapters/mse-audio/src/MediaSourceAudioClock.js

@@ -0,0 +1,139 @@
+import { GyroViewError, isAbortError, messageOf } from "../../../core/src/shared/errors/GyroViewError.js";
+import { seconds } from "../../../core/src/shared/units/time.js";
+import "../../../core/src/index.js";
+import { attachMediaSource, isMediaSourceTypeSupported, mediaSourceConstructor } from "./mediaSourceSupport.js";
+import { SourceBufferFeeder } from "./SourceBufferFeeder.js";
+//#region ../../packages/adapters/mse-audio/src/MediaSourceAudioClock.ts
+/**
+* PlaybackClock over an audio element fed through Media Source Extensions with the recording's
+* own audio track, so the picture follows the sound and volume and mute are the element's.
+* The element is borrowed from the host; disposing detaches the media source from it.
+* See ADR 0007.
+*/
+var MediaSourceAudioClock = class MediaSourceAudioClock {
+	element;
+	feeder;
+	attached;
+	/**
+	* The end the clock stands at since a seek there, the element left where it was.
+	*/
+	standingEnd;
+	constructor(element, feeder, attached) {
+		this.element = element;
+		this.feeder = feeder;
+		this.attached = attached;
+	}
+	static isSupported(source) {
+		return isMediaSourceTypeSupported(source.mimeType);
+	}
+	/**
+	* Attaches a media source to the element and starts buffering from the beginning.
+	*/
+	static async open(element, source) {
+		const mediaSourceClass = mediaSourceConstructor();
+		if (!mediaSourceClass?.isTypeSupported(source.mimeType)) throw new GyroViewError("codec-unsupported", `${source.mimeType} cannot play through Media Source Extensions here`);
+		const attached = await attachMediaSource(element, mediaSourceClass);
+		try {
+			const sourceBuffer = attached.mediaSource.addSourceBuffer(source.mimeType);
+			attached.mediaSource.duration = source.duration;
+			const feeder = new SourceBufferFeeder({
+				element,
+				mediaSource: attached.mediaSource,
+				sourceBuffer,
+				source
+			});
+			feeder.restartFrom(seconds(0));
+			return new MediaSourceAudioClock(element, feeder, attached);
+		} catch (error) {
+			attached.detach();
+			throw asClockFailure(error);
+		}
+	}
+	get currentTime() {
+		return this.standingEnd ?? seconds(this.element.currentTime);
+	}
+	/**
+	* Whoever paused the element (the session, media keys, an audio interruption): `play()` clears
+	* `paused` at once, so a start in flight counts as running.
+	*/
+	get isRunning() {
+		return !this.element.paused;
+	}
+	/**
+	* Standing at the end since a seek there, or the element `ended`: it played to its end.
+	*/
+	get hasEnded() {
+		return this.standingEnd !== void 0 || this.element.ended;
+	}
+	/**
+	* What the feeder met, or the element's own error: sound that buffered but would not decode,
+	* which stalls the element without the feeder ever hearing of it.
+	*/
+	get failure() {
+		return this.feeder.failure ?? failureOfElement(this.element);
+	}
+	/**
+	* Resolves once playback has started. A `pause` that interrupts the start is not an error;
+	* the autoplay policy refusing to start is reported as `playback-blocked`. A clock at its end
+	* stays there: `play()` would play the element from the beginning, or from where a seek to the
+	* end left it, under the last picture.
+	*/
+	async start() {
+		if (this.hasEnded) return;
+		try {
+			await this.element.play();
+		} catch (error) {
+			if (isAbortError(error)) return;
+			const isBlocked = isNamed(error, "NotAllowedError");
+			throw new GyroViewError(isBlocked ? "playback-blocked" : "decode", isBlocked ? "the browser refused to start audio playback; a user gesture is needed" : "audio playback failed to start", { cause: error });
+		}
+	}
+	pause() {
+		this.element.pause();
+	}
+	/**
+	* A seek to the end stands the clock there and leaves the element paused where it was: an
+	* element at its end has nothing left to play, and engines differ right at the end. WebKit on
+	* Linux, under load, fails an element whose seek to the end of its sound is still pending when
+	* the stream ends there (media error 4); macOS WebKit loses a seek just short of the end.
+	*/
+	seek(time) {
+		const end = this.attached.mediaSource.duration;
+		if (time >= end) {
+			this.standAtEnd(seconds(end));
+			return;
+		}
+		this.standingEnd = void 0;
+		this.element.currentTime = time;
+		this.feeder.restartFrom(time);
+	}
+	dispose() {
+		this.feeder.dispose();
+		this.element.pause();
+		this.attached.detach();
+	}
+	standAtEnd(end) {
+		this.element.pause();
+		this.standingEnd = end;
+	}
+};
+function isNamed(error, name) {
+	return error instanceof Error && error.name === name;
+}
+function failureOfElement(element) {
+	const { error } = element;
+	if (error === null) return void 0;
+	const message = `the audio element failed (media error ${error.code})`;
+	return new GyroViewError("decode", message, { cause: error });
+}
+/**
+* The media source's own exceptions cross the port as typed failures: a type it will not buffer
+* is `codec-unsupported`, anything else `decode`.
+*/
+function asClockFailure(error) {
+	if (error instanceof GyroViewError) return error;
+	const isUnsupported = isNamed(error, "NotSupportedError");
+	return new GyroViewError(isUnsupported ? "codec-unsupported" : "decode", `the audio element refused the recording's sound: ${messageOf(error)}`, { cause: error });
+}
+//#endregion
+export { MediaSourceAudioClock };

package/dist/packages/adapters/mse-audio/src/SourceBufferFeeder.js

@@ -0,0 +1,174 @@
+import { GyroViewError, asGyroViewError } from "../../../core/src/shared/errors/GyroViewError.js";
+import { seconds } from "../../../core/src/shared/units/time.js";
+import { RunStop, STOPPED } from "../../../core/src/shared/async/RunStop.js";
+import "../../../core/src/index.js";
+import { nextOfEvents } from "./events.js";
+//#region ../../packages/adapters/mse-audio/src/SourceBufferFeeder.ts
+/**
+* How far past the playhead audio is kept buffered, to ride out a slow network.
+*/
+var BUFFER_AHEAD_SECONDS = 30;
+/**
+* Buffered audio kept behind the playhead for small backward seeks; older data is evicted.
+*/
+var KEEP_BEHIND_SECONDS = 30;
+/**
+* Eviction runs once this much audio has piled up behind the playhead.
+*/
+var EVICT_BEHIND_SECONDS = 60;
+/**
+* How far before its time a run starts feeding: each AAC frame overlaps the one before, so the
+* decoder gets the frames that lead up to the playhead.
+*/
+var LEAD_IN_SECONDS = 1;
+/**
+* Events on which the feeder re-checks whether the buffer needs more data.
+*/
+var WAKE_EVENTS = [
+	"timeupdate",
+	"seeking",
+	"waiting",
+	"play"
+];
+/**
+* Keeps the source buffer filled from the playhead onwards: appends segments while less than
+* `BUFFER_AHEAD_SECONDS` of audio is buffered past the current time, evicts what lies far behind,
+* and ends the stream when the track ends. A seek restarts it from what the new time is missing;
+* disposal stops it.
+*/
+var SourceBufferFeeder = class {
+	parts;
+	stop = new RunStop();
+	run = Promise.resolve();
+	failureValue;
+	constructor(parts) {
+		this.parts = parts;
+	}
+	/**
+	* The first error the feeder met, if any. The element keeps whatever was buffered before.
+	*/
+	get failure() {
+		return this.failureValue;
+	}
+	restartFrom(time) {
+		this.stop.stop();
+		const stop = new RunStop();
+		this.stop = stop;
+		this.run = this.feedAfter(this.run, time, stop);
+	}
+	/**
+	* Stops feeding. An append or eviction under way is left to the media source's detachment,
+	* which ends it; `abort` would throw while old audio is being evicted.
+	*/
+	dispose() {
+		this.stop.stop();
+	}
+	/**
+	* Runs are serialised so a restart never appends while the previous run is mid-append.
+	*/
+	async feedAfter(previous, from, stop) {
+		await previous;
+		await this.feed(from, stop);
+	}
+	async feed(from, stop) {
+		try {
+			await this.settlePendingAppend();
+			if (this.hasAllAudioFrom(from)) return;
+			await this.feedFrom(this.startOf(from), stop);
+		} catch (error) {
+			this.failureValue ??= asGyroViewError(error, "decode", "feeding the audio buffer failed");
+		}
+	}
+	async feedFrom(start, stop) {
+		const segments = this.parts.source.segmentsFrom(start)[Symbol.asyncIterator]();
+		try {
+			if (await this.pump(segments, stop)) this.endStream();
+		} finally {
+			segments.return?.();
+		}
+	}
+	/**
+	* The stream ended and `from` lies in the range that runs to its end: nothing is left to
+	* append, and a run would only append the last frame again and reopen the stream.
+	*/
+	hasAllAudioFrom(from) {
+		const { buffered } = this.parts.element;
+		const end = this.bufferedEndAt(from);
+		return this.parts.mediaSource.readyState === "ended" && end > from && end === buffered.end(buffered.length - 1);
+	}
+	/**
+	* Where a run for `from` starts: at the end of the audio already buffered around it, so a seek
+	* within the buffer appends only what is missing, or a lead-in before it otherwise.
+	*/
+	startOf(from) {
+		const bufferedEnd = this.bufferedEndAt(from);
+		return seconds(bufferedEnd > from ? bufferedEnd : Math.max(0, from - LEAD_IN_SECONDS));
+	}
+	/**
+	* Appends segments as the playhead needs them. True when the track ended, false when stopped.
+	*/
+	async pump(segments, stop) {
+		let next = await this.nextWhenNeeded(segments, stop);
+		while (next !== STOPPED) {
+			if (next.done === true) return true;
+			this.evictBehind();
+			await this.append(next.value);
+			next = await this.nextWhenNeeded(segments, stop);
+		}
+		return false;
+	}
+	/**
+	* The next segment once the buffer has room for it, or STOPPED if the run ended meanwhile.
+	*/
+	async nextWhenNeeded(segments, stop) {
+		await this.waitUntilNeeded(stop);
+		return stop.race(() => segments.next());
+	}
+	async waitUntilNeeded(stop) {
+		while (!stop.wasStopped && this.bufferedAhead() >= BUFFER_AHEAD_SECONDS) {
+			const woken = new AbortController();
+			await stop.race(() => nextOfEvents(this.parts.element, WAKE_EVENTS, woken.signal));
+			woken.abort();
+		}
+	}
+	/**
+	* Seconds buffered from the playhead to the end of the range it lies in; zero outside any.
+	*/
+	bufferedAhead() {
+		const { currentTime } = this.parts.element;
+		return seconds(this.bufferedEndAt(currentTime) - currentTime);
+	}
+	/**
+	* The end of the buffered range `time` lies in; `time` itself outside any.
+	*/
+	bufferedEndAt(time) {
+		const { buffered } = this.parts.element;
+		for (let index = 0; index < buffered.length; index += 1) if (buffered.start(index) <= time && time < buffered.end(index)) return buffered.end(index);
+		return time;
+	}
+	evictBehind() {
+		const { buffered, currentTime } = this.parts.element;
+		if (currentTime - (buffered.length > 0 ? buffered.start(0) : currentTime) < EVICT_BEHIND_SECONDS || this.parts.sourceBuffer.updating) return;
+		this.parts.sourceBuffer.remove(0, currentTime - KEEP_BEHIND_SECONDS);
+	}
+	async append(segment) {
+		const { sourceBuffer } = this.parts;
+		await this.settlePendingAppend();
+		const outcome = nextOfEvents(sourceBuffer, ["updateend", "error"]);
+		try {
+			sourceBuffer.appendBuffer(segment);
+		} catch (error) {
+			throw new GyroViewError("decode", "the audio buffer rejected a segment", { cause: error });
+		}
+		if (await outcome === "error") throw new GyroViewError("decode", "the audio buffer could not parse a segment");
+	}
+	async settlePendingAppend() {
+		if (this.parts.sourceBuffer.updating) await nextOfEvents(this.parts.sourceBuffer, ["updateend"]);
+	}
+	endStream() {
+		const { mediaSource, sourceBuffer } = this.parts;
+		if (mediaSource.readyState === "open" && !sourceBuffer.updating) mediaSource.endOfStream();
+	}
+};
+//#endregion
+export { SourceBufferFeeder };

package/dist/packages/adapters/mse-audio/src/events.js

@@ -0,0 +1,26 @@
+//#region ../../packages/adapters/mse-audio/src/events.ts
+/**
+* Resolves with the type of the first of the given events. Every listener is removed then, or as
+* soon as `cancel` aborts, so a wait that lost a race leaves nothing on the target; the watch on
+* `cancel` goes with them, so a long-lived signal gathers nothing either.
+*/
+function nextOfEvents(target, types, cancel) {
+	const listening = new AbortController();
+	cancel?.addEventListener("abort", () => {
+		listening.abort();
+	}, {
+		once: true,
+		signal: listening.signal
+	});
+	return new Promise((resolve) => {
+		for (const type of types) target.addEventListener(type, () => {
+			listening.abort();
+			resolve(type);
+		}, {
+			once: true,
+			signal: listening.signal
+		});
+	});
+}
+//#endregion
+export { nextOfEvents };

package/dist/packages/adapters/mse-audio/src/index.js

@@ -0,0 +1,2 @@
+import { MediaSourceAudioClock } from "./MediaSourceAudioClock.js";
+export { MediaSourceAudioClock };

package/dist/packages/adapters/mse-audio/src/mediaSourceSupport.js

@@ -0,0 +1,82 @@
+import { GyroViewError } from "../../../core/src/shared/errors/GyroViewError.js";
+import "../../../core/src/index.js";
+import { nextOfEvents } from "./events.js";
+//#region ../../packages/adapters/mse-audio/src/mediaSourceSupport.ts
+var MANAGED_MEDIA_SOURCE = "ManagedMediaSource";
+var MEDIA_SOURCE = "MediaSource";
+function isMediaSourceConstructor(value) {
+	return typeof value === "function" && typeof value.isTypeSupported === "function";
+}
+function globalConstructor(name) {
+	const value = Reflect.get(globalThis, name);
+	return isMediaSourceConstructor(value) ? value : void 0;
+}
+/**
+* The media source implementation to use, preferring the managed one where it exists.
+*/
+function mediaSourceConstructor() {
+	return globalConstructor(MANAGED_MEDIA_SOURCE) ?? globalConstructor(MEDIA_SOURCE);
+}
+function isMediaSourceTypeSupported(mimeType) {
+	return mediaSourceConstructor()?.isTypeSupported(mimeType) ?? false;
+}
+/**
+* `sourceopen` follows the attachment within a task or two; a browser that never sends it, or
+* sends the element's `error` instead, must not hold the load, which falls back to a silent clock.
+*/
+var SOURCE_OPEN_TIMEOUT_MS = 1e4;
+/**
+* Attaches a fresh media source to the element and resolves once it is open for source buffers;
+* rejects with `decode`, detached again, when the element fails or the source never opens.
+*/
+async function attachMediaSource(element, mediaSourceClass) {
+	const mediaSource = new mediaSourceClass();
+	const outcome = sourceOpenOutcome(element, mediaSource);
+	const url = URL.createObjectURL(mediaSource);
+	element.disableRemotePlayback = true;
+	element.src = url;
+	const attached = {
+		mediaSource,
+		detach: () => {
+			if (element.src === url) {
+				element.removeAttribute("src");
+				element.load();
+			}
+			URL.revokeObjectURL(url);
+		}
+	};
+	const opened = await outcome;
+	if (opened !== "sourceopen") {
+		attached.detach();
+		throw new GyroViewError("decode", `the audio element could not open its media source (${opened})`);
+	}
+	return attached;
+}
+/**
+* Whichever comes first; the losers' listeners and the timer go once it is known, so the element
+* the host reuses for every load carries nothing over.
+*/
+async function sourceOpenOutcome(element, mediaSource) {
+	const settled = new AbortController();
+	try {
+		return await Promise.race([
+			nextOfEvents(mediaSource, ["sourceopen"], settled.signal),
+			nextOfEvents(element, ["error"], settled.signal),
+			timeoutAfter(SOURCE_OPEN_TIMEOUT_MS, settled.signal)
+		]);
+	} finally {
+		settled.abort();
+	}
+}
+function timeoutAfter(ms, cancel) {
+	return new Promise((resolve) => {
+		const timer = setTimeout(() => {
+			resolve("timeout");
+		}, ms);
+		cancel.addEventListener("abort", () => {
+			clearTimeout(timer);
+		}, { once: true });
+	});
+}
+//#endregion
+export { attachMediaSource, isMediaSourceTypeSupported, mediaSourceConstructor };