mattebox 0.1.0

package/dist/es2015/containers/fmp4/writer.js

@@ -0,0 +1,165 @@
+//#region src/containers/fmp4/writer.ts
+function fourcc(type) {
+	return [
+		type.charCodeAt(0),
+		type.charCodeAt(1),
+		type.charCodeAt(2),
+		type.charCodeAt(3)
+	];
+}
+/** Concatenates children under a box header. Sizes are computed, never assumed. */
+function box(type, ...children) {
+	let length = 8;
+	for (const child of children) length += child.byteLength;
+	const out = new Uint8Array(length);
+	new DataView(out.buffer).setUint32(0, length);
+	out.set(fourcc(type), 4);
+	let offset = 8;
+	for (const child of children) {
+		out.set(child, offset);
+		offset += child.byteLength;
+	}
+	return out;
+}
+/** A FullBox: version byte plus 24-bit flags ahead of the payload. */
+function fullBox(type, version, flags, ...children) {
+	return box(type, u8(version, flags >> 16 & 255, flags >> 8 & 255, flags & 255), ...children);
+}
+function u8(...values) {
+	return Uint8Array.from(values, (v) => v & 255);
+}
+function u16(value) {
+	return u8(value >> 8 & 255, value & 255);
+}
+function u32(value) {
+	return u8(value >>> 24 & 255, value >> 16 & 255, value >> 8 & 255, value & 255);
+}
+/** A 64-bit unsigned as two 32-bit halves; JS numbers hold this range exactly to 2^53. */
+function u64(value) {
+	return concat(u32(Math.floor(value / 4294967296)), u32(value >>> 0));
+}
+function concat(...parts) {
+	let length = 0;
+	for (const part of parts) length += part.byteLength;
+	const out = new Uint8Array(length);
+	let offset = 0;
+	for (const part of parts) {
+		out.set(part, offset);
+		offset += part.byteLength;
+	}
+	return out;
+}
+const UNITY_MATRIX = concat(u32(65536), u32(0), u32(0), u32(0), u32(65536), u32(0), u32(0), u32(0), u32(1073741824));
+function ftyp() {
+	return box("ftyp", u8(...fourcc("isom")), u32(512), u8(...fourcc("isom")), u8(...fourcc("iso6")), u8(...fourcc("mp41")));
+}
+function avcC(config) {
+	var _sps$, _sps$2, _sps$3;
+	const { sps, pps } = config;
+	return box("avcC", u8(1, (_sps$ = sps[1]) !== null && _sps$ !== void 0 ? _sps$ : 0, (_sps$2 = sps[2]) !== null && _sps$2 !== void 0 ? _sps$2 : 0, (_sps$3 = sps[3]) !== null && _sps$3 !== void 0 ? _sps$3 : 0), u8(255), u8(225), u16(sps.byteLength), sps, u8(1), u16(pps.byteLength), pps);
+}
+function avc1(config) {
+	return box("avc1", u8(0, 0, 0, 0, 0, 0), u16(1), u16(0), u16(0), u32(0), u32(0), u32(0), u16(config.width), u16(config.height), u32(4718592), u32(4718592), u32(0), u16(1), /* @__PURE__ */ new Uint8Array(32), u16(24), u16(65535), avcC(config));
+}
+function esds(config) {
+	const asc = u8(config.audioObjectType << 3 | config.samplingFrequencyIndex >> 1, (config.samplingFrequencyIndex & 1) << 7 | config.channelConfig << 3);
+	const dsi = concat(u8(5, asc.byteLength), asc);
+	const dcd = concat(u8(4, 13 + dsi.byteLength, 64, 21), u8(0, 0, 0), u32(0), u32(0), dsi);
+	const sl = u8(6, 1, 2);
+	return fullBox("esds", 0, 0, concat(u8(3, 3 + dcd.byteLength + sl.byteLength, 0, 0, 0), dcd, sl));
+}
+function mp4a(config) {
+	return box("mp4a", u8(0, 0, 0, 0, 0, 0), u16(1), u32(0), u32(0), u16(config.channelConfig), u16(16), u16(0), u16(0), u32(config.timescale << 16 >>> 0), esds(config));
+}
+function stbl(config) {
+	const entry = config.kind === "video" ? avc1(config) : mp4a(config);
+	return box("stbl", fullBox("stsd", 0, 0, u32(1), entry), fullBox("stts", 0, 0, u32(0)), fullBox("stsc", 0, 0, u32(0)), fullBox("stsz", 0, 0, u32(0), u32(0)), fullBox("stco", 0, 0, u32(0)));
+}
+function minf(config) {
+	return box("minf", config.kind === "video" ? fullBox("vmhd", 0, 1, u16(0), u16(0), u16(0), u16(0)) : fullBox("smhd", 0, 0, u16(0), u16(0)), box("dinf", fullBox("dref", 0, 0, u32(1), fullBox("url ", 0, 1))), stbl(config));
+}
+function hdlr(config) {
+	const handler = config.kind === "video" ? "vide" : "soun";
+	const name = config.kind === "video" ? "VideoHandler" : "SoundHandler";
+	return fullBox("hdlr", 0, 0, u32(0), u8(...fourcc(handler)), u32(0), u32(0), u32(0), concat(u8(...[...name].map((c) => c.charCodeAt(0))), u8(0)));
+}
+function mdia(config) {
+	return box("mdia", fullBox("mdhd", 0, 0, u32(0), u32(0), u32(config.timescale), u32(0), u16(21956), u16(0)), hdlr(config), minf(config));
+}
+function tkhd(config) {
+	const w = config.kind === "video" ? config.width : 0;
+	const h = config.kind === "video" ? config.height : 0;
+	return fullBox("tkhd", 0, 7, u32(0), u32(0), u32(config.id), u32(0), u32(0), u32(0), u32(0), u16(0), u16(0), u16(config.kind === "audio" ? 256 : 0), u16(0), UNITY_MATRIX, u32(w << 16 >>> 0), u32(h << 16 >>> 0));
+}
+function trak(config) {
+	return box("trak", tkhd(config), mdia(config));
+}
+function mvhd(nextTrackId) {
+	return fullBox("mvhd", 0, 0, u32(0), u32(0), u32(9e4), u32(0), u32(65536), u16(256), u16(0), u32(0), u32(0), UNITY_MATRIX, concat(u32(0), u32(0), u32(0), u32(0), u32(0), u32(0)), u32(nextTrackId));
+}
+function mvex(configs) {
+	return box("mvex", ...configs.map((config) => fullBox("trex", 0, 0, u32(config.id), u32(1), u32(0), u32(0), u32(0))));
+}
+/** The init segment: ftyp then a moov describing every track. */
+function writeInitSegment(configs) {
+	let maxId = 0;
+	for (const config of configs) maxId = Math.max(maxId, config.id);
+	const moov = box("moov", mvhd(maxId + 1), ...configs.map(trak), mvex(configs));
+	return concat(ftyp(), moov);
+}
+const TRUN_FLAGS = 3841;
+const TFHD_FLAGS = 131072;
+function sampleFlags(sample) {
+	return sample.isKeyframe ? 33554432 : 16842752;
+}
+function traf(fragment, trunHead) {
+	const tfhd = fullBox("tfhd", 0, TFHD_FLAGS, u32(fragment.trackId));
+	const tfdt = fullBox("tfdt", 1, 0, u64(fragment.baseMediaDecodeTime));
+	const entries = new Uint8Array(fragment.samples.length * 16);
+	const view = new DataView(entries.buffer);
+	for (let i = 0; i < fragment.samples.length; i += 1) {
+		const sample = fragment.samples[i];
+		const base = i * 16;
+		view.setUint32(base, sample.duration);
+		view.setUint32(base + 4, sample.data.byteLength);
+		view.setUint32(base + 8, sampleFlags(sample));
+		view.setUint32(base + 12, sample.cts);
+	}
+	return box("traf", tfhd, tfdt, fullBox("trun", 1, TRUN_FLAGS, trunHead, entries));
+}
+/**
+* The moof/mdat pair for one or more track fragments. Each trun's data offset
+* is back-patched once the moof size is known, so the offsets are exact
+* regardless of how many tracks the fragment carries or how large the trafs
+* grew. The mdat interleaves tracks in the order given.
+*/
+function writeMediaSegment(sequenceNumber, fragments) {
+	const mfhd = fullBox("mfhd", 0, 0, u32(sequenceNumber));
+	const trafs = fragments.map((fragment) => traf(fragment, concat(u32(fragment.samples.length), u32(0))));
+	const moof = box("moof", mfhd, ...trafs);
+	const moofView = new DataView(moof.buffer);
+	let trafOffsetInMoof = 8 + mfhd.byteLength;
+	let mdatCursor = moof.byteLength + 8;
+	for (const [i, fragment] of fragments.entries()) {
+		const thisTraf = trafs[i];
+		const trunDataOffsetPos = trafOffsetInMoof + 8 + 16 + 20 + 8 + 4 + 4;
+		moofView.setUint32(trunDataOffsetPos, mdatCursor);
+		let fragmentBytes = 0;
+		for (const sample of fragment.samples) fragmentBytes += sample.data.byteLength;
+		mdatCursor += fragmentBytes;
+		trafOffsetInMoof += thisTraf.byteLength;
+	}
+	let mdatLength = 0;
+	for (const fragment of fragments) for (const sample of fragment.samples) mdatLength += sample.data.byteLength;
+	const mdat = new Uint8Array(8 + mdatLength);
+	new DataView(mdat.buffer).setUint32(0, mdat.byteLength);
+	mdat.set(fourcc("mdat"), 4);
+	let offset = 8;
+	for (const fragment of fragments) for (const sample of fragment.samples) {
+		mdat.set(sample.data, offset);
+		offset += sample.data.byteLength;
+	}
+	return concat(moof, mdat);
+}
+//#endregion
+export { writeInitSegment, writeMediaSegment };

