@blockcast/mmt-container 0.1.0-main.149f78a4adae

package/dist/mmtp-to-cmaf.js

@@ -0,0 +1,781 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+
+// src/mmtp-to-cmaf.ts
+function box(type, ...children) {
+  let size = 8;
+  for (const c of children) size += c.length;
+  const buf = new Uint8Array(size);
+  new DataView(buf.buffer).setUint32(0, size);
+  buf[4] = type.charCodeAt(0);
+  buf[5] = type.charCodeAt(1);
+  buf[6] = type.charCodeAt(2);
+  buf[7] = type.charCodeAt(3);
+  let pos = 8;
+  for (const c of children) {
+    buf.set(c, pos);
+    pos += c.length;
+  }
+  return buf;
+}
+function fullBox(type, version, flags, ...children) {
+  let size = 12;
+  for (const c of children) size += c.length;
+  const buf = new Uint8Array(size);
+  const dv = new DataView(buf.buffer);
+  dv.setUint32(0, size);
+  buf[4] = type.charCodeAt(0);
+  buf[5] = type.charCodeAt(1);
+  buf[6] = type.charCodeAt(2);
+  buf[7] = type.charCodeAt(3);
+  dv.setUint32(8, version << 24 | flags & 16777215);
+  let pos = 12;
+  for (const c of children) {
+    buf.set(c, pos);
+    pos += c.length;
+  }
+  return buf;
+}
+function u32(v) {
+  const b = new Uint8Array(4);
+  new DataView(b.buffer).setUint32(0, v);
+  return b;
+}
+var KEYFRAME_FLAGS = 33554432;
+var DELTA_FLAGS = 16842752;
+var UINT32_MAX = 4294967295;
+var MAX_TRACK_ID = UINT32_MAX - 1;
+var INT32_MIN = -2147483648;
+var INT32_MAX = 2147483647;
+function assertTrackId(trackId, label) {
+  if (!Number.isInteger(trackId) || trackId <= 0 || trackId > MAX_TRACK_ID) {
+    throw new RangeError(`${label} must be an integer in 1..${MAX_TRACK_ID}, got ${trackId}`);
+  }
+}
+function assertTimescale(timescale, label) {
+  if (!Number.isInteger(timescale) || timescale <= 0 || timescale > UINT32_MAX) {
+    throw new RangeError(`${label} must be an integer in 1..${UINT32_MAX}, got ${timescale}`);
+  }
+}
+function assertCompositionTimeOffsets(samples) {
+  for (let i = 0; i < samples.length; i++) {
+    const offset = samples[i].compositionTimeOffset;
+    if (offset !== void 0 && (!Number.isInteger(offset) || offset < INT32_MIN || offset > INT32_MAX)) {
+      throw new RangeError(
+        `sample ${i} compositionTimeOffset must be an integer in ${INT32_MIN}..${INT32_MAX}, got ${offset}`
+      );
+    }
+  }
+}
+function encodeMultiSampleSegment(samples, baseDecodeTime, sequence, trackId = 1) {
+  if (samples.length === 0) return new Uint8Array(0);
+  assertTrackId(trackId, "trackId");
+  assertCompositionTimeOffsets(samples);
+  const mfhd = fullBox("mfhd", 0, 0, u32(sequence));
+  const tfhd = fullBox("tfhd", 0, 131072, u32(trackId));
+  const tfdtBody = new Uint8Array(8);
+  const tfdtView = new DataView(tfdtBody.buffer);
+  tfdtView.setUint32(0, Math.floor(baseDecodeTime / 4294967296));
+  tfdtView.setUint32(4, baseDecodeTime >>> 0);
+  const tfdt = fullBox("tfdt", 1, 0, tfdtBody);
+  const hasCompositionTimeOffset = samples.some((sample) => sample.compositionTimeOffset !== void 0);
+  const trunVersion = hasCompositionTimeOffset ? 1 : 0;
+  const trunFlags = 1793 | (hasCompositionTimeOffset ? 2048 : 0);
+  const sampleCount = samples.length;
+  const sampleEntrySize = hasCompositionTimeOffset ? 16 : 12;
+  const trunBody = new Uint8Array(8 + sampleCount * sampleEntrySize);
+  const trunView = new DataView(trunBody.buffer);
+  trunView.setUint32(0, sampleCount);
+  trunView.setUint32(4, 0);
+  for (let i = 0; i < sampleCount; i++) {
+    const s = samples[i];
+    const off = 8 + i * sampleEntrySize;
+    trunView.setUint32(off, s.duration >>> 0);
+    trunView.setUint32(off + 4, s.data.length);
+    trunView.setUint32(off + 8, s.keyframe ? KEYFRAME_FLAGS : DELTA_FLAGS);
+    if (hasCompositionTimeOffset) {
+      trunView.setInt32(off + 12, s.compositionTimeOffset ?? 0);
+    }
+  }
+  const trun = fullBox("trun", trunVersion, trunFlags, trunBody);
+  const traf = box("traf", tfhd, tfdt, trun);
+  const moof = box("moof", mfhd, traf);
+  let mdatSize = 0;
+  for (const s of samples) mdatSize += s.data.length;
+  const mdatPayload = new Uint8Array(mdatSize);
+  let pos = 0;
+  for (const s of samples) {
+    mdatPayload.set(s.data, pos);
+    pos += s.data.length;
+  }
+  const mdat = box("mdat", mdatPayload);
+  const dataOffsetPos = 8 + mfhd.length + 8 + tfhd.length + tfdt.length + 12 + 4;
+  new DataView(moof.buffer).setUint32(dataOffsetPos, moof.length + 8);
+  const result = new Uint8Array(moof.length + mdat.length);
+  result.set(moof, 0);
+  result.set(mdat, moof.length);
+  return result;
+}
+function generateGreenFillNAL(avcC, width, height) {
+  if (avcC.length < 8) return new Uint8Array(0);
+  const lengthSize = (avcC[4] & 3) + 1;
+  let offset = 5;
+  const numSPS = avcC[offset++] & 31;
+  const nals = [];
+  for (let i = 0; i < numSPS; i++) {
+    if (offset + 2 > avcC.length) break;
+    const spsLen = avcC[offset] << 8 | avcC[offset + 1];
+    offset += 2;
+    if (offset + spsLen > avcC.length) break;
+    const sps = avcC.subarray(offset, offset + spsLen);
+    const framed = new Uint8Array(4 + sps.length);
+    new DataView(framed.buffer).setUint32(0, sps.length);
+    framed.set(sps, 4);
+    nals.push(framed);
+    offset += spsLen;
+  }
+  if (offset < avcC.length) {
+    const numPPS = avcC[offset++];
+    for (let i = 0; i < numPPS; i++) {
+      if (offset + 2 > avcC.length) break;
+      const ppsLen = avcC[offset] << 8 | avcC[offset + 1];
+      offset += 2;
+      if (offset + ppsLen > avcC.length) break;
+      const pps = avcC.subarray(offset, offset + ppsLen);
+      const framed = new Uint8Array(4 + pps.length);
+      new DataView(framed.buffer).setUint32(0, pps.length);
+      framed.set(pps, 4);
+      nals.push(framed);
+      offset += ppsLen;
+    }
+  }
+  const mbWidth = Math.ceil(width / 16);
+  const mbHeight = Math.ceil(height / 16);
+  const totalMBs = mbWidth * mbHeight;
+  const idrSlice = new Uint8Array([
+    101,
+    // nal_ref_idc=3, nal_type=5 (IDR)
+    136,
+    // slice header: first_mb_in_slice=0, slice_type=7 (I)
+    128,
+    // pps_id=0, frame_num=0, idr_pic_id=0
+    64
+    // slice data: mb_skip_run covering remaining MBs
+    // Truncated — decoder will error-conceal remaining MBs as green/gray
+  ]);
+  const idrFramed = new Uint8Array(4 + idrSlice.length);
+  new DataView(idrFramed.buffer).setUint32(0, idrSlice.length);
+  idrFramed.set(idrSlice, 4);
+  nals.push(idrFramed);
+  let totalLen = 0;
+  for (const n of nals) totalLen += n.length;
+  const result = new Uint8Array(totalLen);
+  let p = 0;
+  for (const n of nals) {
+    result.set(n, p);
+    p += n.length;
+  }
+  return result;
+}
+function generateSilenceFrame(codec, sampleRate, channels) {
+  if (codec.startsWith("opus") || codec.startsWith("Opus")) {
+    return generateSilenceOpus(channels);
+  }
+  return generateSilenceAAC(sampleRate, channels);
+}
+function generateSilenceAAC(sampleRate, channels) {
+  if (channels >= 2) {
+    return new Uint8Array([
+      33,
+      0,
+      73,
+      144,
+      2,
+      25,
+      0,
+      35,
+      128
+    ]);
+  }
+  return new Uint8Array([
+    1,
+    0,
+    2,
+    0,
+    0,
+    0,
+    0
+  ]);
+}
+function generateSilenceOpus(channels) {
+  return new Uint8Array([248, 255, 254]);
+}
+function normalizeAacSampleForCmaf(data) {
+  if (data.length < 7 || data[0] !== 255 || (data[1] & 246) !== 240) {
+    return data;
+  }
+  const headerLength = data[1] & 1 ? 7 : 9;
+  if (data.length <= headerLength) return data;
+  const frameLength = (data[3] & 3) << 11 | data[4] << 3 | (data[5] & 224) >>> 5;
+  if (frameLength !== data.length || frameLength <= headerLength) return data;
+  return data.subarray(headerLength);
+}
+function encodeDataSegment(data, timestamp, duration, keyframe, sequence, trackId = 1, compositionTimeOffset) {
+  assertTrackId(trackId, "trackId");
+  assertCompositionTimeOffsets([{ compositionTimeOffset }]);
+  if (compositionTimeOffset !== void 0) {
+    return encodeMultiSampleSegment(
+      [{ data, duration, keyframe, compositionTimeOffset }],
+      timestamp,
+      sequence,
+      trackId
+    );
+  }
+  const sampleFlags = keyframe ? KEYFRAME_FLAGS : DELTA_FLAGS;
+  const mfhd = fullBox("mfhd", 0, 0, u32(sequence));
+  const tfhd = fullBox("tfhd", 0, 131072, u32(trackId));
+  const tfdtBody = new Uint8Array(8);
+  const tfdtView = new DataView(tfdtBody.buffer);
+  tfdtView.setUint32(0, Math.floor(timestamp / 4294967296));
+  tfdtView.setUint32(4, timestamp >>> 0);
+  const tfdt = fullBox("tfdt", 1, 0, tfdtBody);
+  const trunBody = new Uint8Array(20);
+  const trunView = new DataView(trunBody.buffer);
+  trunView.setUint32(0, 1);
+  trunView.setUint32(4, 0);
+  trunView.setUint32(8, duration >>> 0);
+  trunView.setUint32(12, data.length);
+  trunView.setUint32(16, sampleFlags);
+  const trun = fullBox("trun", 0, 1793, trunBody);
+  const traf = box("traf", tfhd, tfdt, trun);
+  const moof = box("moof", mfhd, traf);
+  const mdat = box("mdat", data);
+  const dataOffsetPos = 8 + mfhd.length + 8 + tfhd.length + tfdt.length + 12 + 4;
+  new DataView(moof.buffer).setUint32(dataOffsetPos, moof.length + 8);
+  const result = new Uint8Array(moof.length + mdat.length);
+  result.set(moof, 0);
+  result.set(mdat, moof.length);
+  return result;
+}
+function buildVideoInitSegment(avcC, width, height, timescale = 1e6, trackId = 1) {
+  assertTrackId(trackId, "video trackId");
+  assertTimescale(timescale, "video timescale");
+  const ftyp = box("ftyp", new Uint8Array([
+    105,
+    115,
+    111,
+    109,
+    0,
+    0,
+    2,
+    0,
+    105,
+    115,
+    111,
+    109,
+    105,
+    115,
+    111,
+    54,
+    109,
+    112,
+    52,
+    49
+  ]));
+  const avcCBox = box("avcC", avcC);
+  const avc1Body = new Uint8Array(78 + avcCBox.length);
+  const avc1View = new DataView(avc1Body.buffer);
+  avc1View.setUint16(6, 1);
+  avc1View.setUint16(24, width);
+  avc1View.setUint16(26, height);
+  avc1View.setUint32(28, 4718592);
+  avc1View.setUint32(32, 4718592);
+  avc1View.setUint16(40, 1);
+  avc1View.setUint16(74, 24);
+  avc1View.setInt16(76, -1);
+  avc1Body.set(avcCBox, 78);
+  const avc1 = box("avc1", avc1Body);
+  const stsd = fullBox("stsd", 0, 0, u32(1), avc1);
+  const stbl = box(
+    "stbl",
+    stsd,
+    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))
+  );
+  const dinf = box("dinf", fullBox("dref", 0, 0, u32(1), fullBox("url ", 0, 1)));
+  const minf = box("minf", fullBox("vmhd", 0, 1), dinf, stbl);
+  const hdlr = fullBox("hdlr", 0, 0, new Uint8Array([
+    0,
+    0,
+    0,
+    0,
+    118,
+    105,
+    100,
+    101,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    86,
+    105,
+    100,
+    101,
+    111,
+    0
+  ]));
+  const mdhdBody = new Uint8Array(20);
+  new DataView(mdhdBody.buffer).setUint32(8, timescale);
+  const mdhd = fullBox("mdhd", 0, 0, mdhdBody);
+  const mdia = box("mdia", mdhd, hdlr, minf);
+  const tkhdBody = new Uint8Array(80);
+  const tkhdView = new DataView(tkhdBody.buffer);
+  tkhdView.setUint32(8, trackId);
+  tkhdView.setUint32(36, 65536);
+  tkhdView.setUint32(52, 65536);
+  tkhdView.setUint32(64, 1073741824);
+  tkhdView.setUint32(72, width << 16);
+  tkhdView.setUint32(76, height << 16);
+  const tkhd = fullBox("tkhd", 0, 3, tkhdBody);
+  const trak = box("trak", tkhd, mdia);
+  const mvhdBody = new Uint8Array(96);
+  const mvhdView = new DataView(mvhdBody.buffer);
+  mvhdView.setUint32(8, timescale);
+  mvhdView.setUint32(16, 65536);
+  mvhdView.setUint16(20, 256);
+  mvhdView.setUint32(32, 65536);
+  mvhdView.setUint32(48, 65536);
+  mvhdView.setUint32(60, 1073741824);
+  mvhdView.setUint32(92, trackId + 1);
+  const mvhd = fullBox("mvhd", 0, 0, mvhdBody);
+  const trexBody = new Uint8Array(20);
+  new DataView(trexBody.buffer).setUint32(0, trackId);
+  new DataView(trexBody.buffer).setUint32(4, 1);
+  const mvex = box("mvex", fullBox("trex", 0, 0, trexBody));
+  const moov = box("moov", mvhd, trak, mvex);
+  const result = new Uint8Array(ftyp.length + moov.length);
+  result.set(ftyp, 0);
+  result.set(moov, ftyp.length);
+  return result;
+}
+function buildAudioInitSegment(sampleRate, channels, asc, timescale, trackId = 1) {
+  assertTrackId(trackId, "audio trackId");
+  const ts = timescale ?? sampleRate;
+  if (!asc) {
+    const freqTable = [96e3, 88200, 64e3, 48e3, 44100, 32e3, 24e3, 22050, 16e3, 12e3, 11025, 8e3, 7350];
+    const fi = freqTable.indexOf(sampleRate);
+    const freqIdx = fi >= 0 ? fi : 15;
+    if (freqIdx <= 14) {
+      const v = 2 << 11 | freqIdx << 7 | channels << 3;
+      asc = new Uint8Array([v >> 8 & 255, v & 255]);
+    } else {
+      asc = new Uint8Array([
+        2 << 3 | 7,
+        (8 | sampleRate >> 20 & 7) & 255,
+        sampleRate >> 12 & 255,
+        sampleRate >> 4 & 255,
+        ((sampleRate & 15) << 4 | channels << 0) & 255
+      ]);
+    }
+  }
+  const dsi = new Uint8Array(2 + asc.length);
+  dsi[0] = 5;
+  dsi[1] = asc.length;
+  dsi.set(asc, 2);
+  const dcdBody = new Uint8Array(13 + dsi.length);
+  dcdBody[0] = 64;
+  dcdBody[1] = 21;
+  dcdBody.set(dsi, 13);
+  const dcd = new Uint8Array(2 + dcdBody.length);
+  dcd[0] = 4;
+  dcd[1] = dcdBody.length;
+  dcd.set(dcdBody, 2);
+  const esBody = new Uint8Array(3 + dcd.length);
+  esBody[0] = 0;
+  esBody[1] = 1;
+  esBody[2] = 0;
+  esBody.set(dcd, 3);
+  const es = new Uint8Array(2 + esBody.length);
+  es[0] = 3;
+  es[1] = esBody.length;
+  es.set(esBody, 2);
+  const esdsBox = fullBox("esds", 0, 0, es);
+  const mp4aBody = new Uint8Array(28 + esdsBox.length);
+  const mp4aView = new DataView(mp4aBody.buffer);
+  mp4aView.setUint16(6, 1);
+  mp4aView.setUint16(16, channels);
+  mp4aView.setUint16(18, 16);
+  mp4aView.setUint32(24, sampleRate << 16);
+  mp4aBody.set(esdsBox, 28);
+  const mp4a = box("mp4a", mp4aBody);
+  const stsd = fullBox("stsd", 0, 0, u32(1), mp4a);
+  const stbl = box(
+    "stbl",
+    stsd,
+    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))
+  );
+  const dinf = box("dinf", fullBox("dref", 0, 0, u32(1), fullBox("url ", 0, 1)));
+  const minf = box("minf", fullBox("smhd", 0, 0, new Uint8Array(4)), dinf, stbl);
+  const hdlr = fullBox("hdlr", 0, 0, new Uint8Array([
+    0,
+    0,
+    0,
+    0,
+    115,
+    111,
+    117,
+    110,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    83,
+    111,
+    117,
+    110,
+    100,
+    0
+  ]));
+  const mdhdBody = new Uint8Array(20);
+  new DataView(mdhdBody.buffer).setUint32(8, ts);
+  const mdhd = fullBox("mdhd", 0, 0, mdhdBody);
+  const mdia = box("mdia", mdhd, hdlr, minf);
+  const tkhdBody = new Uint8Array(80);
+  const tkhdView = new DataView(tkhdBody.buffer);
+  tkhdView.setUint32(8, trackId);
+  tkhdView.setUint32(36, 65536);
+  tkhdView.setUint32(52, 65536);
+  tkhdView.setUint32(64, 1073741824);
+  const tkhd = fullBox("tkhd", 0, 3, tkhdBody);
+  const trak = box("trak", tkhd, mdia);
+  const mvhdBody = new Uint8Array(96);
+  const mvhdView = new DataView(mvhdBody.buffer);
+  mvhdView.setUint32(8, ts);
+  mvhdView.setUint32(16, 65536);
+  mvhdView.setUint16(20, 256);
+  mvhdView.setUint32(32, 65536);
+  mvhdView.setUint32(48, 65536);
+  mvhdView.setUint32(60, 1073741824);
+  mvhdView.setUint32(92, trackId + 1);
+  const mvhd = fullBox("mvhd", 0, 0, mvhdBody);
+  const trexBody = new Uint8Array(20);
+  new DataView(trexBody.buffer).setUint32(0, trackId);
+  new DataView(trexBody.buffer).setUint32(4, 1);
+  const mvex = box("mvex", fullBox("trex", 0, 0, trexBody));
+  const moov = box("moov", mvhd, trak, mvex);
+  const ftyp = box("ftyp", new Uint8Array([
+    105,
+    115,
+    111,
+    109,
+    0,
+    0,
+    2,
+    0,
+    105,
+    115,
+    111,
+    109,
+    105,
+    115,
+    111,
+    54,
+    109,
+    112,
+    52,
+    49
+  ]));
+  const result = new Uint8Array(ftyp.length + moov.length);
+  result.set(ftyp, 0);
+  result.set(moov, ftyp.length);
+  return result;
+}
+var _videoSeq, _audioSeq, _videoInitSegment, _videoInitTrackId, _audioInitSegment, _lastVideoTimestamp, _frameDuration, _videoBaseTs, _audioBaseTs, _videoTrackId, _videoTimescale, _MmtpToCmaf_instances, videoFrameDuration_get, _audioTimescale, _audioSampleCount, _aacFrameSamples;
+var MmtpToCmaf = class {
+  constructor() {
+    __privateAdd(this, _MmtpToCmaf_instances);
+    __privateAdd(this, _videoSeq, 1);
+    __privateAdd(this, _audioSeq, 1);
+    __privateAdd(this, _videoInitSegment, null);
+    // Known only for locally-built init segments. Wire-supplied MPU metadata is
+    // intentionally opaque here, so setVideoTrackParams remains the API that
+    // lets a caller declare its track geometry before wrapping samples.
+    __privateAdd(this, _videoInitTrackId, null);
+    __privateAdd(this, _audioInitSegment, null);
+    __privateAdd(this, _lastVideoTimestamp, 0);
+    // Sticky sample duration in video timescale units, updated from caller-
+    // supplied durations or adjacent-timestamp deltas. null means "nothing
+    // observed yet", in which case #videoFrameDuration derives ~30fps from the
+    // configured timescale (33333 at the 1_000_000 default, i.e. unchanged).
+    __privateAdd(this, _frameDuration, null);
+    // Per-track rebase: each track anchors on its OWN first sample so
+    // baseMediaDecodeTime is never negative. A shared base was wrong — if the
+    // first sample of one track arrives later than the other's first sample,
+    // the earlier track computes `timestamp - sharedBase` as a negative number,
+    // which serializes into tfdt as a huge unsigned uint64 (~2^64 - 46) and
+    // Chromium rejects the segment with CHUNK_DEMUXER_ERROR_APPEND_FAILED,
+    // closing the MediaSource and detaching all SourceBuffers.
+    // For A/V alignment, choose a COMMON anchor: set when the first sample of
+    // EITHER track arrives, but only if that sample's timestamp is <= any
+    // subsequent track's first sample. Implementation: each track rebases to
+    // the minimum timestamp seen across tracks on their respective first sample.
+    __privateAdd(this, _videoBaseTs, -1);
+    __privateAdd(this, _audioBaseTs, -1);
+    // Video track geometry. These pair with the video init segment's tkhd
+    // track_ID and mdhd/mvhd timescale: every moof this converter emits must
+    // reference the same track at the same rate or the browser either drops the
+    // fragment (unknown track) or plays it at the wrong rate. They are
+    // configuration rather than stream state, so — unlike the sequence numbers
+    // and time bases above — reset() deliberately preserves them, matching the
+    // fact that reset() also preserves #videoInitSegment.
+    __privateAdd(this, _videoTrackId, 1);
+    __privateAdd(this, _videoTimescale, 1e6);
+    // Audio timescale from init segment (default 1M µs; real FFmpeg init uses sampleRate).
+    // Set by buildAudioInit or setAudioTimescale.
+    __privateAdd(this, _audioTimescale, 1e6);
+    // Audio sample counter for drift-free baseMediaDecodeTime.
+    // AAC frames are exactly 1024 samples at sampleRate. Using sequential
+    // counter × 1024 avoids floating-point rounding drift from timestamp conversion.
+    __privateAdd(this, _audioSampleCount, 0);
+    /** AAC access-unit length in samples. ISO/IEC 14496-3: an AAC-LC frame is
+     *  exactly 1024 samples at every sample rate — it is not rate-dependent. */
+    __privateAdd(this, _aacFrameSamples, 1024);
+  }
+  /**
+   * Point the single-sample video wrappers at a specific track and rate.
+   *
+   * Call this when the init segment came off the wire (setInitSegmentFromMpu)
+   * rather than from buildVideoInit, so the wrappers match the publisher's
+   * tkhd/mdhd instead of assuming trackId=1 at microsecond rate. Consumers
+   * that build their init through buildVideoInit can pass the same values
+   * there instead and skip this call.
+   *
+   * The rate is settable only until the first single-sample wrap — see the
+   * throw below for why.
+   */
+  setVideoTrackParams(trackId, timescale) {
+    assertTrackId(trackId, "video trackId");
+    assertTimescale(timescale, "video timescale");
+    if (trackId !== __privateGet(this, _videoTrackId) && __privateGet(this, _videoInitTrackId) !== null) {
+      throw new Error(
+        `video track ID cannot change from ${__privateGet(this, _videoTrackId)} to ${trackId} after a video init has been cached; replace the init atomically`
+      );
+    }
+    if (timescale !== __privateGet(this, _videoTimescale) && __privateGet(this, _videoBaseTs) >= 0) {
+      throw new Error(
+        `video timescale cannot change from ${__privateGet(this, _videoTimescale)} to ${timescale} after video samples have been wrapped; call reset() first`
+      );
+    }
+    __privateSet(this, _videoTrackId, trackId);
+    __privateSet(this, _videoTimescale, timescale);
+  }
+  /** Set init segment from MPU metadata packet (fragment_type=0).
+   *  These are complete ftyp+moov bytes from FFmpeg — use directly. */
+  setInitSegmentFromMpu(data, isAudio) {
+    if (isAudio) {
+      __privateSet(this, _audioInitSegment, data);
+    } else {
+      __privateSet(this, _videoInitSegment, data);
+      __privateSet(this, _videoInitTrackId, null);
+    }
+  }
+  /** Build init segment from codec config (catalog path — no MPU metadata available).
+   *  Passing timescale/trackId also configures the wrappers via
+   *  setVideoTrackParams, so init and media segments cannot disagree. */
+  buildVideoInit(avcC, width, height, timescale, trackId) {
+    const nextTimescale = timescale ?? __privateGet(this, _videoTimescale);
+    const nextTrackId = trackId ?? __privateGet(this, _videoTrackId);
+    assertTrackId(nextTrackId, "video trackId");
+    assertTimescale(nextTimescale, "video timescale");
+    if (nextTimescale !== __privateGet(this, _videoTimescale) && __privateGet(this, _videoBaseTs) >= 0) {
+      throw new Error(
+        `video timescale cannot change from ${__privateGet(this, _videoTimescale)} to ${nextTimescale} after video samples have been wrapped; call reset() first`
+      );
+    }
+    const init = buildVideoInitSegment(
+      avcC,
+      width,
+      height,
+      nextTimescale,
+      nextTrackId
+    );
+    __privateSet(this, _videoTimescale, nextTimescale);
+    __privateSet(this, _videoTrackId, nextTrackId);
+    __privateSet(this, _videoInitSegment, init);
+    __privateSet(this, _videoInitTrackId, nextTrackId);
+  }
+  buildAudioInit(sampleRate, channels, asc, timescale) {
+    const ts = timescale ?? sampleRate;
+    __privateSet(this, _audioTimescale, ts);
+    __privateSet(this, _audioInitSegment, buildAudioInitSegment(sampleRate, channels, asc, ts));
+  }
+  get videoInitSegment() {
+    return __privateGet(this, _videoInitSegment);
+  }
+  get audioInitSegment() {
+    return __privateGet(this, _audioInitSegment);
+  }
+  /** Convert a raw video sample to an fMP4 moof+mdat segment. */
+  wrapVideoSample(data, timestamp, keyframe, duration) {
+    return this.wrapVideoSampleWithTiming(data, timestamp, keyframe, duration).segment;
+  }
+  /**
+   * Convert a raw video sample and return the exact browser media interval
+   * encoded into tfdt/trun. Consumers that correlate SourceBuffer appends with
+   * requestVideoFrameCallback must use this rebased timestamp, not the wire or
+   * caller-owned timestamp passed above.
+   */
+  wrapVideoSampleWithTiming(data, timestamp, keyframe, duration) {
+    if (duration !== void 0 && Number.isFinite(duration) && duration > 0) {
+      __privateSet(this, _frameDuration, Math.round(duration));
+    } else if (__privateGet(this, _lastVideoTimestamp) > 0 && timestamp > __privateGet(this, _lastVideoTimestamp)) {
+      const delta = timestamp - __privateGet(this, _lastVideoTimestamp);
+      if (delta > 0 && delta < __privateGet(this, _videoTimescale)) __privateSet(this, _frameDuration, delta);
+    }
+    __privateSet(this, _lastVideoTimestamp, timestamp);
+    if (__privateGet(this, _videoBaseTs) < 0) __privateSet(this, _videoBaseTs, timestamp);
+    const relTs = timestamp - __privateGet(this, _videoBaseTs);
+    const frameDuration = __privateGet(this, _MmtpToCmaf_instances, videoFrameDuration_get);
+    return Object.freeze({
+      segment: encodeDataSegment(
+        data,
+        relTs,
+        frameDuration,
+        keyframe,
+        __privateWrapper(this, _videoSeq)._++,
+        __privateGet(this, _videoTrackId)
+      ),
+      mediaTimestamp: relTs,
+      duration: frameDuration
+    });
+  }
+  /** Convert an append-safe video batch using the caller-owned timeline.
+   *  Durations, baseDecodeTime, and compositionTimeOffset are in the
+   *  configured video timescale. compositionTimeOffset is the signed PTS-DTS
+   *  delta; its presence selects a version-1 trun for the whole batch.
+   *  An explicit trackId is range-checked before #videoSeq++ for the same
+   *  reason as wrapAudioSamples: the encoder's own check fires too late to
+   *  keep the sequence ungapped. */
+  wrapVideoSamples(samples, baseDecodeTime, trackId = __privateGet(this, _videoTrackId)) {
+    assertTrackId(trackId, "video trackId");
+    assertCompositionTimeOffsets(samples);
+    return encodeMultiSampleSegment(samples, baseDecodeTime, __privateWrapper(this, _videoSeq)._++, trackId);
+  }
+  /** Set audio timescale to match the init segment's mdhd timescale.
+   *  Call after appending the real encoder init (FT=0 ftyp+moov). */
+  setAudioTimescale(timescale) {
+    __privateSet(this, _audioTimescale, timescale);
+  }
+  /** Convert a raw audio sample to an fMP4 moof+mdat segment. */
+  wrapAudioSample(data, timestamp, sampleDuration = 21333, compositionTimeOffset) {
+    assertCompositionTimeOffsets([{ compositionTimeOffset }]);
+    const sampleData = normalizeAacSampleForCmaf(data);
+    if (__privateGet(this, _audioBaseTs) < 0) __privateSet(this, _audioBaseTs, timestamp);
+    const samplesPerFrame = __privateGet(this, _audioTimescale) !== 1e6 ? __privateGet(this, _aacFrameSamples) : sampleDuration;
+    const scaledTs = __privateGet(this, _audioTimescale) !== 1e6 ? __privateGet(this, _audioSampleCount) * samplesPerFrame : timestamp - __privateGet(this, _audioBaseTs);
+    __privateWrapper(this, _audioSampleCount)._++;
+    return encodeDataSegment(
+      sampleData,
+      scaledTs,
+      samplesPerFrame,
+      true,
+      __privateWrapper(this, _audioSeq)._++,
+      1,
+      compositionTimeOffset
+    );
+  }
+  /** Convert an ordered audio batch using the caller-owned timeline. */
+  wrapAudioSamples(samples, baseDecodeTime, trackId = 1) {
+    assertTrackId(trackId, "audio trackId");
+    assertCompositionTimeOffsets(samples);
+    return encodeMultiSampleSegment(
+      samples.map((sample) => ({
+        data: normalizeAacSampleForCmaf(sample.data),
+        duration: sample.duration,
+        keyframe: true,
+        compositionTimeOffset: sample.compositionTimeOffset
+      })),
+      baseDecodeTime,
+      __privateWrapper(this, _audioSeq)._++,
+      trackId
+    );
+  }
+  /** Clear per-stream sequencing and time bases.
+   *  Cached init segments and the video track geometry survive, so a converter
+   *  reset mid-subscription keeps emitting moofs the existing init can resolve.
+   *  Clearing the timescale-denominated timing state also re-opens the video
+   *  rate for change — this is the sanctioned way to retarget mid-subscription. */
+  reset() {
+    __privateSet(this, _videoSeq, 1);
+    __privateSet(this, _audioSeq, 1);
+    __privateSet(this, _audioSampleCount, 0);
+    __privateSet(this, _lastVideoTimestamp, 0);
+    __privateSet(this, _frameDuration, null);
+    __privateSet(this, _videoBaseTs, -1);
+    __privateSet(this, _audioBaseTs, -1);
+    __privateSet(this, _audioTimescale, 1e6);
+  }
+};
+_videoSeq = new WeakMap();
+_audioSeq = new WeakMap();
+_videoInitSegment = new WeakMap();
+_videoInitTrackId = new WeakMap();
+_audioInitSegment = new WeakMap();
+_lastVideoTimestamp = new WeakMap();
+_frameDuration = new WeakMap();
+_videoBaseTs = new WeakMap();
+_audioBaseTs = new WeakMap();
+_videoTrackId = new WeakMap();
+_videoTimescale = new WeakMap();
+_MmtpToCmaf_instances = new WeakSet();
+videoFrameDuration_get = function() {
+  return __privateGet(this, _frameDuration) ?? Math.max(1, Math.round(__privateGet(this, _videoTimescale) / 30));
+};
+_audioTimescale = new WeakMap();
+_audioSampleCount = new WeakMap();
+_aacFrameSamples = new WeakMap();
+export {
+  MmtpToCmaf,
+  buildAudioInitSegment,
+  buildVideoInitSegment,
+  encodeDataSegment,
+  encodeMultiSampleSegment,
+  generateGreenFillNAL,
+  generateSilenceFrame,
+  normalizeAacSampleForCmaf
+};
+//# sourceMappingURL=mmtp-to-cmaf.js.map