mattebox 0.1.0

package/dist/es2015/containers/ts-transmux/demux.js

@@ -0,0 +1,211 @@
+//#region src/containers/ts-transmux/demux.ts
+/**
+* MPEG-TS demux: 188-byte packets into PES payloads, grouped by elementary
+* stream. PAT names the PMT, the PMT names the elementary PIDs and their
+* stream types, and the payload-unit-start flag frames each PES. Nothing
+* here allocates per packet beyond the growing payload buffers, and every
+* loop strictly advances, so a truncated or garbage segment returns what it
+* could parse rather than throwing or spinning.
+*/
+const PACKET_SIZE = 188;
+const SYNC_BYTE = 71;
+/** MPEG-TS stream_type values this transmuxer routes. */
+const STREAM_TYPE = {
+	h264: 27,
+	aacAdts: 15,
+	mp3a: 3,
+	mp3b: 4,
+	ac3: 129,
+	metadata: 21,
+	privateData: 6
+};
+function kindOf(streamType) {
+	if (streamType === STREAM_TYPE.h264) return "video";
+	if (streamType === STREAM_TYPE.aacAdts || streamType === STREAM_TYPE.mp3a || streamType === STREAM_TYPE.mp3b || streamType === STREAM_TYPE.ac3) return "audio";
+	if (streamType === STREAM_TYPE.metadata) return "id3";
+	return null;
+}
+/** True when the buffer carries the TS sync byte at the packet cadence. */
+function looksLikeTransportStream(data) {
+	if (data.byteLength < PACKET_SIZE) return false;
+	let offset = 0;
+	while (offset + PACKET_SIZE < data.byteLength) {
+		if (data[offset] === SYNC_BYTE && data[offset + PACKET_SIZE] === SYNC_BYTE) return true;
+		offset += 1;
+		if (offset > PACKET_SIZE) return false;
+	}
+	return false;
+}
+/** Reads a 33-bit PTS/DTS field from a 5-byte PES timestamp region. */
+function readTimestamp(data, offset) {
+	var _data$offset, _data, _data2, _data3, _data4;
+	const b0 = (_data$offset = data[offset]) !== null && _data$offset !== void 0 ? _data$offset : 0;
+	const b1 = (_data = data[offset + 1]) !== null && _data !== void 0 ? _data : 0;
+	const b2 = (_data2 = data[offset + 2]) !== null && _data2 !== void 0 ? _data2 : 0;
+	const b3 = (_data3 = data[offset + 3]) !== null && _data3 !== void 0 ? _data3 : 0;
+	const b4 = (_data4 = data[offset + 4]) !== null && _data4 !== void 0 ? _data4 : 0;
+	const high = b0 >> 1 & 7;
+	const mid = (b1 << 7 | b2 >> 1) & 32767;
+	const low = (b3 << 7 | b4 >> 1) & 32767;
+	return high * 1073741824 + mid * 32768 + low;
+}
+/** Parses one completed PES accumulator into a packet with timestamps. */
+function finishPes(acc) {
+	var _buf$, _buf$2;
+	const buf = concatChunks(acc.chunks, acc.length);
+	if (buf.byteLength < 9 || buf[0] !== 0 || buf[1] !== 0 || buf[2] !== 1) return null;
+	const headerDataLength = (_buf$ = buf[8]) !== null && _buf$ !== void 0 ? _buf$ : 0;
+	const ptsDtsFlags = ((_buf$2 = buf[7]) !== null && _buf$2 !== void 0 ? _buf$2 : 0) >> 6;
+	let pts = null;
+	let dts = null;
+	if (ptsDtsFlags & 2 && buf.byteLength >= 14) {
+		pts = readTimestamp(buf, 9);
+		dts = pts;
+		if (ptsDtsFlags & 1 && buf.byteLength >= 19) dts = readTimestamp(buf, 14);
+	}
+	const payloadStart = 9 + headerDataLength;
+	const data = payloadStart <= buf.byteLength ? buf.subarray(payloadStart) : /* @__PURE__ */ new Uint8Array(0);
+	return {
+		pid: acc.pid,
+		streamType: acc.streamType,
+		kind: acc.kind,
+		pts,
+		dts,
+		data
+	};
+}
+function concatChunks(chunks, length) {
+	if (chunks.length === 1) return chunks[0];
+	const out = new Uint8Array(length);
+	let offset = 0;
+	for (const chunk of chunks) {
+		out.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return out;
+}
+function demux(data) {
+	if (!looksLikeTransportStream(data)) return {
+		video: [],
+		audio: [],
+		id3: [],
+		notTransportStream: true
+	};
+	let base = 0;
+	while (base < data.byteLength && data[base] !== SYNC_BYTE) base += 1;
+	let pmtPid = -1;
+	const streamTypes = /* @__PURE__ */ new Map();
+	const accumulators = /* @__PURE__ */ new Map();
+	const completed = [];
+	function flush(pid) {
+		const acc = accumulators.get(pid);
+		if (acc === void 0 || acc.length === 0) return;
+		const packet = finishPes(acc);
+		if (packet !== null) completed.push(packet);
+		accumulators.delete(pid);
+	}
+	for (let offset = base; offset + PACKET_SIZE <= data.byteLength; offset += PACKET_SIZE) {
+		var _data5, _data6, _data7;
+		if (data[offset] !== SYNC_BYTE) {
+			let resync = offset + 1;
+			while (resync < data.byteLength && data[resync] !== SYNC_BYTE) resync += 1;
+			offset = resync - PACKET_SIZE;
+			continue;
+		}
+		const b1 = (_data5 = data[offset + 1]) !== null && _data5 !== void 0 ? _data5 : 0;
+		const b2 = (_data6 = data[offset + 2]) !== null && _data6 !== void 0 ? _data6 : 0;
+		const b3 = (_data7 = data[offset + 3]) !== null && _data7 !== void 0 ? _data7 : 0;
+		const pusi = (b1 & 64) !== 0;
+		const pid = (b1 & 31) << 8 | b2;
+		const adaptationControl = b3 >> 4 & 3;
+		if (!((adaptationControl & 1) !== 0)) continue;
+		let payloadOffset = offset + 4;
+		if (adaptationControl & 2) {
+			var _data$payloadOffset;
+			const adaptationLength = (_data$payloadOffset = data[payloadOffset]) !== null && _data$payloadOffset !== void 0 ? _data$payloadOffset : 0;
+			payloadOffset += 1 + adaptationLength;
+		}
+		if (payloadOffset >= offset + PACKET_SIZE) continue;
+		const payload = data.subarray(payloadOffset, offset + PACKET_SIZE);
+		if (pid === 0) {
+			var _payload$;
+			const pointer = (_payload$ = payload[0]) !== null && _payload$ !== void 0 ? _payload$ : 0;
+			const section = payload.subarray(1 + pointer);
+			if (section.byteLength >= 13) {
+				var _section$, _section$2;
+				pmtPid = (((_section$ = section[10]) !== null && _section$ !== void 0 ? _section$ : 0) & 31) << 8 | ((_section$2 = section[11]) !== null && _section$2 !== void 0 ? _section$2 : 0);
+			}
+			continue;
+		}
+		if (pid === pmtPid && pusi) {
+			var _payload$2, _section$3, _section$4, _section$5, _section$6;
+			const pointer = (_payload$2 = payload[0]) !== null && _payload$2 !== void 0 ? _payload$2 : 0;
+			const section = payload.subarray(1 + pointer);
+			const sectionLength = (((_section$3 = section[1]) !== null && _section$3 !== void 0 ? _section$3 : 0) & 15) << 8 | ((_section$4 = section[2]) !== null && _section$4 !== void 0 ? _section$4 : 0);
+			let cursor = 12 + ((((_section$5 = section[10]) !== null && _section$5 !== void 0 ? _section$5 : 0) & 15) << 8 | ((_section$6 = section[11]) !== null && _section$6 !== void 0 ? _section$6 : 0));
+			const end = Math.min(3 + sectionLength - 4, section.byteLength);
+			while (cursor + 5 <= end) {
+				var _section$cursor, _section, _section2, _section3, _section4;
+				const streamType = (_section$cursor = section[cursor]) !== null && _section$cursor !== void 0 ? _section$cursor : 0;
+				const elementaryPid = (((_section = section[cursor + 1]) !== null && _section !== void 0 ? _section : 0) & 31) << 8 | ((_section2 = section[cursor + 2]) !== null && _section2 !== void 0 ? _section2 : 0);
+				const esInfoLength = (((_section3 = section[cursor + 3]) !== null && _section3 !== void 0 ? _section3 : 0) & 15) << 8 | ((_section4 = section[cursor + 4]) !== null && _section4 !== void 0 ? _section4 : 0);
+				streamTypes.set(elementaryPid, streamType);
+				cursor += 5 + esInfoLength;
+			}
+			continue;
+		}
+		const streamType = streamTypes.get(pid);
+		if (streamType === void 0) continue;
+		const kind = kindOf(streamType);
+		if (kind === null) continue;
+		if (pusi) {
+			flush(pid);
+			accumulators.set(pid, {
+				pid,
+				streamType,
+				kind,
+				chunks: [],
+				length: 0
+			});
+		}
+		const acc = accumulators.get(pid);
+		if (acc === void 0) continue;
+		acc.chunks.push(payload);
+		acc.length += payload.byteLength;
+	}
+	for (const pid of accumulators.keys()) flush(pid);
+	return {
+		video: completed.filter((p) => p.kind === "video"),
+		audio: completed.filter((p) => p.kind === "audio"),
+		id3: completed.filter((p) => p.kind === "id3"),
+		notTransportStream: false
+	};
+}
+/**
+* Corrects a 33-bit timestamp series for wrap. When a value drops by more
+* than half the range from the previous one, the counter rolled over; the
+* accumulated offset carries every later value past the wrap. The reference
+* anchors the first value so the output starts near zero regardless of where
+* in the 26.5 hour cycle the segment sits.
+*/
+function unrollTimestamps(values) {
+	const RANGE = 8589934592;
+	const HALF = 4294967296;
+	let offset = 0;
+	let previous = null;
+	const out = [];
+	for (const value of values) {
+		if (value === null) {
+			var _previous;
+			out.push((_previous = previous) !== null && _previous !== void 0 ? _previous : 0);
+			continue;
+		}
+		if (previous !== null && value + offset < previous - HALF) offset += RANGE;
+		const unrolled = value + offset;
+		out.push(unrolled);
+		previous = unrolled;
+	}
+	return out;
+}
+//#endregion
+export { STREAM_TYPE, demux, looksLikeTransportStream, unrollTimestamps };

package/dist/es2015/containers/ts-transmux/h264.js

@@ -0,0 +1,204 @@
+import _defineProperty from "../../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/defineProperty.js";
+//#region src/containers/ts-transmux/h264.ts
+/**
+* H.264 Annex B to AVCC. The elementary stream separates NAL units with
+* start codes; MSE wants them length-prefixed, with the parameter sets moved
+* into the avcC box instead of the sample data. This module splits NALs,
+* pulls the SPS and PPS, and reads the coded dimensions out of the SPS so
+* the init segment is honest. Exp-Golomb reads are bounded by the bitstream
+* length, so a truncated SPS yields zeroes rather than a runaway loop.
+*/
+const NAL_TYPE = {
+	nonIdrSlice: 1,
+	idrSlice: 5,
+	sei: 6,
+	sps: 7,
+	pps: 8,
+	accessUnitDelimiter: 9
+};
+/** Splits an Annex B buffer into raw NAL units, start codes removed. */
+function splitNalUnits(data) {
+	const nals = [];
+	const length = data.byteLength;
+	let start = -1;
+	let i = 0;
+	while (i + 2 < length) if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 1) {
+		if (start !== -1) nals.push(data.subarray(start, i));
+		i += 3;
+		start = i;
+	} else i += 1;
+	if (start !== -1 && start < length) nals.push(data.subarray(start, length));
+	return nals.filter((nal) => nal.byteLength > 0);
+}
+function nalType(nal) {
+	var _nal$;
+	return ((_nal$ = nal[0]) !== null && _nal$ !== void 0 ? _nal$ : 0) & 31;
+}
+/**
+* Turns one PES payload's NALs into an access unit. Parameter sets are
+* surfaced for the init segment and dropped from the sample; slices and SEI
+* become length-prefixed AVCC. An IDR slice marks the sample as a keyframe.
+*/
+function toAccessUnit(annexB) {
+	return accessUnitFromNals(splitNalUnits(annexB));
+}
+/**
+* Builds one access unit from its already-split NAL units. Access units do not
+* align with PES packet boundaries in the wild, so the demux splits the whole
+* elementary stream and groups NALs into units by access-unit delimiter; this
+* turns one such group into an AVCC sample.
+*/
+function accessUnitFromNals(nals) {
+	let sps = null;
+	let pps = null;
+	let isKeyframe = false;
+	const sampleNals = [];
+	const sei = [];
+	for (const nal of nals) {
+		const type = nalType(nal);
+		if (type === NAL_TYPE.sps) sps = nal;
+		else if (type === NAL_TYPE.pps) pps = nal;
+		else if (type === NAL_TYPE.accessUnitDelimiter) continue;
+		else {
+			if (type === NAL_TYPE.idrSlice) isKeyframe = true;
+			if (type === NAL_TYPE.sei) sei.push(nal);
+			sampleNals.push(nal);
+		}
+	}
+	let length = 0;
+	for (const nal of sampleNals) length += 4 + nal.byteLength;
+	const avcc = new Uint8Array(length);
+	const view = new DataView(avcc.buffer);
+	let offset = 0;
+	for (const nal of sampleNals) {
+		view.setUint32(offset, nal.byteLength);
+		avcc.set(nal, offset + 4);
+		offset += 4 + nal.byteLength;
+	}
+	return {
+		avcc,
+		isKeyframe,
+		sps,
+		pps,
+		sei
+	};
+}
+/** Strips H.264 emulation-prevention bytes (00 00 03 -> 00 00) for RBSP reads. */
+function toRbsp(nal) {
+	const out = new Uint8Array(nal.byteLength);
+	let count = 0;
+	let zeros = 0;
+	for (let i = 1; i < nal.byteLength; i += 1) {
+		const byte = nal[i];
+		if (zeros >= 2 && byte === 3) {
+			zeros = 0;
+			continue;
+		}
+		out[count] = byte;
+		count += 1;
+		zeros = byte === 0 ? zeros + 1 : 0;
+	}
+	return out.subarray(0, count);
+}
+var BitReader = class {
+	constructor(data) {
+		this.data = data;
+		_defineProperty(this, "byte", 0);
+		_defineProperty(this, "bit", 0);
+	}
+	readBit() {
+		if (this.byte >= this.data.byteLength) return 0;
+		const value = this.data[this.byte] >> 7 - this.bit & 1;
+		this.bit += 1;
+		if (this.bit === 8) {
+			this.bit = 0;
+			this.byte += 1;
+		}
+		return value;
+	}
+	readBits(count) {
+		let value = 0;
+		for (let i = 0; i < count; i += 1) value = value << 1 | this.readBit();
+		return value >>> 0;
+	}
+	/** Unsigned Exp-Golomb, bounded so a malformed stream cannot loop forever. */
+	readUe() {
+		let leadingZeros = 0;
+		while (leadingZeros < 32 && this.byte < this.data.byteLength && this.readBit() === 0) leadingZeros += 1;
+		if (leadingZeros === 0) return 0;
+		return (1 << leadingZeros) - 1 + this.readBits(leadingZeros);
+	}
+	readSe() {
+		const value = this.readUe();
+		return value & 1 ? value + 1 >> 1 : -(value >> 1);
+	}
+};
+/** Reads coded width and height from an SPS NAL, cropping applied. */
+function spsDimensions(sps) {
+	const reader = new BitReader(toRbsp(sps));
+	const profileIdc = reader.readBits(8);
+	reader.readBits(8);
+	reader.readBits(8);
+	reader.readUe();
+	let chromaFormat = 1;
+	if ([
+		100,
+		110,
+		122,
+		244,
+		44,
+		83,
+		86,
+		118,
+		128,
+		138,
+		139,
+		134,
+		135
+	].includes(profileIdc)) {
+		chromaFormat = reader.readUe();
+		if (chromaFormat === 3) reader.readBits(1);
+		reader.readUe();
+		reader.readUe();
+		reader.readBits(1);
+		if (reader.readBits(1)) {
+			const count = chromaFormat === 3 ? 12 : 8;
+			for (let i = 0; i < count; i += 1) if (reader.readBits(1)) reader.readUe();
+		}
+	}
+	reader.readUe();
+	const picOrderCntType = reader.readUe();
+	if (picOrderCntType === 0) reader.readUe();
+	else if (picOrderCntType === 1) {
+		reader.readBits(1);
+		reader.readSe();
+		reader.readSe();
+		const numRefFrames = reader.readUe();
+		for (let i = 0; i < numRefFrames && i < 256; i += 1) reader.readSe();
+	}
+	reader.readUe();
+	reader.readBits(1);
+	const picWidthInMbs = reader.readUe() + 1;
+	const picHeightInMapUnits = reader.readUe() + 1;
+	const frameMbsOnly = reader.readBits(1);
+	if (frameMbsOnly === 0) reader.readBits(1);
+	reader.readBits(1);
+	let cropLeft = 0;
+	let cropRight = 0;
+	let cropTop = 0;
+	let cropBottom = 0;
+	if (reader.readBits(1)) {
+		cropLeft = reader.readUe();
+		cropRight = reader.readUe();
+		cropTop = reader.readUe();
+		cropBottom = reader.readUe();
+	}
+	const width = picWidthInMbs * 16 - (cropLeft + cropRight) * 2;
+	const height = (2 - frameMbsOnly) * picHeightInMapUnits * 16 - (cropTop + cropBottom) * 2;
+	return {
+		width: Math.max(0, width),
+		height: Math.max(0, height)
+	};
+}
+//#endregion
+export { NAL_TYPE, accessUnitFromNals, nalType, splitNalUnits, spsDimensions, toAccessUnit };

