mattebox 0.1.0

package/dist/es2015/stages/cmaf-timing/index.js

@@ -0,0 +1,55 @@
+import { findBox, normalizeTfdt, trackTimescales } from "../../containers/mp4-box/index.js";
+//#region src/stages/cmaf-timing/index.ts
+/**
+* cmaf-timing normalizes the decode timeline of native fMP4 segments so a live
+* CMAF stream plays. A CMAF live segment's tfdt carries the real broadcast
+* clock (often a value in the billions of seconds); appended with the zero
+* timestampOffset the kernel derives for fMP4, its frames land far past the
+* playhead and nothing ever renders. This stage rewrites each segment's tfdt to
+* the presentation start the manifest assigns it, which is the same alignment a
+* TS transmux produces for free, so VOD (already near zero) is untouched and
+* live is corrected.
+*
+* It contributes a transform step and the `media-transform` capability, so the
+* append path routes through the transform pipeline for a CMAF composition too.
+* Timescales come from the init segment's moov; the transform runs after any
+* transmux, and a decrypt step never touches the moof header, so an encrypted
+* segment is normalized the same way.
+*/
+/** After ts-transmux (100) and any decrypt-class step, before the append. */
+const ORDER = 150;
+function cmafTiming() {
+	return {
+		name: "cmaf-timing",
+		provides: [
+			"cmaf-timing",
+			"media-transform",
+			"media-time-normalized"
+		],
+		install(ctx) {
+			const timescales = /* @__PURE__ */ new Map();
+			ctx.registerTransform({
+				name: "cmaf-timing",
+				order: ORDER,
+				transform(data, meta) {
+					if (meta.contentType !== "video" && meta.contentType !== "audio") return data;
+					if (findBox(data, "moov") !== null) {
+						const scales = trackTimescales(data);
+						if (scales.size > 0) timescales.set(meta.contentType, scales);
+					}
+					if (findBox(data, "moof") !== null) {
+						const scales = timescales.get(meta.contentType);
+						if (scales !== void 0 && scales.size > 0) {
+							var _;
+							const fallback = (_ = [...scales.values()][0]) !== null && _ !== void 0 ? _ : 0;
+							normalizeTfdt(data, meta.start, scales, fallback);
+						}
+					}
+					return data;
+				}
+			});
+		}
+	};
+}
+//#endregion
+export { cmafTiming as default };

package/dist/es2015/stages/cmcd/index.js