package/dist/es2015/containers/id3.js

@@ -0,0 +1,72 @@
+import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+//#region src/containers/id3.ts
+const HEADER_SIZE = 10;
+function isId3(data, offset) {
+	return data[offset] === 73 && data[offset + 1] === 68 && data[offset + 2] === 51;
+}
+/** A 28-bit synchsafe integer: four bytes, seven bits each. */
+function synchsafe(data, offset) {
+	var _data$offset, _data, _data2, _data3;
+	return ((_data$offset = data[offset]) !== null && _data$offset !== void 0 ? _data$offset : 0) << 21 | ((_data = data[offset + 1]) !== null && _data !== void 0 ? _data : 0) << 14 | ((_data2 = data[offset + 2]) !== null && _data2 !== void 0 ? _data2 : 0) << 7 | ((_data3 = data[offset + 3]) !== null && _data3 !== void 0 ? _data3 : 0);
+}
+/** The full byte length of the ID3v2 tag at `offset`, or zero if none is there. */
+function id3TagLength(data, offset = 0) {
+	if (offset + HEADER_SIZE > data.byteLength || !isId3(data, offset)) return 0;
+	const size = synchsafe(data, offset + 6);
+	const total = HEADER_SIZE + size;
+	return offset + total <= data.byteLength ? total : 0;
+}
+function frameSize(data, offset, major) {
+	var _data$offset2, _data4, _data5, _data6;
+	if (major >= 4) return synchsafe(data, offset);
+	return ((_data$offset2 = data[offset]) !== null && _data$offset2 !== void 0 ? _data$offset2 : 0) << 24 | ((_data4 = data[offset + 1]) !== null && _data4 !== void 0 ? _data4 : 0) << 16 | ((_data5 = data[offset + 2]) !== null && _data5 !== void 0 ? _data5 : 0) << 8 | ((_data6 = data[offset + 3]) !== null && _data6 !== void 0 ? _data6 : 0);
+}
+/** Parses the frames of one ID3v2 tag. Stops at padding or a bad frame. */
+function parseId3Frames(data, offset = 0) {
+	var _data7;
+	const total = id3TagLength(data, offset);
+	if (total === 0) return [];
+	const major = (_data7 = data[offset + 3]) !== null && _data7 !== void 0 ? _data7 : 0;
+	const frames = [];
+	let cursor = offset + HEADER_SIZE;
+	const end = offset + total;
+	while (cursor + 10 <= end) {
+		var _data$cursor, _data8, _data9, _data10;
+		const id = String.fromCharCode((_data$cursor = data[cursor]) !== null && _data$cursor !== void 0 ? _data$cursor : 0, (_data8 = data[cursor + 1]) !== null && _data8 !== void 0 ? _data8 : 0, (_data9 = data[cursor + 2]) !== null && _data9 !== void 0 ? _data9 : 0, (_data10 = data[cursor + 3]) !== null && _data10 !== void 0 ? _data10 : 0);
+		if (data[cursor] === 0) break;
+		const size = frameSize(data, cursor + 4, major);
+		if (size <= 0 || cursor + 10 + size > end) break;
+		frames.push({
+			id,
+			data: data.subarray(cursor + 10, cursor + 10 + size)
+		});
+		cursor += 10 + size;
+	}
+	return frames;
+}
+function decodeTextFrame(frame) {
+	var _frame$data$;
+	const encoding = (_frame$data$ = frame.data[0]) !== null && _frame$data$ !== void 0 ? _frame$data$ : 0;
+	const body = frame.data.subarray(1);
+	return new TextDecoder(encoding === 1 || encoding === 2 ? "utf-16" : "utf-8").decode(body).replace(/\0+$/, "");
+}
+/**
+* Turns an ID3 tag's frames into metadata cues at `presentationTime`. Text
+* frames carry their decoded string; every frame keeps its raw bytes on the
+* payload so a consumer can read a format this decoder does not special-case.
+* The cues are zero-length, which is how timed metadata is represented.
+*/
+function id3Cues(data, presentationTime, offset = 0) {
+	return parseId3Frames(data, offset).map((frame) => {
+		return {
+			start: presentationTime,
+			end: presentationTime,
+			payload: _objectSpread2({
+				key: frame.id,
+				data: [...frame.data]
+			}, frame.id.startsWith("T") || frame.id === "WXXX" ? { value: decodeTextFrame(frame) } : {})
+		};
+	});
+}
+//#endregion
+export { id3Cues, id3TagLength, parseId3Frames };

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

