@blockcast/mmt-container 0.1.0 → 0.3.0-main.d9354616fdf2

package/dist/mmtp-to-cmaf.js

@@ -0,0 +1,716 @@
+// 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 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) {
+  return buildVisualInitSegment("avc1", "avcC", avcC, width, height, timescale, trackId);
+}
+function buildHevcVideoInitSegment(sampleEntry, hvcC, width, height, timescale, trackId) {
+  if (sampleEntry !== "hev1" && sampleEntry !== "hvc1") {
+    throw new Error(`HEVC init segment requires an hev1 or hvc1 sample entry, got ${String(sampleEntry)}`);
+  }
+  return buildVisualInitSegment(sampleEntry, "hvcC", hvcC, width, height, timescale, trackId);
+}
+function buildVisualInitSegment(sampleEntryType, configBoxType, configRecord, width, height, timescale, trackId) {
+  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 configBox = box(configBoxType, configRecord);
+  const sampleEntryBody = new Uint8Array(78 + configBox.length);
+  const sampleEntryView = new DataView(sampleEntryBody.buffer);
+  sampleEntryView.setUint16(6, 1);
+  sampleEntryView.setUint16(24, width);
+  sampleEntryView.setUint16(26, height);
+  sampleEntryView.setUint32(28, 4718592);
+  sampleEntryView.setUint32(32, 4718592);
+  sampleEntryView.setUint16(40, 1);
+  sampleEntryView.setUint16(74, 24);
+  sampleEntryView.setInt16(76, -1);
+  sampleEntryBody.set(configBox, 78);
+  const visualSampleEntry = box(sampleEntryType, sampleEntryBody);
+  const stsd = fullBox("stsd", 0, 0, u32(1), visualSampleEntry);
+  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, new Uint8Array(8)), 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;
+  assertTimescale(ts, "audio timescale");
+  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 MmtpToCmaf = class {
+  #videoSeq = 1;
+  #audioSeq = 1;
+  #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.
+  #videoInitTrackId = null;
+  #audioInitSegment = null;
+  #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).
+  #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.
+  #videoBaseTs = -1;
+  #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.
+  #videoTrackId = 1;
+  #videoTimescale = 1e6;
+  /**
+   * 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 !== this.#videoTrackId && this.#videoInitTrackId !== null) {
+      throw new Error(
+        `video track ID cannot change from ${this.#videoTrackId} to ${trackId} after a video init has been cached; replace the init atomically`
+      );
+    }
+    if (timescale !== this.#videoTimescale && this.#videoBaseTs >= 0) {
+      throw new Error(
+        `video timescale cannot change from ${this.#videoTimescale} to ${timescale} after video samples have been wrapped; call reset() first`
+      );
+    }
+    this.#videoTrackId = trackId;
+    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) {
+      this.#audioInitSegment = data;
+    } else {
+      this.#videoInitSegment = data;
+      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 ?? this.#videoTimescale;
+    const nextTrackId = trackId ?? this.#videoTrackId;
+    assertTrackId(nextTrackId, "video trackId");
+    assertTimescale(nextTimescale, "video timescale");
+    if (nextTimescale !== this.#videoTimescale && this.#videoBaseTs >= 0) {
+      throw new Error(
+        `video timescale cannot change from ${this.#videoTimescale} to ${nextTimescale} after video samples have been wrapped; call reset() first`
+      );
+    }
+    const init = buildVideoInitSegment(
+      avcC,
+      width,
+      height,
+      nextTimescale,
+      nextTrackId
+    );
+    this.#videoTimescale = nextTimescale;
+    this.#videoTrackId = nextTrackId;
+    this.#videoInitSegment = init;
+    this.#videoInitTrackId = nextTrackId;
+  }
+  buildAudioInit(sampleRate, channels, asc, timescale) {
+    const ts = timescale ?? sampleRate;
+    const init = buildAudioInitSegment(sampleRate, channels, asc, ts);
+    this.#audioTimescale = ts;
+    this.#audioInitSegment = init;
+  }
+  get videoInitSegment() {
+    return this.#videoInitSegment;
+  }
+  get audioInitSegment() {
+    return this.#audioInitSegment;
+  }
+  /** Convert a raw video sample to an fMP4 moof+mdat segment. */
+  wrapVideoSample(data, timestamp, keyframe, duration, compositionTimeOffset) {
+    return this.wrapVideoSampleWithTiming(data, timestamp, keyframe, duration, compositionTimeOffset).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.
+   *
+   * `compositionTimeOffset` is the signed authored PTS-DTS delta, in the same
+   * #videoTimescale units as `timestamp` and `duration` — unlike wrapAudioSample,
+   * which takes microseconds and rescales, because every other quantity on this
+   * path is already denominated in #videoTimescale (see setVideoTrackParams).
+   * Passing it therefore needs no conversion here; rescaling would double-convert.
+   * Absent leaves the trun at version 0 with no offset field; a declared 0 is an
+   * authored value and still promotes to version 1. Never reconstruct it from
+   * arrival time.
+   */
+  wrapVideoSampleWithTiming(data, timestamp, keyframe, duration, compositionTimeOffset) {
+    assertCompositionTimeOffsets([{ compositionTimeOffset }]);
+    if (duration !== void 0 && Number.isFinite(duration) && duration > 0) {
+      this.#frameDuration = Math.round(duration);
+    } else if (this.#lastVideoTimestamp > 0 && timestamp > this.#lastVideoTimestamp) {
+      const delta = timestamp - this.#lastVideoTimestamp;
+      if (delta > 0 && delta < this.#videoTimescale) this.#frameDuration = delta;
+    }
+    this.#lastVideoTimestamp = timestamp;
+    if (this.#videoBaseTs < 0) this.#videoBaseTs = timestamp;
+    const relTs = timestamp - this.#videoBaseTs;
+    const frameDuration = this.#videoFrameDuration;
+    return Object.freeze({
+      segment: encodeDataSegment(
+        data,
+        relTs,
+        frameDuration,
+        keyframe,
+        this.#videoSeq++,
+        this.#videoTrackId,
+        compositionTimeOffset
+      ),
+      mediaTimestamp: relTs,
+      duration: frameDuration
+    });
+  }
+  /** Sticky duration if one has been observed, else ~30fps at the current rate. */
+  get #videoFrameDuration() {
+    return this.#frameDuration ?? Math.max(1, Math.round(this.#videoTimescale / 30));
+  }
+  /** 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 = this.#videoTrackId) {
+    assertTrackId(trackId, "video trackId");
+    assertCompositionTimeOffsets(samples);
+    return encodeMultiSampleSegment(samples, baseDecodeTime, this.#videoSeq++, trackId);
+  }
+  // Audio timescale from init segment (default 1M µs; real FFmpeg init uses sampleRate).
+  // Set by buildAudioInit or setAudioTimescale.
+  #audioTimescale = 1e6;
+  /** Set audio timescale to match the init segment's mdhd timescale.
+   *  Call after appending the real encoder init (FT=0 ftyp+moov).
+   *  Fails closed on a value the mdhd uint32 cannot hold, as the video paths
+   *  already do. wrapAudioSample rescales the authored composition offset by
+   *  this value, so the two failure modes are both silent: a 0 multiplies
+   *  every authored offset to 0 — indistinguishable from a feed that authored
+   *  none — while a value above uint32 scales the trun to a timescale the
+   *  mdhd cannot declare, since it is emitted with setUint32 modulo 2^32. */
+  setAudioTimescale(timescale) {
+    assertTimescale(timescale, "audio timescale");
+    this.#audioTimescale = timescale;
+  }
+  // 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.
+  #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. */
+  #aacFrameSamples = 1024;
+  /** Convert a raw audio sample to an fMP4 moof+mdat segment. */
+  wrapAudioSample(data, timestamp, sampleDuration = 21333, compositionTimeOffset) {
+    assertCompositionTimeOffsets([{ compositionTimeOffset }]);
+    const sampleData = normalizeAacSampleForCmaf(data);
+    if (this.#audioBaseTs < 0) this.#audioBaseTs = timestamp;
+    const samplesPerFrame = this.#audioTimescale !== 1e6 ? this.#aacFrameSamples : sampleDuration;
+    const scaledTs = this.#audioTimescale !== 1e6 ? this.#audioSampleCount * samplesPerFrame : timestamp - this.#audioBaseTs;
+    this.#audioSampleCount++;
+    const scaledCompositionTimeOffset = compositionTimeOffset === void 0 || this.#audioTimescale === 1e6 ? compositionTimeOffset : Math.round(compositionTimeOffset * this.#audioTimescale / 1e6);
+    return encodeDataSegment(
+      sampleData,
+      scaledTs,
+      samplesPerFrame,
+      true,
+      this.#audioSeq++,
+      1,
+      scaledCompositionTimeOffset
+    );
+  }
+  /** 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,
+      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() {
+    this.#videoSeq = 1;
+    this.#audioSeq = 1;
+    this.#audioSampleCount = 0;
+    this.#lastVideoTimestamp = 0;
+    this.#frameDuration = null;
+    this.#videoBaseTs = -1;
+    this.#audioBaseTs = -1;
+    this.#audioTimescale = 1e6;
+  }
+};
+export {
+  MmtpToCmaf,
+  buildAudioInitSegment,
+  buildHevcVideoInitSegment,
+  buildVideoInitSegment,
+  encodeDataSegment,
+  encodeMultiSampleSegment,
+  generateSilenceFrame,
+  normalizeAacSampleForCmaf
+};
+//# sourceMappingURL=mmtp-to-cmaf.js.map