@@ -0,0 +1,70 @@
+//#region src/stages/cmcd/index.ts
+/** The CMCD object type, inferred from the URL the request is fetching. */
+function objectType(url) {
+	if (/\.(m3u8|mpd)(\?|$)/i.test(url)) return "m";
+	if (/\.(vtt|srt)(\?|$)/i.test(url)) return "c";
+	if (/\.(aac|mp3|ac3|m4a)(\?|$)/i.test(url)) return "a";
+	return "av";
+}
+/** CMCD keys whose value is an enumerated token, sent unquoted. */
+const TOKEN_KEYS = /* @__PURE__ */ new Set([
+	"ot",
+	"sf",
+	"st"
+]);
+/**
+* Serializes CMCD keys per CTA-5004: sorted, booleans bare, tokens unquoted,
+* and true strings (sid, cid) quoted.
+*/
+function serialize(keys) {
+	return Object.keys(keys).sort().map((key) => {
+		const value = keys[key];
+		if (value === true) return key;
+		if (typeof value === "string") return TOKEN_KEYS.has(key) ? `${key}=${value}` : `${key}=${JSON.stringify(value)}`;
+		return `${key}=${value}`;
+	}).join(",");
+}
+function cmcd(options = {}) {
+	var _ref, _options$sessionId, _globalThis$crypto, _globalThis$crypto$ra, _options$mode;
+	const sessionId = (_ref = (_options$sessionId = options.sessionId) !== null && _options$sessionId !== void 0 ? _options$sessionId : (_globalThis$crypto = globalThis.crypto) === null || _globalThis$crypto === void 0 || (_globalThis$crypto$ra = _globalThis$crypto.randomUUID) === null || _globalThis$crypto$ra === void 0 ? void 0 : _globalThis$crypto$ra.call(_globalThis$crypto)) !== null && _ref !== void 0 ? _ref : `mb-${Math.random().toString(36).slice(2)}`;
+	const mode = (_options$mode = options.mode) !== null && _options$mode !== void 0 ? _options$mode : "query";
+	return {
+		name: "cmcd",
+		provides: ["cmcd"],
+		requires: ["transport"],
+		install(ctx) {
+			ctx.addRequestHook((req) => {
+				const state = ctx.getState();
+				const keys = {
+					sid: sessionId,
+					ot: objectType(req.url)
+				};
+				if (options.contentId !== void 0) keys.cid = options.contentId;
+				const activeId = state.quality.active;
+				if (activeId !== null && state.presentation !== null) for (const period of state.presentation.periods) for (const track of period.tracks) {
+					const rendition = track.renditions.find((r) => r.id === activeId);
+					if (rendition !== void 0) keys.br = Math.round(rendition.bitrate / 1e3);
+				}
+				const mtp = state.stats.throughputEwma;
+				if (mtp > 0) keys.mtp = Math.round(mtp / 1e3 / 100) * 100;
+				const el = ctx.element;
+				const ahead = bufferAhead(el);
+				if (ahead !== null) keys.bl = Math.round(ahead * 1e3 / 100) * 100;
+				if (ahead !== null && ahead < 1) keys.su = true;
+				const payload = serialize(keys);
+				if (mode === "header") req.headers["CMCD-Request"] = payload;
+				else {
+					const separator = req.url.includes("?") ? "&" : "?";
+					req.url = `${req.url}${separator}CMCD=${encodeURIComponent(payload)}`;
+				}
+			});
+		}
+	};
+}
+function bufferAhead(el) {
+	const { buffered, currentTime } = el;
+	for (let i = 0; i < buffered.length; i += 1) if (buffered.start(i) <= currentTime && currentTime <= buffered.end(i)) return buffered.end(i) - currentTime;
+	return null;
+}
+//#endregion
+export { cmcd as default };

package/dist/es2015/stages/codec-probe/index.js

@@ -0,0 +1,65 @@
+import { probeInitSegment } from "../../containers/codec-probe/index.js";
+//#region src/stages/codec-probe/index.ts
+/**
+* codec-probe as a loadable stage. The derivation itself lives in the
+* container layer (probeInitSegment reads the stsd sample entries and rebuilds
+* the RFC 6381 string from avcC/hvcC/esds/vpcC/dOps). This stage is the
+* runtime call site the container never had: a transform that watches init
+* segments, publishes what it derived on `engine.codecProbe`, and emits a
+* `codecprobe:detected` event.
+*
+* It also registers the composition's type probe: a rendition the manifest
+* left codec-less (a bare media playlist) gets its SourceBuffer typed from
+* its first segment instead of the bare `video/mp4` Chrome refuses. A
+* manifest that does declare codecs still creates the buffer as declared;
+* a mismatch with the probe surfaces on the event for a follow-up stage.
+*/
+/** A media segment carries a moof; only an init segment carries a moov. */
+function isInitSegment(data) {
+	for (let i = 4; i + 4 <= data.byteLength && i < 64; i += 1) if (data[i] === 109 && data[i + 1] === 111 && data[i + 2] === 111 && data[i + 3] === 118) return true;
+	return false;
+}
+function codecProbe() {
+	return {
+		name: "codec-probe",
+		provides: ["codec-probe"],
+		requires: ["mp4-box"],
+		install(ctx) {
+			let detected = [];
+			let mimeType = null;
+			ctx.registerNamespace("codecProbe", {
+				get detected() {
+					return detected;
+				},
+				get mimeType() {
+					return mimeType;
+				}
+			});
+			ctx.registerTypeProbe((bytes) => {
+				if (!isInitSegment(bytes)) return null;
+				const result = probeInitSegment(bytes);
+				return result.codecs.length > 0 ? result.mimeType : null;
+			});
+			ctx.registerTransform({
+				name: "codec-probe",
+				order: 5,
+				transform(data, meta) {
+					if (meta.contentType !== "video" && meta.contentType !== "audio") return data;
+					if (!isInitSegment(data)) return data;
+					const result = probeInitSegment(data);
+					if (result.codecs.length > 0) {
+						detected = result.codecs;
+						mimeType = result.mimeType;
+						ctx.emit("codecprobe:detected", {
+							codecs: result.codecs,
+							mimeType: result.mimeType
+						});
+					}
+					return data;
+				}
+			});
+		}
+	};
+}
+//#endregion
+export { codecProbe as default };