@@ -0,0 +1,209 @@
+//#region src/containers/mp4-box/index.ts
+/** Container boxes the walker descends into. Only ancestors of consumed boxes. */
+const CONTAINERS = /* @__PURE__ */ new Set([
+	"moov",
+	"trak",
+	"mdia",
+	"minf",
+	"stbl",
+	"moof",
+	"traf"
+]);
+function malformed(reason, offset) {
+	return {
+		category: "media",
+		code: "MEDIA_CONTAINER_INVALID",
+		fatal: false,
+		recoverable: false,
+		context: {
+			reason,
+			offset
+		}
+	};
+}
+function fourcc(view, offset) {
+	return String.fromCharCode(view.getUint8(offset), view.getUint8(offset + 1), view.getUint8(offset + 2), view.getUint8(offset + 3));
+}
+/**
+* Walks one level plus known containers, depth-first. The visitor sees
+* every box; returning false stops the walk early without error.
+*/
+function walkBoxes(data, visit) {
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	function level(start, end, path) {
+		let offset = start;
+		while (offset < end) {
+			if (end - offset < 8) return malformed("truncated box header", offset);
+			let size = view.getUint32(offset);
+			let headerSize = 8;
+			const type = fourcc(view, offset + 4);
+			if (size === 1) {
+				if (end - offset < 16) return malformed("truncated 64-bit size", offset);
+				const big = view.getBigUint64(offset + 8);
+				if (big > BigInt(Number.MAX_SAFE_INTEGER)) return malformed("size overflow", offset);
+				size = Number(big);
+				headerSize = 16;
+			} else if (size === 0) size = end - offset;
+			if (size < headerSize) return malformed("box size smaller than header", offset);
+			if (offset + size > end) return malformed("box extends past its container", offset);
+			const payload = data.subarray(offset + headerSize, offset + size);
+			if (visit({
+				type,
+				start: offset,
+				size,
+				headerSize,
+				payload,
+				path
+			}) === false) return "stop";
+			if (CONTAINERS.has(type)) {
+				const nested = level(offset + headerSize, offset + size, path === "" ? type : `${path}/${type}`);
+				if (nested !== null) return nested;
+			}
+			offset += size;
+		}
+		return null;
+	}
+	const outcome = level(0, data.byteLength, "");
+	return { error: outcome === "stop" || outcome === null ? null : outcome };
+}
+/** The first box matching a slash path such as 'moov/trak/mdia/minf/stbl/stsd'. */
+function findBox(data, path) {
+	let found = null;
+	const parent = path.includes("/") ? path.slice(0, path.lastIndexOf("/")) : "";
+	const leaf = path.includes("/") ? path.slice(path.lastIndexOf("/") + 1) : path;
+	walkBoxes(data, (box) => {
+		if (box.path === parent && box.type === leaf) {
+			found = box;
+			return false;
+		}
+	});
+	return found;
+}
+/** Every box matching the path, in document order. trak repeats, for one. */
+function findBoxes(data, path) {
+	const out = [];
+	const parent = path.includes("/") ? path.slice(0, path.lastIndexOf("/")) : "";
+	const leaf = path.includes("/") ? path.slice(path.lastIndexOf("/") + 1) : path;
+	walkBoxes(data, (box) => {
+		if (box.path === parent && box.type === leaf) out.push(box);
+	});
+	return out;
+}
+/** Splits a FullBox payload into version, 24-bit flags, and the body view. */
+function fullBox(payload) {
+	if (payload.byteLength < 4) return null;
+	return {
+		version: payload[0],
+		flags: payload[1] << 16 | payload[2] << 8 | payload[3],
+		body: payload.subarray(4)
+	};
+}
+/** tfdt: version 1 widens baseMediaDecodeTime to 64 bits. */
+function parseTfdt(payload) {
+	const header = fullBox(payload);
+	if (header === null) return null;
+	const view = new DataView(header.body.buffer, header.body.byteOffset, header.body.byteLength);
+	if (header.version === 1) {
+		if (header.body.byteLength < 8) return null;
+		return {
+			version: 1,
+			baseMediaDecodeTime: Number(view.getBigUint64(0))
+		};
+	}
+	if (header.body.byteLength < 4) return null;
+	return {
+		version: 0,
+		baseMediaDecodeTime: view.getUint32(0)
+	};
+}
+/** sidx: version 1 widens the time and offset fields to 64 bits. */
+function parseSidx(payload) {
+	const header = fullBox(payload);
+	if (header === null) return null;
+	const body = header.body;
+	const view = new DataView(body.buffer, body.byteOffset, body.byteLength);
+	const wide = header.version === 1;
+	const fixed = 8 + (wide ? 16 : 8) + 4;
+	if (body.byteLength < fixed) return null;
+	const referenceId = view.getUint32(0);
+	const timescale = view.getUint32(4);
+	let at = 8;
+	const earliestPresentationTime = wide ? Number(view.getBigUint64(at)) : view.getUint32(at);
+	at += wide ? 8 : 4;
+	const firstOffset = wide ? Number(view.getBigUint64(at)) : view.getUint32(at);
+	at += wide ? 8 : 4;
+	at += 2;
+	const count = view.getUint16(at);
+	at += 2;
+	if (body.byteLength < at + count * 12) return null;
+	const references = [];
+	for (let i = 0; i < count; i += 1) {
+		const word = view.getUint32(at);
+		references.push({
+			referencedSize: word & 2147483647,
+			subsegmentDuration: view.getUint32(at + 4),
+			startsWithSap: (view.getUint32(at + 8) & 2147483648) !== 0
+		});
+		at += 12;
+	}
+	return {
+		version: header.version,
+		referenceId,
+		timescale,
+		earliestPresentationTime,
+		firstOffset,
+		references
+	};
+}
+/**
+* The media timescale of each track, read from moov/trak (tkhd track id paired
+* with mdhd timescale). CMAF timing normalization needs it to convert a
+* baseMediaDecodeTime between timescale units and seconds.
+*/
+function trackTimescales(init) {
+	const map = /* @__PURE__ */ new Map();
+	for (const trak of findBoxes(init, "moov/trak")) {
+		const tkhd = findBox(trak.payload, "tkhd");
+		const mdhd = findBox(trak.payload, "mdia/mdhd");
+		if (tkhd === null || mdhd === null) continue;
+		const tkView = new DataView(tkhd.payload.buffer, tkhd.payload.byteOffset, tkhd.payload.byteLength);
+		const mdView = new DataView(mdhd.payload.buffer, mdhd.payload.byteOffset, mdhd.payload.byteLength);
+		const trackAt = tkhd.payload[0] === 1 ? 20 : 12;
+		const scaleAt = mdhd.payload[0] === 1 ? 20 : 12;
+		if (tkhd.payload.byteLength < trackAt + 4 || mdhd.payload.byteLength < scaleAt + 4) continue;
+		const trackId = tkView.getUint32(trackAt);
+		const timescale = mdView.getUint32(scaleAt);
+		if (timescale > 0) map.set(trackId, timescale);
+	}
+	return map;
+}
+/**
+* Rewrites every traf's tfdt baseMediaDecodeTime in place so the segment's
+* media clock equals its presentation start. A CMAF live segment carries the
+* real broadcast clock (a huge value); appended with a zero timestampOffset it
+* would land far off the playhead. Normalizing it to `presentationStart` makes
+* the segment land exactly where the manifest places it, the same alignment a
+* TS transmux gives for free. Returns the number of tfdt boxes rewritten.
+*/
+function normalizeTfdt(segment, presentationStart, timescales, fallbackTimescale) {
+	let rewritten = 0;
+	for (const traf of findBoxes(segment, "moof/traf")) {
+		var _ref;
+		const tfdt = findBox(traf.payload, "tfdt");
+		if (tfdt === null) continue;
+		const tfhd = findBox(traf.payload, "tfhd");
+		const trackId = tfhd !== null && tfhd.payload.byteLength >= 8 ? new DataView(tfhd.payload.buffer, tfhd.payload.byteOffset, tfhd.payload.byteLength).getUint32(4) : null;
+		const timescale = (_ref = trackId !== null ? timescales.get(trackId) : void 0) !== null && _ref !== void 0 ? _ref : fallbackTimescale;
+		if (timescale <= 0) continue;
+		const target = Math.round(presentationStart * timescale);
+		const body = tfdt.payload;
+		const view = new DataView(body.buffer, body.byteOffset, body.byteLength);
+		if (body[0] === 1) {
+			if (body.byteLength >= 12) view.setBigUint64(4, BigInt(target));
+		} else if (body.byteLength >= 8) view.setUint32(4, target);
+		rewritten += 1;
+	}
+	return rewritten;
+}
+//#endregion
+export { findBox, findBoxes, fullBox, normalizeTfdt, parseSidx, parseTfdt, trackTimescales, walkBoxes };