package/dist/es2015/containers/ts-transmux/index.js

@@ -0,0 +1,37 @@
+import _asyncToGenerator from "../../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/asyncToGenerator.js";
+import { captionsWanted, deliverCaptions } from "../captions.js";
+import { looksLikeTransportStream } from "./demux.js";
+import { createTransmuxRunner } from "./runner.js";
+//#region src/containers/ts-transmux/index.ts
+/** Runs after decrypt-class steps (lower order) and before caption extraction. */
+const TRANSMUX_ORDER = 100;
+function tsTransmux(options = {}) {
+	return {
+		name: "ts-transmux",
+		provides: [
+			"ts-transmux",
+			"media-transform",
+			"media-time-normalized"
+		],
+		install(ctx) {
+			const runner = createTransmuxRunner(options);
+			ctx.registerTransform({
+				name: "ts-transmux",
+				order: TRANSMUX_ORDER,
+				transform(data, meta) {
+					return _asyncToGenerator(function* () {
+						var _result$bytes;
+						if (meta.contentType !== "video" && meta.contentType !== "audio") return data;
+						if (!looksLikeTransportStream(data)) return data;
+						const result = yield runner.run(data, meta.start, captionsWanted());
+						if (result.captions.length > 0) deliverCaptions(result.captions);
+						return (_result$bytes = result.bytes) !== null && _result$bytes !== void 0 ? _result$bytes : data;
+					})();
+				}
+			});
+			return () => runner.dispose();
+		}
+	};
+}
+//#endregion
+export { tsTransmux as default };