package/dist/es2015/stages/codec-switch/index.js

@@ -0,0 +1,48 @@
+import { canSwitchTo } from "../../kernel/rendition-select.js";
+//#region src/stages/codec-switch/index.ts
+/**
+* codec-switch: the real answer to entanglement #2's query. It registers a
+* switch policy the kernel injects into abr's telemetry; abr consumes it
+* without importing this stage. The refinement over the kernel default: a
+* changeType verdict is only returned when the browser can actually bridge
+* the two codecs, which needs both a supported target type and
+* SourceBuffer.changeType itself. Where the browser cannot, an in-family
+* change downgrades to reload rather than proposing a switch that would
+* throw at append time.
+*
+* codec-probe (declared in `requires`, resolved by the loader, never
+* imported) is the future source of exact codec strings when a manifest
+* lies; until a runtime call site exists this policy reasons over the IR's
+* declared strings, which is already a real improvement.
+*/
+/** A full MSE type string for a rendition, mime plus codecs. */
+function typeString(rendition) {
+	return rendition.codecs === null ? rendition.mimeType : `${rendition.mimeType}; codecs="${rendition.codecs}"`;
+}
+/** Whether the runtime can bridge two types without tearing the buffer down. */
+function changeTypeSupported(target) {
+	var _globalThis$SourceBuf;
+	const MediaSourceCtor = typeof MediaSource !== "undefined" ? MediaSource : globalThis.ManagedMediaSource;
+	if (MediaSourceCtor === void 0) return false;
+	if (typeof ((_globalThis$SourceBuf = globalThis.SourceBuffer) === null || _globalThis$SourceBuf === void 0 || (_globalThis$SourceBuf = _globalThis$SourceBuf.prototype) === null || _globalThis$SourceBuf === void 0 ? void 0 : _globalThis$SourceBuf.changeType) !== "function") return false;
+	return MediaSourceCtor.isTypeSupported(typeString(target));
+}
+function createPolicy() {
+	return (current, target) => {
+		const base = canSwitchTo(current, target);
+		if (base !== "changeType") return base;
+		return changeTypeSupported(target) ? "changeType" : "reload";
+	};
+}
+function codecSwitch() {
+	return {
+		name: "codec-switch",
+		provides: ["codec-switch"],
+		requires: ["mse"],
+		install(ctx) {
+			ctx.registerSwitchPolicy(createPolicy());
+		}
+	};
+}
+//#endregion
+export { createPolicy, codecSwitch as default };

package/dist/es2015/stages/content-steering/index.js