package/dist/es2015/containers/packed-audio/index.js

@@ -0,0 +1,67 @@
+import { id3TagLength } from "../id3.js";
+import { SAMPLES_PER_FRAME, parseAdts } from "../adts.js";
+import { writeInitSegment, writeMediaSegment } from "../fmp4/writer.js";
+//#region src/containers/packed-audio/index.ts
+const AUDIO_TRACK_ID = 1;
+const PACK_ORDER = 100;
+/** True when the bytes are bare ADTS AAC, past any leading ID3 tag. */
+function looksLikePackedAudio(data) {
+	const offset = id3TagLength(data, 0);
+	return offset + 2 <= data.byteLength && data[offset] === 255 && (data[offset + 1] & 246) === 240;
+}
+/** Wraps one packed-audio segment as a self-contained fMP4. Null if unparseable. */
+function packAudio(data, presentationStart) {
+	const offset = id3TagLength(data, 0);
+	const adts = parseAdts(data.subarray(offset));
+	if (adts.frames.length === 0) return null;
+	const config = {
+		id: AUDIO_TRACK_ID,
+		kind: "audio",
+		timescale: adts.sampleRate,
+		audioObjectType: adts.audioObjectType,
+		samplingFrequencyIndex: adts.samplingFrequencyIndex,
+		channelConfig: adts.channelConfig
+	};
+	const samples = adts.frames.map((frame) => ({
+		data: frame.data,
+		duration: SAMPLES_PER_FRAME,
+		cts: 0,
+		isKeyframe: true
+	}));
+	const base = Math.round(presentationStart * adts.sampleRate);
+	const sequenceNumber = Math.max(1, Math.round(presentationStart) + 1);
+	const init = writeInitSegment([config]);
+	const media = writeMediaSegment(sequenceNumber, [{
+		trackId: AUDIO_TRACK_ID,
+		baseMediaDecodeTime: base,
+		samples
+	}]);
+	const out = new Uint8Array(init.byteLength + media.byteLength);
+	out.set(init, 0);
+	out.set(media, init.byteLength);
+	return out;
+}
+function packedAudio() {
+	return {
+		name: "packed-audio",
+		provides: [
+			"packed-audio",
+			"media-transform",
+			"media-time-normalized"
+		],
+		install(ctx) {
+			ctx.registerTransform({
+				name: "packed-audio",
+				order: PACK_ORDER,
+				transform(data, meta) {
+					var _packAudio;
+					if (meta.contentType !== "audio") return data;
+					if (!looksLikePackedAudio(data)) return data;
+					return (_packAudio = packAudio(data, meta.start)) !== null && _packAudio !== void 0 ? _packAudio : data;
+				}
+			});
+		}
+	};
+}
+//#endregion
+export { packedAudio as default, looksLikePackedAudio, packAudio };