package/dist/es2015/containers/ts-transmux/runner.js

@@ -0,0 +1,95 @@
+import { transmux } from "./transmux.js";
+//#region src/containers/ts-transmux/runner.ts
+/**
+* The boundary between the transform step and where the demux actually runs.
+* A Worker keeps the hot path off the main thread; when the build cannot emit
+* a Worker chunk, or the environment has no Worker, or a custom-URL Worker
+* fails to start, the same pure transmux runs synchronously on the main
+* thread. Both paths call the identical function, so the bytes match whatever
+* route a given browser takes; only the timing differs.
+*/
+function runOnMainThread(bytes, presentationStart, wantCaptions) {
+	return transmux(bytes, presentationStart, wantCaptions);
+}
+function createTransmuxRunner(options = {}) {
+	let worker = null;
+	let workerBroken = options.disableWorker === true;
+	let lastPath = "main";
+	let nextId = 1;
+	const pending = /* @__PURE__ */ new Map();
+	function ensureWorker() {
+		if (workerBroken) return null;
+		if (worker !== null) return worker;
+		try {
+			worker = options.workerUrl !== void 0 ? new Worker(options.workerUrl, { type: "module" }) : new Worker(new URL("./transmux.worker.js", import.meta.url), { type: "module" });
+			worker.onmessage = (event) => {
+				const entry = pending.get(event.data.id);
+				if (entry === void 0) return;
+				pending.delete(event.data.id);
+				entry.resolve({
+					bytes: event.data.bytes === null ? null : new Uint8Array(event.data.bytes),
+					notTransportStream: event.data.notTransportStream,
+					empty: event.data.bytes === null && !event.data.notTransportStream,
+					captions: event.data.captions
+				});
+			};
+			worker.onerror = () => {
+				workerBroken = true;
+				worker = null;
+				for (const [id, entry] of pending) {
+					pending.delete(id);
+					entry.resolve(runOnMainThread(entry.bytes, entry.presentationStart, entry.wantCaptions));
+				}
+			};
+		} catch (_unused) {
+			workerBroken = true;
+			worker = null;
+		}
+		return worker;
+	}
+	return {
+		run(bytes, presentationStart, wantCaptions = false) {
+			const active = ensureWorker();
+			if (active === null) {
+				lastPath = "main";
+				return Promise.resolve(runOnMainThread(bytes, presentationStart, wantCaptions));
+			}
+			lastPath = "worker";
+			const id = nextId;
+			nextId += 1;
+			const copy = bytes.slice();
+			return new Promise((resolve) => {
+				pending.set(id, {
+					resolve,
+					bytes,
+					presentationStart,
+					wantCaptions
+				});
+				try {
+					active.postMessage({
+						id,
+						bytes: copy.buffer,
+						presentationStart,
+						wantCaptions
+					}, [copy.buffer]);
+				} catch (_unused2) {
+					pending.delete(id);
+					workerBroken = true;
+					worker = null;
+					lastPath = "main";
+					resolve(runOnMainThread(bytes, presentationStart, wantCaptions));
+				}
+			});
+		},
+		path() {
+			return lastPath;
+		},
+		dispose() {
+			worker === null || worker === void 0 || worker.terminate();
+			worker = null;
+			pending.clear();
+		}
+	};
+}
+//#endregion
+export { createTransmuxRunner };