mattebox 0.1.0

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

@@ -0,0 +1,237 @@
+import _objectSpread2 from "../../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+import _asyncToGenerator from "../../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/asyncToGenerator.js";
+import { keySystemHandlers, normalizeSystemId } from "../drm-shared.js";
+//#region src/stages/eme-core/index.ts
+const CLEARKEY = "org.w3.clearkey";
+function bytesToBase64Url(bytes) {
+	let binary = "";
+	for (const b of bytes) binary += String.fromCharCode(b);
+	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+/** A ClearKey handler: the license is a JSON the app answers from its keys. */
+function clearKeyHandler(clearKeys) {
+	return {
+		keySystem: CLEARKEY,
+		systemIds: ["1077efec-c0b2-4d02-ace3-3c1e52e2fb4b"],
+		initDataTypes: ["cenc", "keyids"],
+		localLicense: true,
+		buildLicenseRequest(message) {
+			var _request$kids;
+			const keys = ((_request$kids = JSON.parse(new TextDecoder().decode(message)).kids) !== null && _request$kids !== void 0 ? _request$kids : []).filter((kid) => clearKeys[kid] !== void 0).map((kid) => ({
+				kty: "oct",
+				kid,
+				k: clearKeys[kid]
+			}));
+			return new TextEncoder().encode(JSON.stringify({
+				keys,
+				type: "temporary"
+			}));
+		},
+		parseLicenseResponse(response) {
+			return response;
+		}
+	};
+}
+/** The MSE capability config for requestMediaKeySystemAccess. */
+function accessConfig(handler) {
+	return (handler.robustness && handler.robustness.length > 0 ? handler.robustness : [""]).map((robustness) => ({
+		initDataTypes: [...handler.initDataTypes],
+		videoCapabilities: [{
+			contentType: "video/mp4; codecs=\"avc1.42c01e\"",
+			robustness
+		}, {
+			contentType: "video/mp4; codecs=\"vp09.00.10.08\"",
+			robustness
+		}],
+		audioCapabilities: [{
+			contentType: "audio/mp4; codecs=\"mp4a.40.2\"",
+			robustness
+		}, {
+			contentType: "audio/mp4; codecs=\"opus\"",
+			robustness
+		}]
+	}));
+}
+function emeCore(options = {}) {
+	return {
+		name: "eme-core",
+		provides: ["eme-core"],
+		requires: ["mse"],
+		install(ctx) {
+			var _options$licenseUrl;
+			const element = ctx.element;
+			let mediaKeys = null;
+			let keySystem = null;
+			let handler = null;
+			let licenseUrl = (_options$licenseUrl = options.licenseUrl) !== null && _options$licenseUrl !== void 0 ? _options$licenseUrl : null;
+			const sessionsByKey = /* @__PURE__ */ new Map();
+			const statuses = /* @__PURE__ */ new Map();
+			const initDataSeen = /* @__PURE__ */ new Set();
+			let disposed = false;
+			ctx.registerNamespace("drm", {
+				get keySystem() {
+					return keySystem;
+				},
+				get sessions() {
+					return [...statuses.entries()].map(([keyId, status]) => ({
+						keyId,
+						status
+					}));
+				},
+				setLicenseUrl(url) {
+					licenseUrl = url;
+				}
+			});
+			function fail(code, recoverable, cause) {
+				ctx.emit("error", _objectSpread2({
+					category: "drm",
+					code,
+					fatal: !recoverable,
+					recoverable
+				}, cause !== void 0 ? { context: { message: String(cause) } } : {}));
+			}
+			/** All handlers eme-core can use: ClearKey plus whatever registered. */
+			function allHandlers() {
+				const registered = keySystemHandlers();
+				const clearKeys = options.clearKeys;
+				return clearKeys !== void 0 ? [clearKeyHandler(clearKeys), ...registered] : [...registered];
+			}
+			/** Chooses and initializes a key system for the given systemIds. */
+			function ensureKeys(_x) {
+				return _ensureKeys.apply(this, arguments);
+			}
+			function _ensureKeys() {
+				_ensureKeys = _asyncToGenerator(function* (preferredSystemIds) {
+					if (mediaKeys !== null) return true;
+					const handlers = allHandlers();
+					const ordered = options.preferredKeySystems ? [...handlers].sort((a, b) => options.preferredKeySystems.indexOf(a.keySystem) - options.preferredKeySystems.indexOf(b.keySystem)) : handlers;
+					const candidates = preferredSystemIds.length > 0 ? ordered.filter((h) => h.systemIds.some((id) => preferredSystemIds.includes(id))) : ordered;
+					for (const candidate of candidates.length > 0 ? candidates : ordered) try {
+						var _candidate$fairplay;
+						const keys = yield (yield navigator.requestMediaKeySystemAccess(candidate.keySystem, accessConfig(candidate))).createMediaKeys();
+						if (disposed) return false;
+						if (((_candidate$fairplay = candidate.fairplay) === null || _candidate$fairplay === void 0 ? void 0 : _candidate$fairplay.certificateUrl) !== void 0) {
+							const cert = yield ctx.request(candidate.fairplay.certificateUrl, {}).then((r) => r.arrayBuffer());
+							yield keys.setServerCertificate(cert);
+						}
+						yield element.setMediaKeys(keys);
+						mediaKeys = keys;
+						keySystem = candidate.keySystem;
+						handler = candidate;
+						ctx.emit("drm:keysystem", { keySystem });
+						return true;
+					} catch (_unused) {}
+					fail("DRM_KEY_SYSTEM_UNAVAILABLE", false);
+					return false;
+				});
+				return _ensureKeys.apply(this, arguments);
+			}
+			/** Opens a session for one init data blob, deduped by key id. */
+			function openSession(_x2, _x3) {
+				return _openSession.apply(this, arguments);
+			}
+			function _openSession() {
+				_openSession = _asyncToGenerator(function* (initDataType, initData) {
+					if (mediaKeys === null || handler === null || disposed) return;
+					const fingerprint = `${initDataType}:${bytesToBase64Url(new Uint8Array(initData))}`;
+					if (initDataSeen.has(fingerprint)) return;
+					initDataSeen.add(fingerprint);
+					let session;
+					try {
+						session = mediaKeys.createSession("temporary");
+					} catch (err) {
+						fail("DRM_SESSION_FAILED", false, err);
+						return;
+					}
+					session.addEventListener("message", (event) => {
+						onMessage(session, event);
+					});
+					session.addEventListener("keystatuseschange", () => onKeyStatus(session));
+					try {
+						yield session.generateRequest(initDataType, initData);
+					} catch (err) {
+						fail("DRM_INIT_DATA_INVALID", false, err);
+					}
+				});
+				return _openSession.apply(this, arguments);
+			}
+			function onMessage(_x4, _x5) {
+				return _onMessage.apply(this, arguments);
+			}
+			function _onMessage() {
+				_onMessage = _asyncToGenerator(function* (session, event) {
+					if (handler === null) return;
+					try {
+						var _options$licenseUrls, _options$licenseUrls2, _keySystem2;
+						let body = handler.buildLicenseRequest(event.message);
+						if (handler.localLicense === true) {
+							yield session.update(body instanceof Uint8Array ? new Uint8Array(body) : body);
+							return;
+						}
+						if (options.requestFilter !== void 0) {
+							var _keySystem;
+							body = options.requestFilter(new Uint8Array(body), (_keySystem = keySystem) !== null && _keySystem !== void 0 ? _keySystem : "");
+						}
+						const url = (_options$licenseUrls = (_options$licenseUrls2 = options.licenseUrls) === null || _options$licenseUrls2 === void 0 ? void 0 : _options$licenseUrls2[(_keySystem2 = keySystem) !== null && _keySystem2 !== void 0 ? _keySystem2 : ""]) !== null && _options$licenseUrls !== void 0 ? _options$licenseUrls : licenseUrl;
+						if (url === null || url === void 0) {
+							fail("DRM_LICENSE_FAILED", false, "no license url");
+							return;
+						}
+						const response = yield ctx.request(url, {
+							method: "POST",
+							headers: _objectSpread2({}, handler.licenseHeaders),
+							body
+						});
+						if (!response.ok) {
+							fail("DRM_LICENSE_FAILED", true, `status ${response.status}`);
+							return;
+						}
+						const raw = handler.parseLicenseResponse(yield response.arrayBuffer());
+						yield session.update(raw instanceof Uint8Array ? new Uint8Array(raw) : raw);
+					} catch (err) {
+						fail("DRM_LICENSE_FAILED", true, err);
+					}
+				});
+				return _onMessage.apply(this, arguments);
+			}
+			function onKeyStatus(session) {
+				session.keyStatuses.forEach((status, keyIdBuffer) => {
+					const keyId = bytesToBase64Url(new Uint8Array(keyIdBuffer));
+					statuses.set(keyId, status);
+					sessionsByKey.set(keyId, session);
+					ctx.emit("drm:keystatus", {
+						keyId,
+						status
+					});
+					if (status === "expired") fail("DRM_KEY_EXPIRED", true);
+					else if (status === "output-restricted") fail("DRM_OUTPUT_RESTRICTED", false);
+					else if (status === "internal-error") fail("DRM_KEY_STATUS_ERROR", false);
+				});
+			}
+			const onEncrypted = (event) => {
+				const e = event;
+				if (e.initData === null) return;
+				ensureKeys([]).then((ok) => {
+					if (ok) openSession(e.initDataType, e.initData);
+				});
+			};
+			element.addEventListener("encrypted", onEncrypted);
+			const offManifest = ctx.on("presentation:protection", (payload) => {
+				const schemes = payload;
+				ensureKeys(schemes.map((s) => normalizeSystemId(s.systemId)).filter((id) => id !== null)).then((ok) => {
+					if (!ok) return;
+					for (const scheme of schemes) if (scheme.initData !== null && scheme.initDataType !== null) openSession(scheme.initDataType, scheme.initData);
+				});
+			});
+			return () => {
+				disposed = true;
+				element.removeEventListener("encrypted", onEncrypted);
+				offManifest();
+				for (const session of sessionsByKey.values()) session.close().catch(() => {});
+				element.setMediaKeys(null).catch(() => {});
+			};
+		}
+	};
+}
+//#endregion
+export { emeCore as default };

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

@@ -0,0 +1,52 @@
+import _objectSpread2 from "../../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+import { registerKeySystem } from "../drm-shared.js";
+//#region src/stages/eme-fairplay/index.ts
+const FAIRPLAY_SYSTEM_ID = "94ce86fb-07ff-4f43-adb8-93d2fa968ca2";
+/** The content id from a skd:// init data blob: the URI's opaque tail. */
+function contentIdFromSkd(initData) {
+	const text = new TextDecoder().decode(initData);
+	const match = /skd:\/\/(.+)$/.exec(text.trim());
+	return match !== null ? match[1] : text.trim();
+}
+/** Wraps the SPC as the `spc=` form body Apple's key servers expect. */
+function buildSpcRequest(message) {
+	let binary = "";
+	for (const b of new Uint8Array(message)) binary += String.fromCharCode(b);
+	const spc = btoa(binary);
+	return new TextEncoder().encode(`spc=${encodeURIComponent(spc)}`);
+}
+/** Decodes a CKC form/base64 response into the bytes session.update wants. */
+function parseCkcResponse(response) {
+	var _exec$, _exec;
+	const text = new TextDecoder().decode(response).trim();
+	const b64 = (_exec$ = (_exec = /^ckc=(.+)$/.exec(text)) === null || _exec === void 0 ? void 0 : _exec[1]) !== null && _exec$ !== void 0 ? _exec$ : /^[A-Za-z0-9+/=]+$/.test(text) ? text : null;
+	if (b64 === null) return response;
+	try {
+		const binary = atob(decodeURIComponent(b64));
+		const bytes = new Uint8Array(binary.length);
+		for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
+		return bytes;
+	} catch (_unused) {
+		return response;
+	}
+}
+function emeFairplay(options = {}) {
+	return {
+		name: "eme-fairplay",
+		provides: ["eme-fairplay"],
+		requires: ["eme-core"],
+		install() {
+			registerKeySystem({
+				keySystem: "com.apple.fps",
+				systemIds: [FAIRPLAY_SYSTEM_ID],
+				initDataTypes: ["sinf", "skd"],
+				licenseHeaders: { "Content-Type": "application/x-www-form-urlencoded" },
+				buildLicenseRequest: buildSpcRequest,
+				parseLicenseResponse: parseCkcResponse,
+				fairplay: _objectSpread2(_objectSpread2({}, options.certificateUrl !== void 0 ? { certificateUrl: options.certificateUrl } : {}), {}, { contentId: contentIdFromSkd })
+			});
+		}
+	};
+}
+//#endregion
+export { buildSpcRequest, contentIdFromSkd, emeFairplay as default, parseCkcResponse };

package/dist/es2015/stages/meta-id3/index.js

@@ -0,0 +1,37 @@
+import { id3Cues } from "../../containers/id3.js";
+import { createMetadataSink } from "../../kernel/sinks/metadata-sink.js";
+//#region src/stages/meta-id3/index.ts
+/**
+* ID3 timed metadata as cues. A metadata rendition whose segments are ID3,
+* or a packed-audio segment's leading ID3 tag, becomes zero-length cues on a
+* metadata TextTrack through the same MetadataSink the emsg and DATERANGE
+* paths use. The ID3 decoding itself lives in the container layer so this
+* stage and packed-audio share it without importing each other.
+*
+* It requires `media-transform`, which ts-transmux and packed-audio both
+* provide: ID3 only reaches the engine once one of them is decoding the
+* legacy segments it rides in.
+*/
+function parseId3Segment(data, meta) {
+	return id3Cues(data, meta.start);
+}
+function metaId3() {
+	return {
+		name: "meta-id3",
+		provides: ["meta-id3", {
+			contentType: "metadata",
+			mimeType: "application/id3"
+		}],
+		requires: ["media-transform"],
+		install(ctx) {
+			ctx.registerParser("application/id3", parseId3Segment);
+			ctx.registerSink("metadata", ({ element }) => createMetadataSink({
+				element,
+				parse: parseId3Segment,
+				label: "ID3"
+			}));
+		}
+	};
+}
+//#endregion
+export { metaId3 as default };

package/dist/es2015/stages/mp4-box/index.js

@@ -0,0 +1,27 @@
+import { findBox, findBoxes, parseSidx, parseTfdt, walkBoxes } from "../../containers/mp4-box/index.js";
+//#region src/stages/mp4-box/index.ts
+/**
+* mp4-box as a loadable stage. The walker is a container-layer library used
+* across the engine; this stage exposes it on the facade as `engine.mp4box`
+* so a composition can inspect ISOBMFF box trees at runtime, which is what the
+* playground uses to make the module observable rather than a silent
+* dependency. Loading it also declares the `mp4-box` capability that
+* codec-probe and the DASH addressing stages resolve against.
+*/
+function mp4Box() {
+	return {
+		name: "mp4-box",
+		provides: ["mp4-box"],
+		install(ctx) {
+			ctx.registerNamespace("mp4box", {
+				walkBoxes,
+				findBox,
+				findBoxes,
+				parseTfdt,
+				parseSidx
+			});
+		}
+	};
+}
+//#endregion
+export { mp4Box as default };

package/dist/es2015/stages/nal-scan/index.js

@@ -0,0 +1,121 @@
+import { captionsWanted, deliverCaptions } from "../../containers/captions.js";
+import { findBox, parseTfdt } from "../../containers/mp4-box/index.js";
+import { ccTriplesFromSei } from "../../containers/sei.js";
+//#region src/stages/nal-scan/index.ts
+/**
+* nal-scan exists only to reach captions in fMP4. On native CMAF content
+* there is no transmux walking the NALs, so this stage does: it walks the
+* moof and mdat, finds the SEI NAL units in each coded sample, times them
+* from the fragment's tfdt and trun, and delivers the caption bytes to the
+* same seam ts-transmux uses. It imports mp4-box for the box reads and the
+* shared SEI decoder; it never imports text-cea608.
+*
+* It is not cheap and does not pretend to be: per entanglement #1 it loads
+* only when a caption stage needs an fMP4 SEI source, and it does zero work
+* when no caption consumer is registered.
+*/
+/** After transmux (100) so it can walk transmuxed TS output as well as native fMP4. */
+const SCAN_ORDER = 150;
+const DEFAULT_TIMESCALE = 9e4;
+const SEI_NAL_TYPE = 6;
+/** Reads sample durations and sizes from a trun, honouring its flag layout. */
+function parseTrun(payload) {
+	const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+	const flags = view.getUint32(0) & 16777215;
+	const sampleCount = view.getUint32(4);
+	let offset = 8;
+	if (flags & 1) offset += 4;
+	if (flags & 4) offset += 4;
+	const hasDuration = (flags & 256) !== 0;
+	const hasSize = (flags & 512) !== 0;
+	const hasFlags = (flags & 1024) !== 0;
+	const hasCts = (flags & 2048) !== 0;
+	const samples = [];
+	for (let i = 0; i < sampleCount; i += 1) {
+		let duration = 0;
+		let size = 0;
+		if (hasDuration) {
+			duration = view.getUint32(offset);
+			offset += 4;
+		}
+		if (hasSize) {
+			size = view.getUint32(offset);
+			offset += 4;
+		}
+		if (hasFlags) offset += 4;
+		if (hasCts) offset += 4;
+		if (offset > payload.byteLength) break;
+		samples.push({
+			duration,
+			size
+		});
+	}
+	return {
+		samples,
+		defaultDuration: DEFAULT_TIMESCALE / 30
+	};
+}
+/** Walks one AVCC sample's length-prefixed NALs, collecting the SEI units. */
+function seiOfSample(sample) {
+	const view = new DataView(sample.buffer, sample.byteOffset, sample.byteLength);
+	const sei = [];
+	let offset = 0;
+	while (offset + 4 <= sample.byteLength) {
+		var _nal$;
+		const length = view.getUint32(offset);
+		offset += 4;
+		if (length === 0 || offset + length > sample.byteLength) break;
+		const nal = sample.subarray(offset, offset + length);
+		if ((((_nal$ = nal[0]) !== null && _nal$ !== void 0 ? _nal$ : 0) & 31) === SEI_NAL_TYPE) sei.push(nal);
+		offset += length;
+	}
+	return sei;
+}
+function nalScan() {
+	let timescale = DEFAULT_TIMESCALE;
+	return {
+		name: "nal-scan",
+		provides: ["nal-scan"],
+		install(ctx) {
+			ctx.registerTransform({
+				name: "nal-scan",
+				order: SCAN_ORDER,
+				transform(data, _meta) {
+					var _parseTfdt$baseMediaD, _parseTfdt;
+					if (!captionsWanted()) return data;
+					const mdhd = findBox(data, "moov/trak/mdia/mdhd");
+					if (mdhd !== null) {
+						const view = new DataView(mdhd.payload.buffer, mdhd.payload.byteOffset, mdhd.payload.byteLength);
+						timescale = view.getUint8(0) === 1 ? view.getUint32(20) : view.getUint32(12);
+					}
+					const mdat = findBox(data, "mdat");
+					const trunBox = findBox(data, "moof/traf/trun");
+					if (mdat === null || trunBox === null) return data;
+					const tfdtBox = findBox(data, "moof/traf/tfdt");
+					const base = tfdtBox !== null ? (_parseTfdt$baseMediaD = (_parseTfdt = parseTfdt(tfdtBox.payload)) === null || _parseTfdt === void 0 ? void 0 : _parseTfdt.baseMediaDecodeTime) !== null && _parseTfdt$baseMediaD !== void 0 ? _parseTfdt$baseMediaD : 0 : 0;
+					const { samples } = parseTrun(trunBox.payload);
+					const packets = [];
+					let cursor = 0;
+					let decodeTime = base;
+					for (const sample of samples) {
+						const bytes = mdat.payload.subarray(cursor, cursor + sample.size);
+						cursor += sample.size;
+						const time = decodeTime / (timescale || DEFAULT_TIMESCALE);
+						decodeTime += sample.duration;
+						for (const sei of seiOfSample(bytes)) {
+							const triples = ccTriplesFromSei(sei);
+							if (triples.length > 0) packets.push({
+								time,
+								triples
+							});
+						}
+					}
+					deliverCaptions(packets);
+					return data;
+				}
+			});
+		}
+	};
+}
+//#endregion
+export { nalScan as default };

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

@@ -0,0 +1,34 @@
+//#region src/stages/pdt/index.ts
+function anchorOf(state) {
+	var _state$presentation;
+	const live = (_state$presentation = state.presentation) === null || _state$presentation === void 0 ? void 0 : _state$presentation.live;
+	if ((live === null || live === void 0 ? void 0 : live.dateAnchor) !== void 0) return live.dateAnchor;
+	if ((live === null || live === void 0 ? void 0 : live.availabilityStart) !== void 0) return {
+		wallClock: live.availabilityStart,
+		presentationTime: 0
+	};
+	return null;
+}
+function pdt() {
+	return {
+		name: "pdt",
+		provides: ["pdt"],
+		requires: ["timeline"],
+		install(ctx) {
+			ctx.registerNamespace("pdt", {
+				toWallClock(presentationTime) {
+					const anchor = anchorOf(ctx.getState());
+					if (anchor === null) return null;
+					return anchor.wallClock + (presentationTime - anchor.presentationTime);
+				},
+				toPresentationTime(wallClock) {
+					const anchor = anchorOf(ctx.getState());
+					if (anchor === null) return null;
+					return anchor.presentationTime + (wallClock - anchor.wallClock);
+				}
+			});
+		}
+	};
+}
+//#endregion
+export { pdt as default };