@@ -0,0 +1,179 @@
+import _objectSpread2 from "../../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+//#region src/stages/content-steering/index.ts
+const MANIFEST_TOKEN = "steering:manifest";
+const RELOAD_TOKEN = "steering:reload";
+const PATHWAY_EVENT = "steering:pathway";
+/** Failures on the active pathway before failing over. */
+const FAILOVER_AFTER = 2;
+/** Default steering manifest TTL, in seconds. */
+const DEFAULT_TTL = 300;
+const INITIAL = {
+	serverUri: null,
+	priority: [],
+	active: null,
+	dead: [],
+	fails: 0,
+	fetchPending: false,
+	tickPending: false
+};
+/** Loops a message back into the bus through a zero-delay schedule effect. */
+function feed(message) {
+	return {
+		kind: "schedule",
+		token: "steering:loopback",
+		delayMs: 0,
+		then: message
+	};
+}
+function pathwaysOf(kernel) {
+	var _kernel$presentation$, _kernel$presentation, _kernel$presentation$2, _kernel$presentation2;
+	const ids = /* @__PURE__ */ new Set();
+	for (const base of Object.keys((_kernel$presentation$ = (_kernel$presentation = kernel.presentation) === null || _kernel$presentation === void 0 || (_kernel$presentation = _kernel$presentation.steering) === null || _kernel$presentation === void 0 ? void 0 : _kernel$presentation.bases) !== null && _kernel$presentation$ !== void 0 ? _kernel$presentation$ : {})) ids.add(base);
+	for (const period of (_kernel$presentation$2 = (_kernel$presentation2 = kernel.presentation) === null || _kernel$presentation2 === void 0 ? void 0 : _kernel$presentation2.periods) !== null && _kernel$presentation$2 !== void 0 ? _kernel$presentation$2 : []) for (const track of period.tracks) for (const rendition of track.renditions) if (rendition.pathway !== void 0) ids.add(rendition.pathway);
+	return [...ids];
+}
+/** The effects that make `active` the pathway in force. */
+function applyPathway(kernel, active) {
+	var _kernel$presentation$3, _kernel$presentation3;
+	const effects = [{
+		kind: "emit",
+		event: PATHWAY_EVENT,
+		payload: { pathway: active }
+	}];
+	const excludeIds = [];
+	for (const period of (_kernel$presentation$3 = (_kernel$presentation3 = kernel.presentation) === null || _kernel$presentation3 === void 0 ? void 0 : _kernel$presentation3.periods) !== null && _kernel$presentation$3 !== void 0 ? _kernel$presentation$3 : []) for (const track of period.tracks) for (const rendition of track.renditions) if (rendition.pathway !== void 0 && rendition.pathway !== active) excludeIds.push(rendition.id);
+	effects.push(excludeIds.length > 0 ? feed({
+		type: "CONSTRAIN",
+		source: "steering",
+		constraint: { excludeIds }
+	}) : feed({
+		type: "RELEASE_CONSTRAINT",
+		source: "steering"
+	}));
+	return effects;
+}
+function choosePathway(slice, known) {
+	var _known$find;
+	for (const id of slice.priority) if (!slice.dead.includes(id) && known.includes(id)) return id;
+	return (_known$find = known.find((id) => !slice.dead.includes(id))) !== null && _known$find !== void 0 ? _known$find : null;
+}
+const reduceSteering = (slice, msg, kernel) => {
+	const state = slice !== null && slice !== void 0 ? slice : INITIAL;
+	if (msg.type === "LOAD" || msg.type === "UNLOAD" || msg.type === "DETACH") return [INITIAL, []];
+	if (msg.type === "MANIFEST_LOADED") {
+		const steering = msg.presentation.steering;
+		if (steering === void 0) return [state, []];
+		const effects = [];
+		let next = state;
+		if (state.serverUri === null) {
+			var _steering$defaultPath;
+			next = _objectSpread2(_objectSpread2({}, next), {}, {
+				serverUri: steering.serverUri,
+				active: (_steering$defaultPath = steering.defaultPathway) !== null && _steering$defaultPath !== void 0 ? _steering$defaultPath : null
+			});
+			effects.push({
+				kind: "fetch",
+				token: MANIFEST_TOKEN,
+				url: steering.serverUri
+			});
+			next = _objectSpread2(_objectSpread2({}, next), {}, { fetchPending: true });
+			if (next.active !== null) effects.push(...applyPathway(kernel, next.active));
+		}
+		return [next, effects];
+	}
+	if (msg.type === "SEGMENT_LOADED" && msg.trackId === MANIFEST_TOKEN) {
+		var _parsed$PATHWAYPRIOR;
+		let parsed;
+		try {
+			parsed = JSON.parse(new TextDecoder().decode(msg.bytes));
+		} catch (_unused) {
+			return [_objectSpread2(_objectSpread2({}, state), {}, { fetchPending: false }), []];
+		}
+		const priority = (_parsed$PATHWAYPRIOR = parsed["PATHWAY-PRIORITY"]) !== null && _parsed$PATHWAYPRIOR !== void 0 ? _parsed$PATHWAYPRIOR : [];
+		let next = _objectSpread2(_objectSpread2({}, state), {}, {
+			priority,
+			dead: [],
+			fails: 0,
+			fetchPending: false
+		});
+		const effects = [];
+		const chosen = choosePathway(next, pathwaysOf(kernel));
+		if (chosen !== null && chosen !== state.active) {
+			next = _objectSpread2(_objectSpread2({}, next), {}, { active: chosen });
+			effects.push(...applyPathway(kernel, chosen));
+		}
+		if (!next.tickPending) {
+			var _parsed$TTL;
+			effects.push({
+				kind: "schedule",
+				token: RELOAD_TOKEN,
+				delayMs: ((_parsed$TTL = parsed.TTL) !== null && _parsed$TTL !== void 0 ? _parsed$TTL : DEFAULT_TTL) * 1e3,
+				then: {
+					type: "TICK",
+					token: RELOAD_TOKEN
+				}
+			});
+			next = _objectSpread2(_objectSpread2({}, next), {}, { tickPending: true });
+		}
+		return [next, effects];
+	}
+	if (msg.type === "TICK" && msg.token === RELOAD_TOKEN) {
+		if (state.serverUri === null) return [_objectSpread2(_objectSpread2({}, state), {}, { tickPending: false }), []];
+		return [_objectSpread2(_objectSpread2({}, state), {}, {
+			tickPending: false,
+			fetchPending: true
+		}), [{
+			kind: "fetch",
+			token: MANIFEST_TOKEN,
+			url: state.serverUri
+		}]];
+	}
+	if (msg.type === "SEGMENT_FAILED" && msg.renditionId !== void 0 && state.active !== null) {
+		const fails = state.fails + 1;
+		if (fails < FAILOVER_AFTER) return [_objectSpread2(_objectSpread2({}, state), {}, { fails }), []];
+		const dead = [...state.dead, state.active];
+		const next = _objectSpread2(_objectSpread2({}, state), {}, {
+			dead,
+			fails: 0
+		});
+		const chosen = choosePathway(next, pathwaysOf(kernel));
+		if (chosen === null || chosen === state.active) return [next, []];
+		return [_objectSpread2(_objectSpread2({}, next), {}, { active: chosen }), [{
+			kind: "emit",
+			event: "steering:failover",
+			payload: {
+				from: state.active,
+				to: chosen
+			}
+		}, ...applyPathway(kernel, chosen)]];
+	}
+	return [state, []];
+};
+/** The stage factory. */
+function contentSteering() {
+	return {
+		name: "content-steering",
+		provides: ["content-steering"],
+		requires: ["transport"],
+		install(ctx) {
+			ctx.reduce("steering", reduceSteering);
+			let activeBase = null;
+			let bases = {};
+			ctx.on(PATHWAY_EVENT, (payload) => {
+				var _ctx$getState$present, _ctx$getState$present2, _bases$pathway;
+				const pathway = payload.pathway;
+				bases = (_ctx$getState$present = (_ctx$getState$present2 = ctx.getState().presentation) === null || _ctx$getState$present2 === void 0 || (_ctx$getState$present2 = _ctx$getState$present2.steering) === null || _ctx$getState$present2 === void 0 ? void 0 : _ctx$getState$present2.bases) !== null && _ctx$getState$present !== void 0 ? _ctx$getState$present : {};
+				activeBase = pathway !== void 0 ? (_bases$pathway = bases[pathway]) !== null && _bases$pathway !== void 0 ? _bases$pathway : null : null;
+			});
+			ctx.addRequestHook((req) => {
+				if (activeBase === null) return;
+				for (const base of Object.values(bases)) if (base !== activeBase && req.url.startsWith(base)) {
+					req.url = activeBase + req.url.slice(base.length);
+					return;
+				}
+			});
+		}
+	};
+}
+//#endregion
+export { contentSteering as default };