package/dist/es2015/containers/sei.js

@@ -0,0 +1,79 @@
+//#region src/containers/sei.ts
+/** Strips emulation-prevention bytes (00 00 03 -> 00 00) so payload sizes read true. */
+function toRbsp(nal, start) {
+	const out = new Uint8Array(nal.byteLength - start);
+	let count = 0;
+	let zeros = 0;
+	for (let i = start; 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);
+}
+/**
+* Extracts every CEA-608/708 cc_data triple from one SEI NAL. Returns an empty
+* array for a SEI that carries no ATSC caption user data, and never reads past
+* the buffer: a malformed message stops the walk.
+*/
+function ccTriplesFromSei(seiNal) {
+	const rbsp = toRbsp(seiNal, 1);
+	const triples = [];
+	let offset = 0;
+	const length = rbsp.byteLength;
+	while (offset < length) {
+		let payloadType = 0;
+		while (offset < length && rbsp[offset] === 255) {
+			payloadType += 255;
+			offset += 1;
+		}
+		if (offset >= length) break;
+		payloadType += rbsp[offset];
+		offset += 1;
+		let payloadSize = 0;
+		while (offset < length && rbsp[offset] === 255) {
+			payloadSize += 255;
+			offset += 1;
+		}
+		if (offset >= length) break;
+		payloadSize += rbsp[offset];
+		offset += 1;
+		if (offset + payloadSize > length) break;
+		if (payloadType === 4) appendAtscCc(rbsp.subarray(offset, offset + payloadSize), triples);
+		offset += payloadSize;
+	}
+	return triples;
+}
+const GA94 = 1195456820;
+function appendAtscCc(payload, out) {
+	if (payload.byteLength < 10) return;
+	const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+	const country = payload[0];
+	const provider = view.getUint16(1);
+	const userIdentifier = view.getUint32(3);
+	if (country !== 181 || provider !== 49 || userIdentifier !== GA94) return;
+	if (payload[7] !== 3) return;
+	const ccCount = payload[8] & 31;
+	let cursor = 10;
+	for (let i = 0; i < ccCount; i += 1) {
+		if (cursor + 3 > payload.byteLength) break;
+		const flags = payload[cursor];
+		const ccValid = (flags & 4) !== 0;
+		const ccType = flags & 3;
+		const a = payload[cursor + 1];
+		const b = payload[cursor + 2];
+		cursor += 3;
+		if (ccValid) out.push({
+			type: ccType,
+			a,
+			b
+		});
+	}
+}
+//#endregion
+export { ccTriplesFromSei };