@bubo-squared/gyroview 0.2.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubo-squared/gyroview",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Play raw Insta360 .insv recordings (X3, X4, X5) in the browser: a <gyro-view> web component that stitches and gyro-stabilizes the camera's dual-fisheye video on the GPU.",
   "keywords": [
     "insta360",

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

@@ -1,133 +0,0 @@
-import { GyroViewError } from "../../../core/src/shared/errors/GyroViewError.js";
-import { seconds } from "../../../core/src/shared/units/time.js";
-import "../../../core/src/index.js";
-import { SegmentChannel } from "./SegmentChannel.js";
-import { EncodedAudioPacketSource, EncodedPacketSink, Mp4OutputFormat, NullTarget, Output } from "mediabunny";
-//#region ../../packages/adapters/mediabunny/src/MediabunnyAudioSegments.ts
-/**
-* Seconds of audio per media segment: short enough that a seek has sound quickly, long enough
-* that appends stay cheap.
-*/
-var FRAGMENT_DURATION_SECONDS = 1;
-/**
-* Segments (each fragment is two: `moof` and `mdat`) that may wait for the consumer before
-* re-packaging pauses.
-*/
-var SEGMENTS_AHEAD = 4;
-/**
-* An audio track's packets re-packaged, unchanged, into fragmented MP4 with mediabunny.
-* Segments are taken from the muxer's box callbacks rather than from its byte stream: that
-* yields whole `ftyp`/`moov`/`moof`/`mdat` boxes and leaves out the `mfra` index the muxer
-* appends at the end, which Media Source Extensions do not accept. Fragmented output keeps the
-* track's own timestamps, so a run started mid-track lands at its true time.
-*/
-var MediabunnyAudioSegments = class MediabunnyAudioSegments {
-	parts;
-	duration;
-	constructor(parts, duration) {
-		this.parts = parts;
-		this.duration = duration;
-	}
-	/**
-	* Rejects with `codec-unsupported`, naming the track, when mediabunny cannot re-package it: the
-	* picture then plays without sound rather than not at all.
-	*/
-	static async open(track, trackIndex) {
-		const [codec, decoderConfig, duration] = await Promise.all([
-			track.getCodec(),
-			track.getDecoderConfig(),
-			track.computeDuration()
-		]);
-		if (codec === null || decoderConfig === null) {
-			const named = await track.getCodecParameterString() ?? "an unknown codec";
-			throw new GyroViewError("codec-unsupported", `audio track ${trackIndex} (${named}) cannot be re-packaged for playback`);
-		}
-		return new MediabunnyAudioSegments({
-			track,
-			codec,
-			decoderConfig
-		}, seconds(duration));
-	}
-	get mimeType() {
-		return `audio/mp4; codecs="${this.parts.decoderConfig.codec}"`;
-	}
-	segmentsFrom(from) {
-		return remux(this.parts, from);
-	}
-};
-async function* remux(parts, from) {
-	const channel = new SegmentChannel(SEGMENTS_AHEAD);
-	const output = new Output({
-		format: fragmentedMp4Into(channel),
-		target: new NullTarget()
-	});
-	const source = new EncodedAudioPacketSource(parts.codec);
-	output.addAudioTrack(source);
-	const production = produce({
-		parts,
-		from,
-		output,
-		source,
-		channel
-	});
-	try {
-		yield* channel.segments();
-	} finally {
-		channel.close();
-		releaseAfter(production, output);
-	}
-}
-/**
-* Frees the muxer once the producer has noticed the closed channel, without making a consumer
-* that left early (a seek) wait for a packet read still in flight.
-*/
-async function releaseAfter(production, output) {
-	await production;
-	if (output.state === "finalized") return;
-	try {
-		await output.cancel();
-	} catch {}
-}
-/**
-* Feeds packets to the muxer at the consumer's pace; every failure ends up in the channel.
-*/
-async function produce(run) {
-	try {
-		await run.output.start();
-		let meta = { decoderConfig: run.parts.decoderConfig };
-		for await (const packet of packetsFrom(run.parts.track, run.from)) {
-			await run.channel.waitForRoom();
-			if (run.channel.isClosed) return;
-			await run.source.add(packet, meta);
-			meta = void 0;
-		}
-		await run.output.finalize();
-		run.channel.close();
-	} catch (error) {
-		run.channel.fail(error);
-	}
-}
-function fragmentedMp4Into(channel) {
-	const forward = (data) => {
-		channel.push(new Uint8Array(data));
-	};
-	return new Mp4OutputFormat({
-		fastStart: "fragmented",
-		minimumFragmentDuration: FRAGMENT_DURATION_SECONDS,
-		onFtyp: forward,
-		onMoov: forward,
-		onMoof: forward,
-		onMdat: forward
-	});
-}
-/**
-* Packets in decode order from the one playing at `time` (or the first one after it) to the end.
-*/
-async function* packetsFrom(track, time) {
-	const sink = new EncodedPacketSink(track);
-	const start = await sink.getPacket(time) ?? await sink.getFirstPacket();
-	if (start === null) return;
-	yield* sink.packets(start);
-}
-//#endregion
-export { MediabunnyAudioSegments };

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

@@ -1,63 +0,0 @@
-import { GyroViewError, isAbortError } from "../../../core/src/shared/errors/GyroViewError.js";
-import { seconds } from "../../../core/src/shared/units/time.js";
-import { ByteRange } from "../../../core/src/shared/binary/ByteRange.js";
-import "../../../core/src/index.js";
-import { MediabunnyAudioSegments } from "./MediabunnyAudioSegments.js";
-import { MediabunnyVideoTrackReader } from "./MediabunnyVideoTrackReader.js";
-import { ALL_FORMATS, CustomSource, Input } from "mediabunny";
-//#region ../../packages/adapters/mediabunny/src/MediabunnyDemuxer.ts
-/**
-* Demuxer over mediabunny. Bytes flow through the core's RandomAccessSource port (one HTTP
-* client, one cache), presented to mediabunny as a CustomSource with network prefetching.
-*/
-var MediabunnyDemuxer = class {
-	async open(source, name) {
-		const input = new Input({
-			formats: ALL_FORMATS,
-			source: new CustomSource({
-				getSize: () => source.size(),
-				read: (start, end) => source.read(ByteRange.of(start, end - start)),
-				prefetchProfile: "network",
-				handleUnhandledError: ignoreFailedPrefetch
-			})
-		});
-		try {
-			return await describeInput(input, name);
-		} catch (error) {
-			input.dispose();
-			throw failureOf(error, name);
-		}
-	}
-};
-/**
-* The source's own failures and a caller's abort pass as they are; anything else the demuxer
-* throws means the bytes are no media file it can read.
-*/
-function failureOf(error, name) {
-	const isPassedOn = isAbortError(error) || error instanceof GyroViewError;
-	const message = `${name ?? "the input"} is not a readable media file`;
-	return isPassedOn ? error : new GyroViewError("unsupported-container", message, { cause: error });
-}
-/**
-* A read ahead that fails while no read waits for it: left unhandled it would reach the host
-* page's error reporting. The read that needs those bytes asks again and fails through the port.
-*/
-function ignoreFailedPrefetch() {}
-async function describeInput(input, name) {
-	const [videoTracks, audioTracks, duration] = await Promise.all([
-		input.getVideoTracks(),
-		input.getAudioTracks(),
-		input.computeDuration()
-	]);
-	return {
-		name,
-		duration: seconds(duration),
-		videoTracks: await Promise.all(videoTracks.map((track, trackIndex) => MediabunnyVideoTrackReader.open(track, trackIndex))),
-		audioTracks: audioTracks.map((track, trackIndex) => ({ openSegments: () => MediabunnyAudioSegments.open(track, trackIndex) })),
-		dispose: () => {
-			input.dispose();
-		}
-	};
-}
-//#endregion
-export { MediabunnyDemuxer };

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

@@ -1,84 +0,0 @@
-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 };