@amazon/vinyl-transmux 1.0.0

package/dist/index.js

@@ -0,0 +1,1130 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+
+// src/aac/adts.ts
+var ADTS_SAMPLING_RATES = [
+  96e3,
+  88200,
+  64e3,
+  48e3,
+  44100,
+  32e3,
+  24e3,
+  22050,
+  16e3,
+  12e3,
+  11025,
+  8e3,
+  7350
+];
+function adtsSampleRate(index) {
+  var _a;
+  return (_a = ADTS_SAMPLING_RATES[index]) != null ? _a : 0;
+}
+function parseAdtsFrames(data) {
+  const frames = [];
+  let offset = 0;
+  while (offset + 7 <= data.length) {
+    if (data[offset] !== 255 || (data[offset + 1] & 240) !== 240) {
+      offset++;
+      continue;
+    }
+    const hasCrc = (data[offset + 1] & 1) === 0;
+    const headerSize = hasCrc ? 9 : 7;
+    const audioObjectType = (data[offset + 2] >> 6 & 3) + 1;
+    const samplingFrequencyIndex = data[offset + 2] >> 2 & 15;
+    const channelConfiguration = (data[offset + 2] & 1) << 2 | data[offset + 3] >> 6 & 3;
+    const frameLength = (data[offset + 3] & 3) << 11 | data[offset + 4] << 3 | data[offset + 5] >> 5 & 7;
+    if (frameLength < headerSize || offset + frameLength > data.length) {
+      break;
+    }
+    frames.push({
+      offset,
+      frameLength,
+      headerSize,
+      audioObjectType,
+      samplingFrequencyIndex,
+      channelConfiguration
+    });
+    offset += frameLength;
+  }
+  return frames;
+}
+function buildAudioSpecificConfig(frame) {
+  const config = new Uint8Array(2);
+  config[0] = frame.audioObjectType << 3 | (frame.samplingFrequencyIndex & 14) >> 1;
+  config[1] = (frame.samplingFrequencyIndex & 1) << 7 | frame.channelConfiguration << 3;
+  return config;
+}
+
+// src/transmux/sampleEntry.ts
+import { BufferWriter as BufferWriter2 } from "@amazon/vinyl-util";
+
+// src/mp4/mp4.ts
+import { BufferWriter } from "@amazon/vinyl-util";
+var UNITY_MATRIX = [
+  65536,
+  0,
+  0,
+  0,
+  65536,
+  0,
+  0,
+  0,
+  1073741824
+];
+var MPEG_TIMESCALE = 9e4;
+var LANGUAGE_UNDETERMINED = 21956;
+function box(type, ...payloads) {
+  let size = 8;
+  for (const p of payloads) size += p.byteLength;
+  const writer = new BufferWriter(size);
+  writer.writeUint32(size);
+  writer.writeString(type);
+  for (const p of payloads) writer.writeBytes(p);
+  return writer.toUint8Array();
+}
+function fullBox(type, version, flags, payload) {
+  const size = 12 + payload.byteLength;
+  const writer = new BufferWriter(size);
+  writer.writeUint32(size);
+  writer.writeString(type);
+  writer.writeUint8(version);
+  writer.writeUint8(flags >> 16 & 255);
+  writer.writeUint8(flags >> 8 & 255);
+  writer.writeUint8(flags & 255);
+  writer.writeBytes(payload);
+  return writer.toUint8Array();
+}
+var DEFAULT_FTYP = {
+  majorBrand: "isom",
+  minorVersion: 512,
+  compatibleBrands: ["isom", "iso6", "mp41"]
+};
+function ftyp(options) {
+  const { majorBrand, minorVersion, compatibleBrands } = __spreadValues(__spreadValues({}, DEFAULT_FTYP), options);
+  const writer = new BufferWriter(8 + compatibleBrands.length * 4);
+  writer.writeString(majorBrand);
+  writer.writeUint32(minorVersion);
+  for (const brand of compatibleBrands) writer.writeString(brand);
+  return box("ftyp", writer.toUint8Array());
+}
+function moov(...traks) {
+  const trakAndMvex = [];
+  for (let i = 0; i < traks.length; i++) {
+    trakAndMvex.push(traks[i], mvex(i + 1));
+  }
+  return box("moov", mvhd(), ...trakAndMvex);
+}
+var DEFAULT_MVHD = {
+  timescale: MPEG_TIMESCALE,
+  duration: 0,
+  rate: 1,
+  volume: 1
+};
+function mvhd(options) {
+  const { timescale, duration, rate, volume } = __spreadValues(__spreadValues({}, DEFAULT_MVHD), options);
+  const writer = new BufferWriter(96);
+  writer.writeUint32(0);
+  writer.writeUint32(0);
+  writer.writeUint32(timescale);
+  writer.writeUint32(duration);
+  writer.writeUint32(rate * 65536);
+  writer.writeUint16(volume * 256);
+  for (let i = 0; i < 10; i++) writer.writeUint8(0);
+  for (const v of UNITY_MATRIX) writer.writeUint32(v);
+  for (let i = 0; i < 6; i++) writer.writeUint32(0);
+  writer.writeUint32(4294967295);
+  return fullBox("mvhd", 0, 0, writer.toUint8Array());
+}
+function audioTrak(options) {
+  return box(
+    "trak",
+    tkhd(options.trackId, 0, 0, options.channelCount > 0 ? 1 : 0),
+    box(
+      "mdia",
+      mdhd(options.sampleRate),
+      hdlr("soun", "SoundHandler"),
+      box("minf", smhd(), dinf(), audioStbl(options.sampleEntry))
+    )
+  );
+}
+function videoTrak(options) {
+  var _a;
+  return box(
+    "trak",
+    tkhd(options.trackId, options.width, options.height, 0),
+    box(
+      "mdia",
+      mdhd((_a = options.timescale) != null ? _a : MPEG_TIMESCALE),
+      hdlr("vide", "VideoHandler"),
+      box("minf", vmhd(), dinf(), videoStbl(options.sampleEntry))
+    )
+  );
+}
+function tkhd(trackId, width, height, volume) {
+  const writer = new BufferWriter(80);
+  writer.writeUint32(0);
+  writer.writeUint32(0);
+  writer.writeUint32(trackId);
+  writer.writeUint32(0);
+  writer.writeUint32(0);
+  writer.writeUint32(0);
+  writer.writeUint32(0);
+  writer.writeUint16(0);
+  writer.writeUint16(0);
+  writer.writeUint16(volume * 256);
+  writer.writeUint16(0);
+  for (const v of UNITY_MATRIX) writer.writeUint32(v);
+  writer.writeUint32(width * 65536);
+  writer.writeUint32(height * 65536);
+  return fullBox("tkhd", 0, 3, writer.toUint8Array());
+}
+function mdhd(timescale) {
+  const writer = new BufferWriter(20);
+  writer.writeUint32(0);
+  writer.writeUint32(0);
+  writer.writeUint32(timescale);
+  writer.writeUint32(0);
+  writer.writeUint16(LANGUAGE_UNDETERMINED);
+  writer.writeUint16(0);
+  return fullBox("mdhd", 0, 0, writer.toUint8Array());
+}
+function hdlr(handlerType, name) {
+  const writer = new BufferWriter(21 + name.length);
+  writer.writeUint32(0);
+  writer.writeString(handlerType);
+  writer.writeUint32(0);
+  writer.writeUint32(0);
+  writer.writeUint32(0);
+  writer.writeString(name);
+  writer.writeUint8(0);
+  return fullBox("hdlr", 0, 0, writer.toUint8Array());
+}
+function smhd() {
+  const writer = new BufferWriter(4);
+  writer.writeUint16(0);
+  writer.writeUint16(0);
+  return fullBox("smhd", 0, 0, writer.toUint8Array());
+}
+function vmhd() {
+  const writer = new BufferWriter(8);
+  writer.writeUint16(0);
+  writer.writeUint16(0);
+  writer.writeUint16(0);
+  writer.writeUint16(0);
+  return fullBox("vmhd", 0, 1, writer.toUint8Array());
+}
+function dinf() {
+  const writer = new BufferWriter(4);
+  writer.writeUint32(1);
+  const urlBox = fullBox("url ", 0, 1, new Uint8Array(0));
+  return box(
+    "dinf",
+    fullBox("dref", 0, 0, concatUint8(writer.toUint8Array(), urlBox))
+  );
+}
+function audioStbl(sampleEntry) {
+  return box("stbl", stsd(sampleEntry), stts(), stsc(), stsz(), stco());
+}
+function videoStbl(sampleEntry) {
+  return box("stbl", stsd(sampleEntry), stts(), stsc(), stsz(), stco());
+}
+function stsd(sampleEntry) {
+  const writer = new BufferWriter(4);
+  writer.writeUint32(1);
+  return fullBox(
+    "stsd",
+    0,
+    0,
+    concatUint8(writer.toUint8Array(), sampleEntry)
+  );
+}
+function stts() {
+  const writer = new BufferWriter(4);
+  writer.writeUint32(0);
+  return fullBox("stts", 0, 0, writer.toUint8Array());
+}
+function stsc() {
+  const writer = new BufferWriter(4);
+  writer.writeUint32(0);
+  return fullBox("stsc", 0, 0, writer.toUint8Array());
+}
+function stsz() {
+  const writer = new BufferWriter(8);
+  writer.writeUint32(0);
+  writer.writeUint32(0);
+  return fullBox("stsz", 0, 0, writer.toUint8Array());
+}
+function stco() {
+  const writer = new BufferWriter(4);
+  writer.writeUint32(0);
+  return fullBox("stco", 0, 0, writer.toUint8Array());
+}
+function mvex(trackId) {
+  return box("mvex", trex(trackId));
+}
+function trex(trackId) {
+  const writer = new BufferWriter(20);
+  writer.writeUint32(trackId);
+  writer.writeUint32(1);
+  writer.writeUint32(0);
+  writer.writeUint32(0);
+  writer.writeUint32(0);
+  return fullBox("trex", 0, 0, writer.toUint8Array());
+}
+function moof(options) {
+  return box("moof", mfhd(options.sequenceNumber), traf(options));
+}
+function mfhd(sequenceNumber) {
+  const writer = new BufferWriter(4);
+  writer.writeUint32(sequenceNumber);
+  return fullBox("mfhd", 0, 0, writer.toUint8Array());
+}
+function traf(options) {
+  return box(
+    "traf",
+    tfhd(options.trackId),
+    tfdt(options.baseDecodeTime),
+    trun(options.samples)
+  );
+}
+function tfhd(trackId) {
+  const writer = new BufferWriter(4);
+  writer.writeUint32(trackId);
+  return fullBox("tfhd", 0, 131072, writer.toUint8Array());
+}
+function tfdt(baseDecodeTime) {
+  const writer = new BufferWriter(4);
+  writer.writeUint32(baseDecodeTime);
+  return fullBox("tfdt", 0, 0, writer.toUint8Array());
+}
+function trun(samples) {
+  var _a, _b;
+  const hasFlags = samples.some((s) => s.flags != null);
+  const hasCto = samples.some((s) => s.compositionTimeOffset != null);
+  let flags = 1 | 256 | 512;
+  if (hasFlags) flags |= 1024;
+  if (hasCto) flags |= 2048;
+  let entrySize = 8;
+  if (hasFlags) entrySize += 4;
+  if (hasCto) entrySize += 4;
+  const writer = new BufferWriter(8 + samples.length * entrySize);
+  writer.writeUint32(samples.length);
+  writer.writeUint32(0);
+  for (const sample of samples) {
+    writer.writeUint32(sample.duration);
+    writer.writeUint32(sample.size);
+    if (hasFlags) writer.writeUint32((_a = sample.flags) != null ? _a : 0);
+    if (hasCto) writer.writeInt32((_b = sample.compositionTimeOffset) != null ? _b : 0);
+  }
+  const result = fullBox("trun", hasCto ? 1 : 0, flags, writer.toUint8Array());
+  return result;
+}
+function mdat(data) {
+  return box("mdat", data);
+}
+function patchDataOffset(moofData, moofSize) {
+  const dataOffset = moofSize + 8;
+  let pos = 8;
+  while (pos < moofData.length) {
+    const boxSize = (moofData[pos] << 24 | moofData[pos + 1] << 16 | moofData[pos + 2] << 8 | moofData[pos + 3]) >>> 0;
+    const boxType = String.fromCharCode(
+      moofData[pos + 4],
+      moofData[pos + 5],
+      moofData[pos + 6],
+      moofData[pos + 7]
+    );
+    if (boxType === "traf") {
+      let trafPos = pos + 8;
+      while (trafPos < pos + boxSize) {
+        const innerSize = (moofData[trafPos] << 24 | moofData[trafPos + 1] << 16 | moofData[trafPos + 2] << 8 | moofData[trafPos + 3]) >>> 0;
+        const innerType = String.fromCharCode(
+          moofData[trafPos + 4],
+          moofData[trafPos + 5],
+          moofData[trafPos + 6],
+          moofData[trafPos + 7]
+        );
+        if (innerType === "trun") {
+          const offsetPos = trafPos + 16;
+          moofData[offsetPos] = dataOffset >> 24 & 255;
+          moofData[offsetPos + 1] = dataOffset >> 16 & 255;
+          moofData[offsetPos + 2] = dataOffset >> 8 & 255;
+          moofData[offsetPos + 3] = dataOffset & 255;
+          return;
+        }
+        trafPos += innerSize;
+      }
+    }
+    pos += boxSize;
+  }
+}
+function concatUint8(...arrays) {
+  let total = 0;
+  for (const a of arrays) total += a.byteLength;
+  const result = new Uint8Array(total);
+  let offset = 0;
+  for (const a of arrays) {
+    result.set(a, offset);
+    offset += a.byteLength;
+  }
+  return result;
+}
+
+// src/transmux/sampleEntry.ts
+var RESOLUTION_72_DPI = 4718592;
+var OBJECT_TYPE_AAC = 64;
+var STREAM_TYPE_AUDIO = 21;
+function mp4aSampleEntry(config) {
+  const writer = new BufferWriter2(28);
+  for (let i = 0; i < 6; i++) writer.writeUint8(0);
+  writer.writeUint16(1);
+  for (let i = 0; i < 8; i++) writer.writeUint8(0);
+  writer.writeUint16(config.channelConfiguration);
+  writer.writeUint16(16);
+  writer.writeUint16(0);
+  writer.writeUint16(0);
+  writer.writeUint32(config.sampleRate << 16);
+  return box("mp4a", writer.toUint8Array(), esds(config));
+}
+function avc1SampleEntry(config) {
+  const writer = new BufferWriter2(78);
+  for (let i = 0; i < 6; i++) writer.writeUint8(0);
+  writer.writeUint16(1);
+  for (let i = 0; i < 16; i++) writer.writeUint8(0);
+  writer.writeUint16(config.width);
+  writer.writeUint16(config.height);
+  writer.writeUint32(RESOLUTION_72_DPI);
+  writer.writeUint32(RESOLUTION_72_DPI);
+  writer.writeUint32(0);
+  writer.writeUint16(1);
+  for (let i = 0; i < 32; i++) writer.writeUint8(0);
+  writer.writeUint16(24);
+  writer.writeInt16(-1);
+  return box("avc1", writer.toUint8Array(), avcC(config));
+}
+function esds(config) {
+  const asc = config.audioSpecificConfig;
+  const dsi = new BufferWriter2(2 + asc.byteLength);
+  dsi.writeUint8(5);
+  dsi.writeUint8(asc.byteLength);
+  dsi.writeBytes(asc);
+  const dcd = new BufferWriter2(2 + 13 + dsi.position);
+  dcd.writeUint8(4);
+  dcd.writeUint8(13 + dsi.position);
+  dcd.writeUint8(OBJECT_TYPE_AAC);
+  dcd.writeUint8(STREAM_TYPE_AUDIO);
+  dcd.writeUint8(0);
+  dcd.writeUint8(0);
+  dcd.writeUint8(0);
+  dcd.writeUint32(0);
+  dcd.writeUint32(0);
+  dcd.writeBytes(dsi.toUint8Array());
+  const slc = new BufferWriter2(3);
+  slc.writeUint8(6);
+  slc.writeUint8(1);
+  slc.writeUint8(2);
+  const esPayloadSize = 3 + dcd.position + slc.position;
+  const es = new BufferWriter2(2 + esPayloadSize);
+  es.writeUint8(3);
+  es.writeUint8(esPayloadSize);
+  es.writeUint16(1);
+  es.writeUint8(0);
+  es.writeBytes(dcd.toUint8Array());
+  es.writeBytes(slc.toUint8Array());
+  return fullBox("esds", 0, 0, es.toUint8Array());
+}
+function avcC(config) {
+  const writer = new BufferWriter2(
+    11 + config.sps.byteLength + config.pps.byteLength
+  );
+  writer.writeUint8(1);
+  writer.writeUint8(config.profileIdc);
+  writer.writeUint8(config.profileCompatibility);
+  writer.writeUint8(config.levelIdc);
+  writer.writeUint8(3);
+  writer.writeUint8(225);
+  writer.writeUint16(config.sps.byteLength);
+  writer.writeBytes(config.sps);
+  writer.writeUint8(1);
+  writer.writeUint16(config.pps.byteLength);
+  writer.writeBytes(config.pps);
+  return box("avcC", writer.toUint8Array());
+}
+
+// src/mpegts/mpegts.ts
+var TS_PACKET_SIZE = 188;
+var TS_SYNC_BYTE = 71;
+var STREAM_TYPE_AAC = 15;
+var STREAM_TYPE_H264 = 27;
+var STREAM_TYPE_H265 = 36;
+var STREAM_TYPE_ID3 = 21;
+function parseTsPacketHeader(data, offset) {
+  const byte1 = data[offset + 1];
+  const byte2 = data[offset + 2];
+  const byte3 = data[offset + 3];
+  return {
+    pid: (byte1 & 31) << 8 | byte2,
+    payloadUnitStartIndicator: (byte1 & 64) !== 0,
+    adaptationFieldControl: byte3 >> 4 & 3,
+    continuityCounter: byte3 & 15
+  };
+}
+function getPayloadOffset(data, offset, adaptationFieldControl) {
+  let payloadOffset = offset + 4;
+  if (adaptationFieldControl >= 2) {
+    payloadOffset += 1 + data[offset + 4];
+  }
+  return payloadOffset;
+}
+function parsePat(data, offset) {
+  const pointerField = data[offset];
+  let pos = offset + 1 + pointerField;
+  pos += 8;
+  pos += 2;
+  return (data[pos] & 31) << 8 | data[pos + 1];
+}
+function parsePmt(data, offset) {
+  const pointerField = data[offset];
+  let pos = offset + 1 + pointerField;
+  pos += 1;
+  const sectionLength = (data[pos] & 15) << 8 | data[pos + 1];
+  pos += 2;
+  const sectionEnd = pos + sectionLength;
+  pos += 5;
+  pos += 2;
+  const programInfoLength = (data[pos] & 15) << 8 | data[pos + 1];
+  pos += 2 + programInfoLength;
+  const entries = [];
+  while (pos < sectionEnd - 4) {
+    const streamType = data[pos];
+    pos += 1;
+    const pid = (data[pos] & 31) << 8 | data[pos + 1];
+    pos += 2;
+    const esInfoLength = (data[pos] & 15) << 8 | data[pos + 1];
+    pos += 2 + esInfoLength;
+    entries.push({ pid, streamType });
+  }
+  return entries;
+}
+function demuxTsSegment(segment) {
+  let pmtPid = -1;
+  const pmtEntries = [];
+  const pesBuffers = /* @__PURE__ */ new Map();
+  for (let i = 0; i + TS_PACKET_SIZE <= segment.length; i += TS_PACKET_SIZE) {
+    if (segment[i] !== TS_SYNC_BYTE) continue;
+    const header = parseTsPacketHeader(segment, i);
+    const payloadStart = getPayloadOffset(
+      segment,
+      i,
+      header.adaptationFieldControl
+    );
+    if (header.adaptationFieldControl === 0 || header.adaptationFieldControl === 2)
+      continue;
+    if (header.pid === 0) {
+      pmtPid = parsePat(segment, payloadStart);
+    } else if (header.pid === pmtPid && pmtEntries.length === 0) {
+      pmtEntries.push(...parsePmt(segment, payloadStart));
+    }
+  }
+  const pidToStreamType = /* @__PURE__ */ new Map();
+  for (const entry of pmtEntries) {
+    pidToStreamType.set(entry.pid, entry.streamType);
+    pesBuffers.set(entry.pid, []);
+  }
+  for (let i = 0; i + TS_PACKET_SIZE <= segment.length; i += TS_PACKET_SIZE) {
+    if (segment[i] !== TS_SYNC_BYTE) continue;
+    const header = parseTsPacketHeader(segment, i);
+    if (header.adaptationFieldControl === 0 || header.adaptationFieldControl === 2)
+      continue;
+    const buffers = pesBuffers.get(header.pid);
+    if (!buffers) continue;
+    const payloadStart = getPayloadOffset(
+      segment,
+      i,
+      header.adaptationFieldControl
+    );
+    const payloadEnd = i + TS_PACKET_SIZE;
+    if (payloadStart < payloadEnd) {
+      buffers.push(segment.slice(payloadStart, payloadEnd));
+    }
+  }
+  const streams = [];
+  for (const [pid, buffers] of pesBuffers) {
+    if (buffers.length === 0) continue;
+    streams.push({
+      pid,
+      streamType: pidToStreamType.get(pid),
+      data: buffers
+    });
+  }
+  return streams;
+}
+function concatBuffers(buffers) {
+  let totalLength = 0;
+  for (const buf of buffers) totalLength += buf.byteLength;
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const buf of buffers) {
+    result.set(buf, offset);
+    offset += buf.byteLength;
+  }
+  return result;
+}
+function stripPesHeader(pesData) {
+  if (pesData[0] !== 0 || pesData[1] !== 0 || pesData[2] !== 1) {
+    return pesData;
+  }
+  const pesHeaderDataLength = pesData[8];
+  return pesData.subarray(9 + pesHeaderDataLength);
+}
+function parsePesPts(pesData) {
+  if (pesData[0] !== 0 || pesData[1] !== 0 || pesData[2] !== 1) return -1;
+  const flags = pesData[7];
+  if ((flags & 128) === 0) return -1;
+  const byte9 = pesData[9];
+  const byte10 = pesData[10];
+  const byte11 = pesData[11];
+  const byte12 = pesData[12];
+  const byte13 = pesData[13];
+  return (byte9 & 14) * 536870912 + // (byte9 & 0x0E) << 29
+  ((byte10 & 255) << 22) + ((byte11 & 254) << 14) + ((byte12 & 255) << 7) + ((byte13 & 254) >>> 1);
+}
+
+// src/transmux/transmux.ts
+function createTransmuxer() {
+  const state = {
+    initSegment: null,
+    sequenceNumber: 1,
+    audioConfig: null,
+    videoConfig: null,
+    audioDecodeTime: 0,
+    videoDecodeTime: 0
+  };
+  return { transmux: (data) => transmux(state, data) };
+}
+function buildInitSegment(state, moovBox) {
+  const ftypBox = ftyp();
+  const init = new Uint8Array(ftypBox.byteLength + moovBox.byteLength);
+  init.set(ftypBox, 0);
+  init.set(moovBox, ftypBox.byteLength);
+  state.initSegment = init;
+}
+function getInitSegment(state) {
+  const init = state.initSegment;
+  return init.buffer.slice(
+    init.byteOffset,
+    init.byteOffset + init.byteLength
+  );
+}
+function transmux(state, data) {
+  let segment = new Uint8Array(data);
+  segment = skipId3Tags(segment);
+  const isMpegTs = segment[0] === 71;
+  const isAdts = segment[0] === 255 && (segment[1] & 240) === 240;
+  if (isMpegTs) {
+    return transmuxMpegTs(state, segment);
+  } else if (isAdts) {
+    return transmuxAdts(state, segment);
+  }
+  throw new Error("Unsupported segment format: expected MPEG-TS or ADTS");
+}
+function skipId3Tags(data) {
+  let offset = 0;
+  while (offset + 10 <= data.length && data[offset] === 73 && // 'I'
+  data[offset + 1] === 68 && // 'D'
+  data[offset + 2] === 51) {
+    const size = (data[offset + 6] & 127) << 21 | (data[offset + 7] & 127) << 14 | (data[offset + 8] & 127) << 7 | data[offset + 9] & 127;
+    offset += 10 + size;
+  }
+  return offset > 0 ? data.subarray(offset) : data;
+}
+function transmuxAdts(state, data) {
+  const frames = parseAdtsFrames(data);
+  if (frames.length === 0) {
+    throw new Error("No ADTS frames found in segment");
+  }
+  const firstFrame = frames[0];
+  if (!state.audioConfig) {
+    const sampleRate2 = adtsSampleRate(firstFrame.samplingFrequencyIndex);
+    state.audioConfig = {
+      audioObjectType: firstFrame.audioObjectType,
+      samplingFrequencyIndex: firstFrame.samplingFrequencyIndex,
+      channelConfiguration: firstFrame.channelConfiguration,
+      sampleRate: sampleRate2,
+      audioSpecificConfig: buildAudioSpecificConfig(firstFrame)
+    };
+    buildInitSegment(
+      state,
+      moov(
+        audioTrak({
+          trackId: 1,
+          sampleRate: state.audioConfig.sampleRate,
+          channelCount: state.audioConfig.channelConfiguration,
+          sampleEntry: mp4aSampleEntry(state.audioConfig)
+        })
+      )
+    );
+  }
+  const sampleRate = state.audioConfig.sampleRate;
+  const samplesPerFrame = 1024;
+  const samples = [];
+  const frameDataParts = [];
+  for (const frame of frames) {
+    const rawData = data.subarray(
+      frame.offset + frame.headerSize,
+      frame.offset + frame.frameLength
+    );
+    samples.push({
+      duration: samplesPerFrame,
+      size: rawData.byteLength
+    });
+    frameDataParts.push(rawData);
+  }
+  const rawMediaData = concatBuffers(frameDataParts);
+  const duration = frames.length * samplesPerFrame / sampleRate;
+  const moofBox = moof({
+    sequenceNumber: state.sequenceNumber++,
+    trackId: 1,
+    baseDecodeTime: state.audioDecodeTime,
+    samples
+  });
+  state.audioDecodeTime += frames.length * samplesPerFrame;
+  patchDataOffset(moofBox, moofBox.byteLength);
+  const mdatBox = mdat(rawMediaData);
+  const mediaSegment = new Uint8Array(moofBox.byteLength + mdatBox.byteLength);
+  mediaSegment.set(moofBox, 0);
+  mediaSegment.set(mdatBox, moofBox.byteLength);
+  return {
+    initSegment: getInitSegment(state),
+    mediaSegment: mediaSegment.buffer.slice(
+      mediaSegment.byteOffset,
+      mediaSegment.byteOffset + mediaSegment.byteLength
+    ),
+    duration
+  };
+}
+function transmuxMpegTs(state, data) {
+  const streams = demuxTsSegment(data);
+  const audioStream = streams.find((s) => s.streamType === STREAM_TYPE_AAC);
+  const videoStream = streams.find((s) => s.streamType === STREAM_TYPE_H264);
+  let audioFrames = [];
+  let audioRawData = null;
+  let audioConfig = state.audioConfig;
+  if (audioStream) {
+    const pesData = concatBuffers(audioStream.data);
+    const esData = extractElementaryStream(pesData);
+    audioFrames = parseAdtsFrames(esData);
+    if (audioFrames.length > 0 && !audioConfig) {
+      const firstFrame = audioFrames[0];
+      const sampleRate = adtsSampleRate(firstFrame.samplingFrequencyIndex);
+      audioConfig = {
+        audioObjectType: firstFrame.audioObjectType,
+        samplingFrequencyIndex: firstFrame.samplingFrequencyIndex,
+        channelConfiguration: firstFrame.channelConfiguration,
+        sampleRate,
+        audioSpecificConfig: buildAudioSpecificConfig(firstFrame)
+      };
+      state.audioConfig = audioConfig;
+    }
+    const parts = [];
+    for (const frame of audioFrames) {
+      parts.push(
+        esData.subarray(
+          frame.offset + frame.headerSize,
+          frame.offset + frame.frameLength
+        )
+      );
+    }
+    audioRawData = concatBuffers(parts);
+  }
+  let videoNalus = [];
+  let videoConfig = state.videoConfig;
+  let videoFrameDuration = 3754;
+  const videoPtsList = [];
+  if (videoStream) {
+    const pesData = concatBuffers(videoStream.data);
+    let pesOff = 0;
+    while (pesOff + 9 < pesData.length) {
+      if (pesData[pesOff] === 0 && pesData[pesOff + 1] === 0 && pesData[pesOff + 2] === 1 && pesData[pesOff + 3] >= 188) {
+        const pts = parsePesPts(pesData.subarray(pesOff));
+        if (pts >= 0) videoPtsList.push(pts);
+        const pLen = pesData[pesOff + 4] << 8 | pesData[pesOff + 5];
+        if (pLen > 0) {
+          pesOff += 6 + pLen;
+        } else {
+          const hdrLen = pesData[pesOff + 8];
+          pesOff += 9 + hdrLen;
+        }
+      } else {
+        pesOff++;
+      }
+    }
+    if (videoPtsList.length >= 2) {
+      const sorted = [...videoPtsList].sort((a, b) => a - b);
+      const deltas = [];
+      for (let i = 1; i < sorted.length; i++)
+        deltas.push(sorted[i] - sorted[i - 1]);
+      deltas.sort((a, b) => a - b);
+      videoFrameDuration = deltas[deltas.length >> 1] || 3754;
+    }
+    const esData = extractElementaryStream(pesData);
+    videoNalus = extractH264Nalus(esData);
+    if (!videoConfig) {
+      const sps = videoNalus.find((n) => (n[0] & 31) === 7);
+      const pps = videoNalus.find((n) => (n[0] & 31) === 8);
+      if (sps && pps) {
+        const { width, height } = parseSpsInfo(sps);
+        videoConfig = {
+          width,
+          height,
+          sps,
+          pps,
+          profileIdc: sps[1],
+          profileCompatibility: sps[2],
+          levelIdc: sps[3]
+        };
+        state.videoConfig = videoConfig;
+      }
+    }
+  }
+  if (!state.initSegment && (audioConfig || videoConfig)) {
+    const traks = [];
+    if (videoConfig) {
+      traks.push(
+        videoTrak({
+          trackId: traks.length + 1,
+          width: videoConfig.width,
+          height: videoConfig.height,
+          sampleEntry: avc1SampleEntry(videoConfig)
+        })
+      );
+    }
+    if (audioConfig) {
+      traks.push(
+        audioTrak({
+          trackId: traks.length + 1,
+          sampleRate: audioConfig.sampleRate,
+          channelCount: audioConfig.channelConfiguration,
+          sampleEntry: mp4aSampleEntry(audioConfig)
+        })
+      );
+    }
+    buildInitSegment(state, moov(...traks));
+  }
+  const fragments = [];
+  let duration = 0;
+  if (videoConfig && videoNalus.length > 0) {
+    const trackId = 1;
+    const accessUnits = [];
+    let pendingParams = [];
+    for (const nalu of videoNalus) {
+      const naluType = nalu[0] & 31;
+      if (naluType === 7 || naluType === 8) {
+        pendingParams.push(nalu);
+      } else if (naluType === 6) {
+        pendingParams.push(nalu);
+      } else if (naluType === 5) {
+        accessUnits.push({
+          nalus: [...pendingParams, nalu],
+          isIdr: true
+        });
+        pendingParams = [];
+      } else if (naluType === 1) {
+        accessUnits.push({
+          nalus: pendingParams.length > 0 ? [...pendingParams, nalu] : [nalu],
+          isIdr: false
+        });
+        pendingParams = [];
+      }
+    }
+    if (accessUnits.length > 0) {
+      const naluParts = [];
+      const samples = [];
+      const frameDuration = videoFrameDuration;
+      const basePts = videoPtsList.length > 0 ? Math.min(...videoPtsList) : 0;
+      const baseDts = basePts;
+      for (let auIdx = 0; auIdx < accessUnits.length; auIdx++) {
+        const au = accessUnits[auIdx];
+        let auSize = 0;
+        const auParts = [];
+        for (const nalu of au.nalus) {
+          const lengthPrefixed = new Uint8Array(4 + nalu.byteLength);
+          lengthPrefixed[0] = nalu.byteLength >> 24 & 255;
+          lengthPrefixed[1] = nalu.byteLength >> 16 & 255;
+          lengthPrefixed[2] = nalu.byteLength >> 8 & 255;
+          lengthPrefixed[3] = nalu.byteLength & 255;
+          lengthPrefixed.set(nalu, 4);
+          auParts.push(lengthPrefixed);
+          auSize += lengthPrefixed.byteLength;
+        }
+        naluParts.push(...auParts);
+        samples.push({
+          duration: frameDuration,
+          size: auSize,
+          // is_leading=0, depends_on: IDR=2(no), non-IDR=1(yes),
+          // is_depended_on=0, has_redundancy=0
+          flags: au.isIdr ? 33554432 : 16842752,
+          compositionTimeOffset: auIdx < videoPtsList.length ? videoPtsList[auIdx] - (baseDts + auIdx * frameDuration) : 0
+        });
+      }
+      const rawData = concatBuffers(naluParts);
+      const moofBox = moof({
+        sequenceNumber: state.sequenceNumber++,
+        trackId,
+        baseDecodeTime: state.videoDecodeTime,
+        samples
+      });
+      state.videoDecodeTime += accessUnits.length * frameDuration;
+      patchDataOffset(moofBox, moofBox.byteLength);
+      const mdatBox = mdat(rawData);
+      fragments.push(moofBox, mdatBox);
+      duration = accessUnits.length * frameDuration / MPEG_TIMESCALE;
+    }
+  }
+  if (audioConfig && audioRawData && audioFrames.length > 0) {
+    const trackId = videoConfig ? 2 : 1;
+    const samplesPerFrame = 1024;
+    const samples = [];
+    const parts = [];
+    let offset = 0;
+    for (const frame of audioFrames) {
+      const size = frame.frameLength - frame.headerSize;
+      parts.push(audioRawData.subarray(offset, offset + size));
+      samples.push({
+        duration: samplesPerFrame,
+        size
+      });
+      offset += size;
+    }
+    const rawData = concatBuffers(parts);
+    const moofBox = moof({
+      sequenceNumber: state.sequenceNumber++,
+      trackId,
+      baseDecodeTime: state.audioDecodeTime,
+      samples
+    });
+    state.audioDecodeTime += audioFrames.length * samplesPerFrame;
+    patchDataOffset(moofBox, moofBox.byteLength);
+    const mdatBox = mdat(rawData);
+    fragments.push(moofBox, mdatBox);
+    const audioDuration = audioFrames.length * samplesPerFrame / audioConfig.sampleRate;
+    if (audioDuration > duration) duration = audioDuration;
+  }
+  const mediaSegment = concatBuffers(fragments);
+  return {
+    initSegment: getInitSegment(state),
+    mediaSegment: mediaSegment.buffer.slice(
+      mediaSegment.byteOffset,
+      mediaSegment.byteOffset + mediaSegment.byteLength
+    ),
+    duration
+  };
+}
+function extractElementaryStream(pesData) {
+  const parts = [];
+  let offset = 0;
+  while (offset < pesData.length) {
+    if (offset + 9 <= pesData.length && pesData[offset] === 0 && pesData[offset + 1] === 0 && pesData[offset + 2] === 1 && pesData[offset + 3] >= 188) {
+      const headerDataLength = pesData[offset + 8];
+      const payloadStart = offset + 9 + headerDataLength;
+      const pesPacketLength = pesData[offset + 4] << 8 | pesData[offset + 5];
+      if (pesPacketLength > 0) {
+        const pesEnd = Math.min(
+          offset + 6 + pesPacketLength,
+          pesData.length
+        );
+        if (payloadStart < pesEnd) {
+          parts.push(pesData.subarray(payloadStart, pesEnd));
+        }
+        offset = pesEnd;
+      } else {
+        let nextPes = payloadStart;
+        while (nextPes + 3 < pesData.length) {
+          if (pesData[nextPes] === 0 && pesData[nextPes + 1] === 0 && pesData[nextPes + 2] === 1 && pesData[nextPes + 3] >= 188) {
+            break;
+          }
+          nextPes++;
+        }
+        if (nextPes + 3 >= pesData.length) nextPes = pesData.length;
+        if (payloadStart < nextPes) {
+          parts.push(pesData.subarray(payloadStart, nextPes));
+        }
+        offset = nextPes;
+      }
+    } else {
+      offset++;
+    }
+  }
+  return concatBuffers(parts);
+}
+function extractH264Nalus(data) {
+  const nalus = [];
+  const startPositions = [];
+  let i = 0;
+  while (i < data.length - 2) {
+    if (data[i] === 0 && data[i + 1] === 0) {
+      if (i + 3 < data.length && data[i + 2] === 0 && data[i + 3] === 1) {
+        startPositions.push({ offset: i, scLen: 4 });
+        i += 4;
+      } else if (data[i + 2] === 1) {
+        startPositions.push({ offset: i, scLen: 3 });
+        i += 3;
+      } else {
+        i++;
+      }
+    } else {
+      i++;
+    }
+  }
+  for (let j = 0; j < startPositions.length; j++) {
+    const naluStart = startPositions[j].offset + startPositions[j].scLen;
+    const naluEnd = j + 1 < startPositions.length ? startPositions[j + 1].offset : data.length;
+    let trimmedEnd = naluEnd;
+    while (trimmedEnd > naluStart + 1 && data[trimmedEnd - 1] === 0) {
+      trimmedEnd--;
+    }
+    if (trimmedEnd > naluStart) {
+      nalus.push(data.subarray(naluStart, trimmedEnd));
+    }
+  }
+  return nalus;
+}
+var HIGH_PROFILE_IDCS = /* @__PURE__ */ new Set([
+  100,
+  110,
+  122,
+  244,
+  44,
+  83,
+  86,
+  118,
+  128,
+  138,
+  139,
+  134
+]);
+function parseSpsInfo(sps) {
+  let bitOffset = 8;
+  function readBit() {
+    const byteIndex = bitOffset >> 3;
+    const bitIndex = 7 - (bitOffset & 7);
+    bitOffset++;
+    return sps[byteIndex] >> bitIndex & 1;
+  }
+  function readBits(n) {
+    let val = 0;
+    for (let i = 0; i < n; i++) {
+      val = val << 1 | readBit();
+    }
+    return val;
+  }
+  function readUe() {
+    let leadingZeros = 0;
+    while (readBit() === 0 && leadingZeros < 32) leadingZeros++;
+    if (leadingZeros === 0) return 0;
+    return (1 << leadingZeros) - 1 + readBits(leadingZeros);
+  }
+  function readSe() {
+    const val = readUe();
+    return val & 1 ? val + 1 >> 1 : -(val >> 1);
+  }
+  const profileIdc = readBits(8);
+  readBits(8);
+  readBits(8);
+  readUe();
+  if (HIGH_PROFILE_IDCS.has(profileIdc)) {
+    const chromaFormatIdc = readUe();
+    if (chromaFormatIdc === 3) readBit();
+    readUe();
+    readUe();
+    readBit();
+    const seqScalingMatrixPresent = readBit();
+    if (seqScalingMatrixPresent) {
+      const count = chromaFormatIdc !== 3 ? 8 : 12;
+      for (let i = 0; i < count; i++) {
+        if (readBit()) {
+          const size = i < 6 ? 16 : (
+            /* c8 ignore next */
+            64
+          );
+          let lastScale = 8;
+          let nextScale = 8;
+          for (let j = 0; j < size; j++) {
+            if (nextScale !== 0) {
+              const delta = readSe();
+              nextScale = (lastScale + delta + 256) % 256;
+            }
+            lastScale = nextScale === 0 ? lastScale : nextScale;
+          }
+        }
+      }
+    }
+  }
+  readUe();
+  const picOrderCntType = readUe();
+  if (picOrderCntType === 0) {
+    readUe();
+  } else if (picOrderCntType === 1) {
+    readBit();
+    readSe();
+    readSe();
+    const numRefFrames = readUe();
+    for (let i = 0; i < numRefFrames; i++) readSe();
+  }
+  readUe();
+  readBit();
+  const picWidthInMbsMinus1 = readUe();
+  const picHeightInMapUnitsMinus1 = readUe();
+  const frameMbsOnlyFlag = readBit();
+  const width = (picWidthInMbsMinus1 + 1) * 16;
+  const height = (2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16;
+  return { width, height };
+}
+export {
+  MPEG_TIMESCALE,
+  STREAM_TYPE_AAC,
+  STREAM_TYPE_H264,
+  STREAM_TYPE_H265,
+  STREAM_TYPE_ID3,
+  TS_PACKET_SIZE,
+  TS_SYNC_BYTE,
+  adtsSampleRate,
+  audioTrak,
+  avc1SampleEntry,
+  box,
+  buildAudioSpecificConfig,
+  concatBuffers,
+  createTransmuxer,
+  demuxTsSegment,
+  ftyp,
+  fullBox,
+  getPayloadOffset,
+  mdat,
+  moof,
+  moov,
+  mp4aSampleEntry,
+  parseAdtsFrames,
+  parsePat,
+  parsePesPts,
+  parsePmt,
+  parseTsPacketHeader,
+  patchDataOffset,
+  stripPesHeader,
+  videoTrak
+};
+//# sourceMappingURL=index.js.map