@blockcast/mmt-transport 0.2.0 → 0.2.2

package/src/unicast-fallback.ts

@@ -0,0 +1,57 @@
+export interface FallbackTrack { name: string; type: "video" | "audio"; }
+export interface FallbackGroup { readFrame(): Promise<Uint8Array | undefined>; close(): void; }
+export interface FallbackSubscription { nextGroup(): Promise<FallbackGroup | undefined>; close(): void; }
+export interface FallbackBroadcast { subscribe(name: string, priority: number): FallbackSubscription; }
+export interface FallbackSessions { enterUnicastFallback(): void; }
+export type FallbackGroupLike = FallbackGroup;
+export type FallbackSubLike = FallbackSubscription;
+export type FallbackBroadcastLike = FallbackBroadcast;
+export interface FallbackSessionManagerLike extends FallbackSessions { hasActiveFallback(): boolean; }
+
+export function runUnicastFallback(input: {
+	tracks: FallbackTrack[];
+	broadcast: FallbackBroadcast;
+	sessions: FallbackSessions;
+	onPacket(packet: Uint8Array): void;
+	priority: number;
+	signal: AbortSignal;
+	onError?(trackName: string, error: unknown): void;
+}): { done: Promise<void> } {
+	input.sessions.enterUnicastFallback();
+	const tracks = Array.from(new Map(input.tracks.map((track) => [track.name, track])).values());
+	let resolveAbort: (value: undefined) => void;
+	const aborted = new Promise<undefined>((resolve) => {
+		resolveAbort = resolve;
+		if (input.signal.aborted) resolve(undefined);
+	});
+	const onAbort = () => resolveAbort(undefined);
+	if (!input.signal.aborted) input.signal.addEventListener("abort", onAbort, { once: true });
+
+	const drainers = tracks.map(async (track) => {
+		const subscription = input.broadcast.subscribe(track.name, input.priority);
+		try {
+			while (!input.signal.aborted) {
+				const nextGroup = subscription.nextGroup();
+				const group = await Promise.race([nextGroup, aborted]);
+				if (!group && input.signal.aborted) void nextGroup.then((lateGroup) => lateGroup?.close());
+				if (!group) break;
+				try {
+					while (!input.signal.aborted) {
+						const frame = await Promise.race([group.readFrame(), aborted]);
+						if (!frame) break;
+						input.onPacket(frame);
+					}
+				} finally { group.close(); }
+			}
+		} catch (error) {
+			if (!input.signal.aborted) {
+				if (input.onError) input.onError(track.name, error);
+				else console.warn(`[unicast-fallback] drainer error on ${track.name}:`, error);
+			}
+		} finally { subscription.close(); }
+	});
+	const done = Promise.all(drainers).then(() => undefined).finally(() => {
+		input.signal.removeEventListener("abort", onAbort);
+	});
+	return { done };
+}