package/dist/es2015/stages/drm-shared.js

@@ -0,0 +1,18 @@
+//#region src/stages/drm-shared.ts
+const handlers = /* @__PURE__ */ new Map();
+/** Registers a handler, keyed by its key system; a repeat replaces. */
+function registerKeySystem(handler) {
+	handlers.set(handler.keySystem, handler);
+}
+/** Every registered handler. eme-core reads this when choosing a key system. */
+function keySystemHandlers() {
+	return [...handlers.values()];
+}
+/** Normalizes a ContentProtection schemeIdUri or systemId to a bare lowercase UUID. */
+function normalizeSystemId(raw) {
+	if (raw === null) return null;
+	const match = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i.exec(raw);
+	return match !== null ? match[1].toLowerCase() : null;
+}
+//#endregion
+export { keySystemHandlers, normalizeSystemId, registerKeySystem };

package/dist/es2015/stages/eme-cenc/index.js

@@ -0,0 +1,46 @@
+import { registerKeySystem } from "../drm-shared.js";
+//#region src/stages/eme-cenc/index.ts
+const WIDEVINE_SYSTEM_ID = "edef8ba9-79d6-4ace-a3c8-27dcd51d21ed";
+const PLAYREADY_SYSTEM_ID = "9a04f079-9840-4286-ab92-e65be0885f95";
+/** Pulls the license blob out of a PlayReady SOAP response, or passes bytes through. */
+function unwrapPlayReadyResponse(response) {
+	const text = new TextDecoder().decode(response);
+	if (!text.includes("<License>")) return response;
+	const match = /<License>([\s\S]*?)<\/License>/.exec(text);
+	if (match === null) return response;
+	const binary = atob(match[1].trim());
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
+	return bytes;
+}
+function emeCenc() {
+	return {
+		name: "eme-cenc",
+		provides: ["eme-cenc"],
+		requires: ["eme-core"],
+		install() {
+			registerKeySystem({
+				keySystem: "com.widevine.alpha",
+				systemIds: [WIDEVINE_SYSTEM_ID],
+				initDataTypes: ["cenc"],
+				robustness: ["SW_SECURE_CRYPTO", ""],
+				buildLicenseRequest: (message) => message,
+				parseLicenseResponse: (response) => response
+			});
+			registerKeySystem({
+				keySystem: "com.microsoft.playready",
+				systemIds: [PLAYREADY_SYSTEM_ID],
+				initDataTypes: ["cenc"],
+				robustness: ["3000", ""],
+				licenseHeaders: {
+					"Content-Type": "text/xml; charset=utf-8",
+					SOAPAction: "\"http://schemas.microsoft.com/DRM/2007/03/protocols/AcquireLicense\""
+				},
+				buildLicenseRequest: (message) => message,
+				parseLicenseResponse: unwrapPlayReadyResponse
+			});
+		}
+	};
+}
+//#endregion
+export { emeCenc as default, unwrapPlayReadyResponse };