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

package/dist/codec-utils.js

@@ -0,0 +1,1546 @@
+// src/codec-utils.ts
+function extractAvcCFromInitSegment(data) {
+  if (!hasIsoBmffMagic(data)) return void 0;
+  for (const stsd of findTrackStsdBoxes(data)) {
+    const info = extractVideoConfigFromStsd(data, stsd);
+    if (info) return info;
+  }
+  return void 0;
+}
+function extractVideoConfigFromStsd(data, stsd) {
+  let s = stsd.o + 16;
+  const e = stsd.o + stsd.sz;
+  const avc1 = findBox(data, s, e, "avc1");
+  if (avc1 && avc1.sz >= 86) {
+    const avcC = findBox(data, avc1.o + 86, avc1.o + avc1.sz, "avcC");
+    if (avcC && avcC.sz >= 12) {
+      const d = data.subarray(avcC.o + 8, avcC.o + avcC.sz);
+      const codec = `avc1.${hex2(d[1])}${hex2(d[2])}${hex2(d[3])}`;
+      return { codec, description: d };
+    }
+  }
+  for (const sampleEntry of ["hvc1", "hev1"]) {
+    const hvc = findBox(data, s, e, sampleEntry);
+    if (!hvc || hvc.sz < 86) continue;
+    const hvcC = findBox(data, hvc.o + 86, hvc.o + hvc.sz, "hvcC");
+    if (hvcC && hvcC.sz >= 8 + 23) {
+      const d = data.subarray(hvcC.o + 8, hvcC.o + hvcC.sz);
+      return { codec: hevcCodecStringFromHvcC(d, sampleEntry), description: d };
+    }
+  }
+  const av01 = findBox(data, s, e, "av01");
+  if (av01 && av01.sz >= 86) {
+    const av1C = findBox(data, av01.o + 86, av01.o + av01.sz, "av1C");
+    if (av1C && av1C.sz >= 8) {
+      const d = data.subarray(av1C.o + 8, av1C.o + av1C.sz);
+      return { codec: codecStringFromAv1C(d), description: d };
+    }
+  }
+  const vp09 = findBox(data, s, e, "vp09");
+  if (vp09 && vp09.sz >= 86) {
+    const vpcC = findBox(data, vp09.o + 86, vp09.o + vp09.sz, "vpcC");
+    if (vpcC && vpcC.sz >= 8) {
+      const d = data.subarray(vpcC.o + 8, vpcC.o + vpcC.sz);
+      return { codec: codecStringFromVpcC(d), description: d };
+    }
+  }
+  return void 0;
+}
+function generateFallbackAvcC(options) {
+  const opts = typeof options === "string" ? { codec: options } : options ?? {};
+  let profile = 100;
+  let constraint = 0;
+  let level = 42;
+  if (opts.codec) {
+    const match = opts.codec.match(/^avc[13]\.([0-9a-fA-F]{6})$/);
+    if (match) {
+      profile = Number.parseInt(match[1].substring(0, 2), 16);
+      constraint = Number.parseInt(match[1].substring(2, 4), 16);
+      level = Number.parseInt(match[1].substring(4, 6), 16);
+    }
+  }
+  const { width, height } = resolveResolution(opts.width, opts.height, level);
+  const sps = buildMinimalSps(profile, constraint, level, width, height);
+  const pps = buildMinimalPps(profile);
+  const avcC = new Uint8Array(5 + 1 + 2 + sps.length + 1 + 2 + pps.length);
+  let w = 0;
+  avcC[w++] = 1;
+  avcC[w++] = profile;
+  avcC[w++] = constraint;
+  avcC[w++] = level;
+  avcC[w++] = 255;
+  avcC[w++] = 225;
+  avcC[w++] = sps.length >> 8 & 255;
+  avcC[w++] = sps.length & 255;
+  avcC.set(sps, w);
+  w += sps.length;
+  avcC[w++] = 1;
+  avcC[w++] = pps.length >> 8 & 255;
+  avcC[w++] = pps.length & 255;
+  avcC.set(pps, w);
+  return avcC;
+}
+function extractSpsPpsFromAvcC(avcC) {
+  if (avcC.length < 8) return void 0;
+  const numSPS = avcC[5] & 31;
+  let offset = 6;
+  let sps;
+  for (let i = 0; i < numSPS && offset + 2 <= avcC.length; i++) {
+    const spsLen = avcC[offset] << 8 | avcC[offset + 1];
+    offset += 2;
+    if (offset + spsLen <= avcC.length) {
+      if (!sps) sps = avcC.subarray(offset, offset + spsLen);
+      offset += spsLen;
+    }
+  }
+  let pps;
+  if (offset < avcC.length) {
+    const numPPS = avcC[offset] & 31;
+    offset++;
+    for (let i = 0; i < numPPS && offset + 2 <= avcC.length; i++) {
+      const ppsLen = avcC[offset] << 8 | avcC[offset + 1];
+      offset += 2;
+      if (offset + ppsLen <= avcC.length) {
+        if (!pps) pps = avcC.subarray(offset, offset + ppsLen);
+        offset += ppsLen;
+      }
+    }
+  }
+  return sps && pps ? { sps, pps } : void 0;
+}
+function avccToAnnexB(avccData, isKeyframe, spsPps) {
+  let offset = 0;
+  let totalNalSize = 0;
+  let nalCount = 0;
+  while (offset + 4 <= avccData.length) {
+    const nalLen = avccData[offset] << 24 | avccData[offset + 1] << 16 | avccData[offset + 2] << 8 | avccData[offset + 3];
+    offset += 4;
+    if (nalLen <= 0 || offset + nalLen > avccData.length) break;
+    totalNalSize += nalLen;
+    nalCount++;
+    offset += nalLen;
+  }
+  if (nalCount === 0) return avccData;
+  let outSize = nalCount * 4 + totalNalSize;
+  if (isKeyframe) {
+    outSize += 4 + spsPps.sps.length + 4 + spsPps.pps.length;
+  }
+  const out = new Uint8Array(outSize);
+  let w = 0;
+  if (isKeyframe) {
+    out[w++] = 0;
+    out[w++] = 0;
+    out[w++] = 0;
+    out[w++] = 1;
+    out.set(spsPps.sps, w);
+    w += spsPps.sps.length;
+    out[w++] = 0;
+    out[w++] = 0;
+    out[w++] = 0;
+    out[w++] = 1;
+    out.set(spsPps.pps, w);
+    w += spsPps.pps.length;
+  }
+  offset = 0;
+  while (offset + 4 <= avccData.length) {
+    const nalLen = avccData[offset] << 24 | avccData[offset + 1] << 16 | avccData[offset + 2] << 8 | avccData[offset + 3];
+    offset += 4;
+    if (nalLen <= 0 || offset + nalLen > avccData.length) break;
+    out[w++] = 0;
+    out[w++] = 0;
+    out[w++] = 0;
+    out[w++] = 1;
+    out.set(avccData.subarray(offset, offset + nalLen), w);
+    w += nalLen;
+    offset += nalLen;
+  }
+  return out;
+}
+function extractCodecDescriptionFromAnnexB(data) {
+  const nalUnits = [];
+  let i = 0;
+  while (i < data.length - 4) {
+    if (data[i] === 0 && data[i + 1] === 0) {
+      let nalStart = 0;
+      if (data[i + 2] === 1) {
+        nalStart = i + 3;
+      } else if (data[i + 2] === 0 && data[i + 3] === 1) {
+        nalStart = i + 4;
+      }
+      if (nalStart > 0 && nalStart < data.length) {
+        let nalEnd = data.length;
+        for (let j = nalStart; j < data.length - 3; j++) {
+          if (data[j] === 0 && data[j + 1] === 0 && (data[j + 2] === 1 || data[j + 2] === 0 && data[j + 3] === 1)) {
+            nalEnd = j;
+            break;
+          }
+        }
+        const nalType = data[nalStart] & 31;
+        nalUnits.push({ type: nalType, data: data.slice(nalStart, nalEnd) });
+        i = nalEnd;
+        continue;
+      }
+    }
+    i++;
+  }
+  const sps = nalUnits.find((n) => n.type === 7);
+  const pps = nalUnits.find((n) => n.type === 8);
+  if (!sps || !pps) return null;
+  const avcCLength = 6 + 2 + sps.data.length + 1 + 2 + pps.data.length;
+  const avcC = new Uint8Array(avcCLength);
+  let offset = 0;
+  avcC[offset++] = 1;
+  avcC[offset++] = sps.data[1];
+  avcC[offset++] = sps.data[2];
+  avcC[offset++] = sps.data[3];
+  avcC[offset++] = 255;
+  avcC[offset++] = 225;
+  avcC[offset++] = sps.data.length >> 8 & 255;
+  avcC[offset++] = sps.data.length & 255;
+  avcC.set(sps.data, offset);
+  offset += sps.data.length;
+  avcC[offset++] = 1;
+  avcC[offset++] = pps.data.length >> 8 & 255;
+  avcC[offset++] = pps.data.length & 255;
+  avcC.set(pps.data, offset);
+  return avcC;
+}
+function codecStringFromAvcC(avcC) {
+  if (avcC.length < 4) return "avc1.640033";
+  return `avc1.${hex2(avcC[1])}${hex2(avcC[2])}${hex2(avcC[3])}`;
+}
+function isHevcCodec(codec) {
+  return codec.startsWith("hev1") || codec.startsWith("hvc1");
+}
+function videoSampleEntryFromCodecString(codec) {
+  const fourCc = codec.split(".")[0];
+  if (fourCc === "avc1" || fourCc === "avc3" || fourCc === "hev1" || fourCc === "hvc1") return fourCc;
+  throw new Error(`Unsupported video codec family in codec string ${JSON.stringify(codec)}`);
+}
+function videoCodecFamily(sampleEntry) {
+  return sampleEntry === "avc1" || sampleEntry === "avc3" ? "avc" : "hevc";
+}
+var HEVC_NAL_UNIT_TYPE = {
+  TRAIL_R: 1,
+  /** First IRAP type. */
+  BLA_W_LP: 16,
+  IDR_W_RADL: 19,
+  IDR_N_LP: 20,
+  CRA_NUT: 21,
+  /** Last IRAP type (reserved IRAP VCL). */
+  RSV_IRAP_VCL23: 23,
+  /** Last VCL type; 32..=63 are non-VCL. */
+  LAST_VCL: 31,
+  VPS_NUT: 32,
+  SPS_NUT: 33,
+  PPS_NUT: 34,
+  AUD_NUT: 35,
+  PREFIX_SEI_NUT: 39,
+  SUFFIX_SEI_NUT: 40
+};
+var HEVC_NAL_HEADER_LENGTH = 2;
+var HVCC_MAX_BIT_DEPTH_MINUS8 = 7;
+function hevcNalUnitType(nal) {
+  return nal[0] >> 1 & 63;
+}
+function isHevcIrapNalUnitType(nalUnitType) {
+  return nalUnitType >= HEVC_NAL_UNIT_TYPE.BLA_W_LP && nalUnitType <= HEVC_NAL_UNIT_TYPE.RSV_IRAP_VCL23;
+}
+function hevcNalType(nal) {
+  return hevcNalUnitType(nal);
+}
+function removeEmulationPrevention(rbsp) {
+  const out = [];
+  let zeros = 0;
+  for (let i = 0; i < rbsp.length; i++) {
+    const b = rbsp[i];
+    if (zeros >= 2 && b === 3) {
+      zeros = 0;
+      continue;
+    }
+    out.push(b);
+    zeros = b === 0 ? zeros + 1 : 0;
+  }
+  return Uint8Array.from(out);
+}
+var RbspReader = class {
+  constructor(data) {
+    this.data = data;
+  }
+  #bit = 0;
+  bits(count) {
+    if (this.#bit + count > this.data.length * 8) throw new Error("HEVC SPS: RBSP truncated");
+    let value = 0;
+    for (let i = 0; i < count; i++, this.#bit++) {
+      value = value * 2 + (this.data[this.#bit >> 3] >> 7 - (this.#bit & 7) & 1);
+    }
+    return value;
+  }
+  skip(count) {
+    if (this.#bit + count > this.data.length * 8) throw new Error("HEVC SPS: RBSP truncated");
+    this.#bit += count;
+  }
+  ue() {
+    let leadingZeros = 0;
+    while (this.bits(1) === 0) {
+      if (++leadingZeros > 31) throw new Error("HEVC SPS: ue(v) exceeds 32 bits");
+    }
+    return leadingZeros === 0 ? 0 : 2 ** leadingZeros - 1 + this.bits(leadingZeros);
+  }
+};
+function parseHevcSps(sps) {
+  if (sps.length < HEVC_NAL_HEADER_LENGTH || (sps[0] & 128) !== 0 || (sps[1] & 7) === 0) {
+    throw new Error("HEVC SPS: invalid NAL unit header");
+  }
+  if (hevcNalUnitType(sps) !== HEVC_NAL_UNIT_TYPE.SPS_NUT) throw new Error("HEVC SPS: NAL unit is not an SPS");
+  if (((sps[0] & 1) << 5 | sps[1] >> 3) !== 0) {
+    throw new Error("HEVC SPS: not in the base layer (nuh_layer_id != 0)");
+  }
+  const r = new RbspReader(removeEmulationPrevention(sps).subarray(HEVC_NAL_HEADER_LENGTH));
+  r.bits(4);
+  const maxSubLayersMinus1 = r.bits(3);
+  if (maxSubLayersMinus1 > 6) throw new Error("HEVC SPS: sps_max_sub_layers_minus1 is greater than 6");
+  const temporalIdNestingFlag = r.bits(1) === 1;
+  const profileSpace = r.bits(2);
+  const tierFlag = r.bits(1) === 1;
+  const profileIdc = r.bits(5);
+  const profileCompatibilityFlags = r.bits(32) >>> 0;
+  const constraintIndicatorFlags = new Uint8Array(6);
+  for (let i = 0; i < 6; i++) constraintIndicatorFlags[i] = r.bits(8);
+  const levelIdc = r.bits(8);
+  const subLayerProfilePresent = [];
+  const subLayerLevelPresent = [];
+  for (let i = 0; i < maxSubLayersMinus1; i++) {
+    subLayerProfilePresent.push(r.bits(1) === 1);
+    subLayerLevelPresent.push(r.bits(1) === 1);
+  }
+  if (maxSubLayersMinus1 > 0) {
+    for (let i = maxSubLayersMinus1; i < 8; i++) r.skip(2);
+  }
+  for (let i = 0; i < maxSubLayersMinus1; i++) {
+    if (subLayerProfilePresent[i]) r.skip(88);
+    if (subLayerLevelPresent[i]) r.skip(8);
+  }
+  const seqParameterSetId = r.ue();
+  if (seqParameterSetId > 15) throw new Error("HEVC SPS: sps_seq_parameter_set_id is greater than 15");
+  const chromaFormatIdc = r.ue();
+  if (chromaFormatIdc > 3) throw new Error("HEVC SPS: chroma_format_idc is greater than 3");
+  if (chromaFormatIdc === 3) r.skip(1);
+  const picWidthInLumaSamples = r.ue();
+  const picHeightInLumaSamples = r.ue();
+  if (picWidthInLumaSamples === 0 || picHeightInLumaSamples === 0) {
+    throw new Error("HEVC SPS: picture dimension is zero");
+  }
+  if (r.bits(1) === 1) for (let i = 0; i < 4; i++) r.ue();
+  const bitDepthLumaMinus8 = r.ue();
+  const bitDepthChromaMinus8 = r.ue();
+  if (bitDepthLumaMinus8 > 8 || bitDepthChromaMinus8 > 8) throw new Error("HEVC SPS: bit depth is greater than 16");
+  return {
+    profileSpace,
+    tierFlag,
+    profileIdc,
+    profileCompatibilityFlags,
+    constraintIndicatorFlags,
+    levelIdc,
+    maxSubLayersMinus1,
+    temporalIdNestingFlag,
+    seqParameterSetId,
+    chromaFormatIdc,
+    picWidthInLumaSamples,
+    picHeightInLumaSamples,
+    bitDepthLumaMinus8,
+    bitDepthChromaMinus8
+  };
+}
+function hevcCodecStringFromSps(sps, sampleEntry) {
+  const info = parseHevcSps(sps);
+  return formatHevcCodecString(
+    sampleEntry,
+    info.profileSpace,
+    info.tierFlag,
+    info.profileIdc,
+    info.profileCompatibilityFlags,
+    info.constraintIndicatorFlags,
+    info.levelIdc
+  );
+}
+function formatHevcCodecString(sampleEntry, profileSpace, tierFlag, profileIdc, profileCompatibilityFlags, constraintIndicatorFlags, levelIdc) {
+  let reversed = 0;
+  let v = profileCompatibilityFlags >>> 0;
+  for (let i = 0; i < 32; i++) {
+    reversed = (reversed << 1 | v & 1) >>> 0;
+    v >>>= 1;
+  }
+  let lastNonZero = -1;
+  for (let i = 0; i < constraintIndicatorFlags.length; i++) if (constraintIndicatorFlags[i] !== 0) lastNonZero = i;
+  const space = profileSpace === 0 ? "" : String.fromCharCode(64 + profileSpace);
+  let codec = `${sampleEntry}.${space}${profileIdc}.${reversed.toString(16).toUpperCase()}.${tierFlag ? "H" : "L"}${levelIdc}`;
+  for (let i = 0; i <= lastNonZero; i++) codec += `.${constraintIndicatorFlags[i].toString(16).toUpperCase()}`;
+  return codec;
+}
+function splitHevcSample(data) {
+  if (isCompleteAvccSample(data)) return { nals: splitAvccNalUnits(data), lengthPrefixed: true };
+  if (isAnnexB(data)) return { nals: splitAnnexBNalUnits(data), lengthPrefixed: false };
+  return null;
+}
+function hevcNalUnitsContainIrap(nals) {
+  let sawNal = false;
+  for (const nal of nals) {
+    if (nal.length < HEVC_NAL_HEADER_LENGTH) continue;
+    sawNal = true;
+    if (isHevcIrapNalUnitType(hevcNalUnitType(nal))) return true;
+  }
+  return sawNal ? false : void 0;
+}
+function classifyHevcKeyframe(data) {
+  const split = splitHevcSample(data);
+  return split === null ? void 0 : hevcNalUnitsContainIrap(split.nals);
+}
+function detectHevcKeyframe(data) {
+  return classifyHevcKeyframe(data) === true;
+}
+function prepareHevcCmafSample(data, sampleEntry) {
+  const split = splitHevcSample(data);
+  if (split === null) return null;
+  const keyframe = hevcNalUnitsContainIrap(split.nals);
+  if (keyframe === void 0) return null;
+  const normalized = hevcNalUnitsToLengthPrefixed(data, split.nals, split.lengthPrefixed, sampleEntry);
+  return normalized === null ? null : { keyframe, data: normalized };
+}
+function normalizeHevcSampleToLengthPrefixed(data, sampleEntry) {
+  const prepared = prepareHevcCmafSample(data, sampleEntry);
+  if (prepared === null) {
+    throw new Error("HEVC sample is neither 4-byte length-prefixed nor Annex B, or holds no NAL unit to write");
+  }
+  return prepared.data;
+}
+function hevcNalUnitsToLengthPrefixed(data, nals, lengthPrefixed, sampleEntry) {
+  const kept = sampleEntry === "hvc1" ? nals.filter((nal) => {
+    const t = hevcNalUnitType(nal);
+    return t !== HEVC_NAL_UNIT_TYPE.VPS_NUT && t !== HEVC_NAL_UNIT_TYPE.SPS_NUT && t !== HEVC_NAL_UNIT_TYPE.PPS_NUT;
+  }) : nals;
+  if (kept.length === 0) return null;
+  if (lengthPrefixed && kept.length === nals.length) return data;
+  const out = new Uint8Array(kept.reduce((sum, nal) => sum + 4 + nal.length, 0));
+  let w = 0;
+  for (const nal of kept) {
+    w = writeNalLength(out, w, nal.length);
+    out.set(nal, w);
+    w += nal.length;
+  }
+  return out;
+}
+function splitAvccNalUnits(data, lengthSize = 4) {
+  const nals = [];
+  let i = 0;
+  while (i + lengthSize <= data.length) {
+    let len = 0;
+    for (let k = 0; k < lengthSize; k++) len = len << 8 | data[i + k];
+    i += lengthSize;
+    if (len <= 0 || i + len > data.length) break;
+    nals.push(data.subarray(i, i + len));
+    i += len;
+  }
+  return nals;
+}
+function isCompleteAvccSample(data, lengthSize = 4) {
+  let i = 0;
+  let count = 0;
+  while (i + lengthSize <= data.length) {
+    let len = 0;
+    for (let k = 0; k < lengthSize; k++) len = len << 8 | data[i + k];
+    i += lengthSize;
+    if (len <= 0 || i + len > data.length) return false;
+    i += len;
+    count++;
+  }
+  return count > 0 && i === data.length;
+}
+function normalizeH264SampleToAvcc(data) {
+  if (isCompleteAvccSample(data)) return { data, format: "avcc" };
+  if (isAnnexB(data)) return { data: annexBToAvcc(data), format: "annexb" };
+  if (isLikelyRawH264NalUnit(data)) return { data: rawH264NalToAvcc(data), format: "raw-nal" };
+  return { data, format: "unknown" };
+}
+function splitH264SampleNalUnits(data, options = {}) {
+  if (isCompleteAvccSample(data)) return { nals: splitAvccNalUnits(data), format: "avcc" };
+  if (isAnnexB(data)) return { nals: splitAnnexBNalUnits(data), format: "annexb" };
+  if (options.allowPartialAvcc === true) {
+    const partial = splitPartialAvccNalUnits(data);
+    if (partial.length > 0) return { nals: partial, format: "partial-avcc" };
+  }
+  if (isLikelyRawH264NalUnit(data)) return { nals: [data], format: "raw-nal" };
+  const nals = splitAvccNalUnits(data);
+  return { nals, format: nals.length > 0 ? "avcc" : "unknown" };
+}
+function extractHevcParameterSets(keyframe) {
+  const nals = isAnnexB(keyframe) ? splitAnnexBNalUnits(keyframe) : splitAvccNalUnits(keyframe);
+  const out = {};
+  for (const nal of nals) {
+    if (nal.length === 0) continue;
+    const t = hevcNalType(nal);
+    if (t === 32 && !out.vps) out.vps = nal;
+    else if (t === 33 && !out.sps) out.sps = nal;
+    else if (t === 34 && !out.pps) out.pps = nal;
+  }
+  return out;
+}
+function generateHvcCFromParameterSets(sets) {
+  const { vps, sps, pps } = sets;
+  if (!sps || !pps) return null;
+  const info = parseHevcSps(sps);
+  if (info.bitDepthLumaMinus8 > HVCC_MAX_BIT_DEPTH_MINUS8 || info.bitDepthChromaMinus8 > HVCC_MAX_BIT_DEPTH_MINUS8) {
+    throw new Error("HEVC SPS: bit depth of 16 is not representable in an hvcC record");
+  }
+  const arrays = [
+    { type: 32, nal: vps },
+    { type: 33, nal: sps },
+    { type: 34, nal: pps }
+  ].filter((a) => a.nal !== void 0);
+  let size = 23;
+  for (const a of arrays) size += 5 + a.nal.length;
+  const h = new Uint8Array(size);
+  let o = 0;
+  h[o++] = 1;
+  h[o++] = info.profileSpace << 6 | (info.tierFlag ? 1 : 0) << 5 | info.profileIdc;
+  h[o++] = info.profileCompatibilityFlags >>> 24 & 255;
+  h[o++] = info.profileCompatibilityFlags >>> 16 & 255;
+  h[o++] = info.profileCompatibilityFlags >>> 8 & 255;
+  h[o++] = info.profileCompatibilityFlags & 255;
+  h.set(info.constraintIndicatorFlags, o);
+  o += 6;
+  h[o++] = info.levelIdc;
+  h[o++] = 240;
+  h[o++] = 0;
+  h[o++] = 252;
+  h[o++] = 252 | info.chromaFormatIdc;
+  h[o++] = 248 | info.bitDepthLumaMinus8;
+  h[o++] = 248 | info.bitDepthChromaMinus8;
+  h[o++] = 0;
+  h[o++] = 0;
+  h[o++] = info.maxSubLayersMinus1 + 1 << 3 | (info.temporalIdNestingFlag ? 1 : 0) << 2 | 3;
+  h[o++] = arrays.length;
+  for (const a of arrays) {
+    h[o++] = a.type & 63;
+    h[o++] = 0;
+    h[o++] = 1;
+    h[o++] = a.nal.length >> 8 & 255;
+    h[o++] = a.nal.length & 255;
+    h.set(a.nal, o);
+    o += a.nal.length;
+  }
+  return h.subarray(0, o);
+}
+function extractHevcCodecDescription(keyframe) {
+  return generateHvcCFromParameterSets(extractHevcParameterSets(keyframe));
+}
+function hevcVclOnly(data) {
+  const nals = isAnnexB(data) ? splitAnnexBNalUnits(data) : splitAvccNalUnits(data);
+  const vcl = nals.filter((n) => n.length > 0 && hevcNalType(n) <= 31);
+  if (vcl.length === nals.length && !isAnnexB(data)) return data;
+  let size = 0;
+  for (const n of vcl) size += 4 + n.length;
+  const out = new Uint8Array(size);
+  let o = 0;
+  for (const n of vcl) {
+    out[o++] = n.length >> 24 & 255;
+    out[o++] = n.length >> 16 & 255;
+    out[o++] = n.length >> 8 & 255;
+    out[o++] = n.length & 255;
+    out.set(n, o);
+    o += n.length;
+  }
+  return out;
+}
+function isAnnexB(data) {
+  if (data.length >= 4 && data[0] === 0 && data[1] === 0 && (data[2] === 1 || data[2] === 0 && data[3] === 1)) {
+    return true;
+  }
+  return false;
+}
+function findAnnexBStartCode(data) {
+  for (let i = 0; i < data.length - 3; i++) {
+    if (data[i] === 0 && data[i + 1] === 0) {
+      if (data[i + 2] === 1) return i;
+      if (data[i + 2] === 0 && data[i + 3] === 1) return i;
+    }
+  }
+  return -1;
+}
+function splitAnnexBNalUnits(data) {
+  const nalUnits = [];
+  let i = 0;
+  while (i < data.length - 3) {
+    if (data[i] === 0 && data[i + 1] === 0) {
+      let scLen = 0;
+      if (data[i + 2] === 1) scLen = 3;
+      else if (data[i + 2] === 0 && i + 3 < data.length && data[i + 3] === 1) scLen = 4;
+      if (scLen > 0) {
+        const nalStart = i + scLen;
+        let nalEnd = data.length;
+        for (let j = nalStart + 1; j < data.length - 2; j++) {
+          if (data[j] === 0 && data[j + 1] === 0 && (data[j + 2] === 1 || data[j + 2] === 0 && j + 3 < data.length && data[j + 3] === 1)) {
+            nalEnd = j;
+            break;
+          }
+        }
+        if (nalEnd > nalStart) nalUnits.push(data.subarray(nalStart, nalEnd));
+        i = nalEnd;
+        continue;
+      }
+    }
+    i++;
+  }
+  return nalUnits;
+}
+function annexBToAvcc(data, spsPps) {
+  const nalUnits = splitAnnexBNalUnits(data);
+  if (nalUnits.length === 0) return data;
+  let extraSize = 0;
+  if (spsPps) {
+    extraSize = 4 + spsPps.sps.length + 4 + spsPps.pps.length;
+  }
+  const frameSize = nalUnits.reduce((sum, nal) => sum + 4 + nal.length, 0);
+  const output = new Uint8Array(extraSize + frameSize);
+  let w = 0;
+  if (spsPps) {
+    w = writeNalLength(output, w, spsPps.sps.length);
+    output.set(spsPps.sps, w);
+    w += spsPps.sps.length;
+    w = writeNalLength(output, w, spsPps.pps.length);
+    output.set(spsPps.pps, w);
+    w += spsPps.pps.length;
+  }
+  for (const nal of nalUnits) {
+    w = writeNalLength(output, w, nal.length);
+    output.set(nal, w);
+    w += nal.length;
+  }
+  return output;
+}
+function classifyH264Keyframe(data, options = {}) {
+  const nals = h264NalUnitsForKeyframeDetection(data, options);
+  if (nals.length === 0) return void 0;
+  let sawIntraSlice = false;
+  let sawNonIntraVcl = false;
+  let sawNal = false;
+  for (const nal of nals) {
+    sawNal = true;
+    const nalType = nal[0] !== void 0 ? nal[0] & 31 : -1;
+    if (nalType === 5 || nalType === 7) return true;
+    if (nalType === 1) {
+      if (isH264IntraSlice(nal)) sawIntraSlice = true;
+      else sawNonIntraVcl = true;
+    }
+  }
+  if (sawIntraSlice && !sawNonIntraVcl) return true;
+  return sawNal ? false : void 0;
+}
+function detectH264Keyframe(data, options = {}) {
+  return classifyH264Keyframe(data, options) === true;
+}
+function mmtpTimestampToMicros(rawTs) {
+  const ts = typeof rawTs === "bigint" ? rawTs >= 0n && rawTs <= 0xffffffffn ? Number(rawTs) : void 0 : Number.isSafeInteger(rawTs) && rawTs >= 0 && rawTs <= 4294967295 ? rawTs : void 0;
+  if (ts === void 0) {
+    throw new RangeError(`MMTP timestamp must be an unsigned 32-bit integer, got ${String(rawTs)}`);
+  }
+  if (ts === 0) return 0;
+  const seconds = ts >>> 16;
+  const frac = ts & 65535;
+  return seconds * 1e6 + Math.floor(frac * 1e6 / 65536);
+}
+function isFmp4InitSegment(data) {
+  let offset = 0;
+  let sawFtyp = false;
+  let sawMoov = false;
+  while (offset + 8 <= data.byteLength) {
+    const view = new DataView(data.buffer, data.byteOffset + offset, data.byteLength - offset);
+    let size = view.getUint32(0, false);
+    const type = String.fromCharCode(data[offset + 4], data[offset + 5], data[offset + 6], data[offset + 7]);
+    let headerSize = 8;
+    if (size === 1) {
+      if (offset + 16 > data.byteLength) return false;
+      const largeSize = view.getBigUint64(8, false);
+      if (largeSize > BigInt(Number.MAX_SAFE_INTEGER)) return false;
+      size = Number(largeSize);
+      headerSize = 16;
+    } else if (size === 0) {
+      size = data.byteLength - offset;
+    }
+    if (size < headerSize || offset + size > data.byteLength) return false;
+    if (type === "mmpu") return false;
+    if (type === "ftyp") sawFtyp = true;
+    if (type === "moov") {
+      if (!sawFtyp) return false;
+      sawMoov = true;
+    }
+    offset += size;
+  }
+  return offset === data.byteLength && sawFtyp && sawMoov;
+}
+function normalizeMmtpInitSegment(data) {
+  if (isFmp4InitSegment(data)) return data;
+  const parts = [];
+  let offset = 0;
+  let removedMpu = false;
+  while (offset + 8 <= data.byteLength) {
+    const view = new DataView(data.buffer, data.byteOffset + offset, data.byteLength - offset);
+    let size = view.getUint32(0, false);
+    let headerSize = 8;
+    if (size === 1) {
+      if (offset + 16 > data.byteLength) return void 0;
+      const largeSize = view.getBigUint64(8, false);
+      if (largeSize > BigInt(Number.MAX_SAFE_INTEGER)) return void 0;
+      size = Number(largeSize);
+      headerSize = 16;
+    } else if (size === 0) {
+      size = data.byteLength - offset;
+    }
+    if (size < headerSize || offset + size > data.byteLength) return void 0;
+    const type = String.fromCharCode(
+      data[offset + 4],
+      data[offset + 5],
+      data[offset + 6],
+      data[offset + 7]
+    );
+    if (type === "mmpu") removedMpu = true;
+    else parts.push(data.subarray(offset, offset + size));
+    offset += size;
+  }
+  if (!removedMpu || offset !== data.byteLength) return void 0;
+  const normalized = new Uint8Array(parts.reduce((total, part) => total + part.byteLength, 0));
+  let writeOffset = 0;
+  for (const part of parts) {
+    normalized.set(part, writeOffset);
+    writeOffset += part.byteLength;
+  }
+  return isFmp4InitSegment(normalized) ? normalized : void 0;
+}
+function hasIsoBmffMagic(data) {
+  for (let i = 0; i + 8 <= data.length && i < 32; i += 4) {
+    const tag = String.fromCharCode(data[i + 4], data[i + 5], data[i + 6], data[i + 7]);
+    if (tag === "ftyp" || tag === "moov") return true;
+  }
+  return false;
+}
+function findTrackStsdBoxes(data) {
+  const moov = findBox(data, 0, data.length, "moov");
+  if (!moov) return [];
+  const out = [];
+  for (const trak of findBoxes(data, moov.o + 8, moov.o + moov.sz, "trak")) {
+    const stsd = findNestedBox(data, trak.o + 8, trak.o + trak.sz, ["mdia", "minf", "stbl", "stsd"]);
+    if (stsd) out.push(stsd);
+  }
+  return out;
+}
+function findNestedBox(buf, start, end, path) {
+  let s = start;
+  let e = end;
+  let current;
+  for (const type of path) {
+    current = findBox(buf, s, e, type);
+    if (!current) return void 0;
+    s = current.o + 8;
+    e = current.o + current.sz;
+  }
+  return current;
+}
+function findBox(buf, start, end, type) {
+  return findBoxes(buf, start, end, type)[0];
+}
+function findBoxes(buf, start, end, type) {
+  const boxes = [];
+  let o = start;
+  while (o + 8 <= end) {
+    let sz = buf[o] << 24 | buf[o + 1] << 16 | buf[o + 2] << 8 | buf[o + 3];
+    const t = String.fromCharCode(buf[o + 4], buf[o + 5], buf[o + 6], buf[o + 7]);
+    if (sz === 0) sz = end - o;
+    if (sz < 8 || o + sz > end) break;
+    if (t === type) boxes.push({ o, sz });
+    o += sz;
+  }
+  return boxes;
+}
+function writeNalLength(buf, offset, len) {
+  buf[offset] = len >> 24 & 255;
+  buf[offset + 1] = len >> 16 & 255;
+  buf[offset + 2] = len >> 8 & 255;
+  buf[offset + 3] = len & 255;
+  return offset + 4;
+}
+function h264NalUnitsForKeyframeDetection(data, options) {
+  return splitH264SampleNalUnits(data, options).nals;
+}
+function splitPartialAvccNalUnits(data, lengthSize = 4) {
+  const nals = [];
+  let i = 0;
+  while (i + lengthSize < data.length) {
+    let len = 0;
+    for (let k = 0; k < lengthSize; k++) len = len << 8 | data[i + k];
+    i += lengthSize;
+    if (len <= 0 || i >= data.length) break;
+    const end = Math.min(i + len, data.length);
+    nals.push(data.subarray(i, end));
+    if (end < i + len) break;
+    i = end;
+  }
+  return nals;
+}
+function isLikelyRawH264NalUnit(data) {
+  if (data.length === 0) return false;
+  const header = data[0];
+  if ((header & 128) !== 0) return false;
+  const nalType = header & 31;
+  return nalType > 0 && nalType < 24;
+}
+function rawH264NalToAvcc(data) {
+  const out = new Uint8Array(4 + data.length);
+  new DataView(out.buffer, out.byteOffset, out.byteLength).setUint32(0, data.length);
+  out.set(data, 4);
+  return out;
+}
+function isH264IntraSlice(nal) {
+  const sliceType = readH264SliceType(nal);
+  return sliceType === 2 || sliceType === 4 || sliceType === 7 || sliceType === 9;
+}
+function readH264SliceType(nal) {
+  if (nal.length < 2 || (nal[0] & 31) !== 1) return null;
+  const rbsp = removeEmulationPrevention(nal.subarray(1));
+  const state = { bitOffset: 0 };
+  if (readUnsignedExpGolomb(rbsp, state) === null) return null;
+  return readUnsignedExpGolomb(rbsp, state);
+}
+function readUnsignedExpGolomb(data, state) {
+  let leadingZeroBits = 0;
+  while (true) {
+    const bit = readBit(data, state);
+    if (bit === null) return null;
+    if (bit === 1) break;
+    leadingZeroBits++;
+    if (leadingZeroBits > 30) return null;
+  }
+  let suffix = 0;
+  for (let i = 0; i < leadingZeroBits; i++) {
+    const bit = readBit(data, state);
+    if (bit === null) return null;
+    suffix = suffix << 1 | bit;
+  }
+  return (1 << leadingZeroBits) - 1 + suffix;
+}
+function readBit(data, state) {
+  if (state.bitOffset >= data.length * 8) return null;
+  const byte = data[state.bitOffset >> 3];
+  const bit = byte >> 7 - (state.bitOffset & 7) & 1;
+  state.bitOffset++;
+  return bit;
+}
+function hex2(n) {
+  return n.toString(16).padStart(2, "0");
+}
+function pad2(n) {
+  return String(n).padStart(2, "0");
+}
+function codecStringFromAv1C(av1C) {
+  if (av1C.length < 4) return "av01.0.01M.08";
+  const profile = av1C[1] >>> 5 & 7;
+  const level = av1C[1] & 31;
+  const tier = (av1C[2] & 128) !== 0 ? "H" : "M";
+  let bitDepth = 8;
+  if ((av1C[2] & 64) !== 0) {
+    bitDepth = (av1C[2] & 32) !== 0 ? 12 : 10;
+  }
+  return `av01.${profile}.${pad2(level)}${tier}.${pad2(bitDepth)}`;
+}
+function codecStringFromVpcC(vpcC) {
+  if (vpcC.length < 3) return "vp09.00.10.08";
+  const offset = vpcC.length >= 7 && vpcC[0] <= 1 ? 4 : 0;
+  if (offset + 2 >= vpcC.length) return "vp09.00.10.08";
+  const profile = vpcC[offset];
+  const level = vpcC[offset + 1];
+  const bitDepth = vpcC[offset + 2] >>> 4 || 8;
+  return `vp09.${pad2(profile)}.${pad2(level)}.${pad2(bitDepth)}`;
+}
+function hevcCodecStringFromHvcC(c, sampleEntry) {
+  return formatHevcCodecString(
+    sampleEntry,
+    c[1] >> 6 & 3,
+    (c[1] >> 5 & 1) === 1,
+    c[1] & 31,
+    (c[2] << 24 | c[3] << 16 | c[4] << 8 | c[5]) >>> 0,
+    c.subarray(6, 12),
+    c[12]
+  );
+}
+var BitWriter = class {
+  constructor() {
+    this.buf = [];
+    this.byte = 0;
+    this.bit = 7;
+  }
+  u(val, bits) {
+    for (let i = bits - 1; i >= 0; i--) {
+      this.byte |= (val >> i & 1) << this.bit;
+      if (--this.bit < 0) {
+        this.buf.push(this.byte);
+        this.byte = 0;
+        this.bit = 7;
+      }
+    }
+  }
+  ue(val) {
+    const v = val + 1;
+    const bits = Math.floor(Math.log2(v)) + 1;
+    this.u(0, bits - 1);
+    this.u(v, bits);
+  }
+  se(val) {
+    this.ue(val <= 0 ? -val * 2 : val * 2 - 1);
+  }
+  finish() {
+    if (this.bit < 7) {
+      this.byte |= 1 << this.bit;
+      this.buf.push(this.byte);
+    }
+    return new Uint8Array(this.buf);
+  }
+};
+function resolveResolution(explicitW, explicitH, level) {
+  if (explicitW && explicitH) return { width: explicitW, height: explicitH };
+  const levelResolutions = {
+    10: [176, 144],
+    11: [352, 288],
+    12: [352, 288],
+    13: [352, 288],
+    20: [352, 288],
+    21: [720, 576],
+    22: [720, 576],
+    30: [1280, 720],
+    31: [1280, 720],
+    32: [1280, 1024],
+    40: [1920, 1088],
+    41: [1920, 1088],
+    42: [2048, 1088],
+    50: [4096, 2160],
+    51: [4096, 2160],
+    52: [4096, 2160]
+  };
+  const [w, h] = levelResolutions[level] ?? [1920, 1088];
+  return { width: explicitW ?? w, height: explicitH ?? h };
+}
+function buildMinimalSps(profile, constraint, level, width, height) {
+  const widthInMbs = Math.ceil(width / 16);
+  const heightInMapUnits = Math.ceil(height / 16);
+  const w = new BitWriter();
+  w.u(0, 1);
+  w.u(3, 2);
+  w.u(7, 5);
+  w.u(profile, 8);
+  w.u(constraint, 8);
+  w.u(level, 8);
+  w.ue(0);
+  if (profile === 100 || profile === 110 || profile === 122 || profile === 244 || profile === 44) {
+    w.ue(1);
+    w.ue(0);
+    w.ue(0);
+    w.u(0, 1);
+    w.u(0, 1);
+  }
+  w.ue(0);
+  w.ue(2);
+  w.ue(1);
+  w.u(0, 1);
+  w.ue(widthInMbs - 1);
+  w.ue(heightInMapUnits - 1);
+  w.u(1, 1);
+  w.u(1, 1);
+  const cropRight = widthInMbs * 16 - width;
+  const cropBottom = heightInMapUnits * 16 - height;
+  if (cropRight > 0 || cropBottom > 0) {
+    w.u(1, 1);
+    w.ue(0);
+    w.ue(cropRight / 2);
+    w.ue(0);
+    w.ue(cropBottom / 2);
+  } else {
+    w.u(0, 1);
+  }
+  w.u(0, 1);
+  return w.finish();
+}
+function buildMinimalPps(profile) {
+  const isHighProfile = profile === 100 || profile === 110 || profile === 122 || profile === 244 || profile === 44;
+  const w = new BitWriter();
+  w.u(0, 1);
+  w.u(3, 2);
+  w.u(8, 5);
+  w.ue(0);
+  w.ue(0);
+  w.u(isHighProfile ? 1 : 0, 1);
+  w.u(0, 1);
+  w.ue(0);
+  w.ue(0);
+  w.ue(0);
+  w.u(0, 1);
+  w.u(0, 2);
+  w.se(0);
+  w.se(0);
+  w.se(0);
+  w.u(1, 1);
+  w.u(0, 1);
+  w.u(0, 1);
+  if (isHighProfile) {
+    w.u(1, 1);
+    w.u(0, 1);
+    w.se(0);
+  }
+  return w.finish();
+}
+var ADTS_SAMPLE_RATES = [96e3, 88200, 64e3, 48e3, 44100, 32e3, 24e3, 22050, 16e3, 12e3, 11025, 8e3, 7350];
+function wrapAdtsFrame(raw, sampleRate, channels) {
+  const sri = ADTS_SAMPLE_RATES.indexOf(sampleRate);
+  const idx = sri >= 0 ? sri : 3;
+  const len = 7 + raw.length;
+  const out = new Uint8Array(len);
+  out[0] = 255;
+  out[1] = 241;
+  out[2] = 1 << 6 | idx << 2 | channels >> 2;
+  out[3] = (channels & 3) << 6 | len >> 11 & 3;
+  out[4] = len >> 3 & 255;
+  out[5] = (len & 7) << 5 | 31;
+  out[6] = 252;
+  out.set(raw, 7);
+  return out;
+}
+function extractAacAscFromInitSegment(data) {
+  if (!hasIsoBmffMagic(data)) return void 0;
+  for (const stsd of findTrackStsdBoxes(data)) {
+    const info = extractAacAscFromStsd(data, stsd);
+    if (info) return info;
+  }
+  return void 0;
+}
+function extractAacAscFromStsd(data, stsd) {
+  const s = stsd.o + 16;
+  const e = stsd.o + stsd.sz;
+  const mp4a = findBox(data, s, e, "mp4a");
+  if (!mp4a || mp4a.sz < 36) return void 0;
+  const esds = findBox(data, mp4a.o + 36, mp4a.o + mp4a.sz, "esds");
+  if (!esds || esds.sz < 12) return void 0;
+  const esdsPayload = data.subarray(esds.o + 8, esds.o + esds.sz);
+  const asc = extractAudioSpecificConfig(esdsPayload);
+  if (!asc || asc.length < 2) return void 0;
+  const aot = asc[0] >> 3;
+  return { codec: `mp4a.40.${aot}`, description: asc };
+}
+function extractAudioSpecificConfig(esds) {
+  let offset = 4;
+  while (offset < esds.length) {
+    const tag = esds[offset++];
+    let size = 0;
+    for (let i = 0; i < 4 && offset < esds.length; i++) {
+      const b = esds[offset++];
+      size = size << 7 | b & 127;
+      if ((b & 128) === 0) break;
+    }
+    if (tag === 5) {
+      if (offset + size > esds.length) return void 0;
+      return esds.subarray(offset, offset + size);
+    }
+    if (tag === 3) {
+      offset += 3;
+    } else if (tag === 4) {
+      offset += 13;
+    } else {
+      offset += size;
+    }
+  }
+  return void 0;
+}
+if (void 0) {
+  const { describe, test, expect } = void 0;
+  describe("codec-utils", () => {
+    describe("isAnnexB", () => {
+      test("4-byte start code", () => {
+        expect(isAnnexB(new Uint8Array([0, 0, 0, 1, 101]))).toBe(true);
+      });
+      test("3-byte start code", () => {
+        expect(isAnnexB(new Uint8Array([0, 0, 1, 101]))).toBe(true);
+      });
+      test("rejects AVCC", () => {
+        expect(isAnnexB(new Uint8Array([0, 0, 0, 10, 101]))).toBe(false);
+      });
+    });
+    describe("findAnnexBStartCode", () => {
+      test("at offset 0", () => {
+        expect(findAnnexBStartCode(new Uint8Array([0, 0, 0, 1, 101]))).toBe(0);
+      });
+      test("at offset 5", () => {
+        expect(findAnnexBStartCode(new Uint8Array([170, 187, 204, 221, 238, 0, 0, 1, 101]))).toBe(5);
+      });
+      test("returns -1 when none", () => {
+        expect(findAnnexBStartCode(new Uint8Array([170, 187, 204]))).toBe(-1);
+      });
+    });
+    describe("splitAnnexBNalUnits", () => {
+      test("splits two NALs", () => {
+        const data = new Uint8Array([0, 0, 0, 1, 101, 170, 187, 0, 0, 0, 1, 65, 204]);
+        const nals = splitAnnexBNalUnits(data);
+        expect(nals.length).toBe(2);
+        expect(nals[0]).toEqual(new Uint8Array([101, 170, 187]));
+        expect(nals[1]).toEqual(new Uint8Array([65, 204]));
+      });
+      test("handles 3-byte start codes", () => {
+        const nals = splitAnnexBNalUnits(new Uint8Array([0, 0, 1, 103, 66, 0, 0, 1, 104, 1]));
+        expect(nals.length).toBe(2);
+      });
+    });
+    describe("annexBToAvcc", () => {
+      test("converts single NAL", () => {
+        const annexB = new Uint8Array([0, 0, 0, 1, 65, 170, 187]);
+        const avcc = annexBToAvcc(annexB);
+        expect(avcc[3]).toBe(3);
+        expect(avcc[4]).toBe(65);
+      });
+      test("prepends SPS/PPS", () => {
+        const annexB = new Uint8Array([0, 0, 0, 1, 101, 1]);
+        const avcc = annexBToAvcc(annexB, { sps: new Uint8Array([103, 66]), pps: new Uint8Array([104, 1]) });
+        expect(avcc[3]).toBe(2);
+        expect(avcc[4]).toBe(103);
+      });
+    });
+    describe("detectH264Keyframe", () => {
+      test("IDR in Annex-B", () => {
+        expect(detectH264Keyframe(new Uint8Array([0, 0, 0, 1, 101]))).toBe(true);
+      });
+      test("SPS in Annex-B", () => {
+        expect(detectH264Keyframe(new Uint8Array([0, 0, 0, 1, 103]))).toBe(true);
+      });
+      test("IDR in AVCC", () => {
+        expect(detectH264Keyframe(new Uint8Array([0, 0, 0, 5, 101, 1, 2, 3, 4]))).toBe(true);
+      });
+      test("IDR after AVCC AUD", () => {
+        expect(detectH264Keyframe(new Uint8Array([
+          0,
+          0,
+          0,
+          1,
+          9,
+          0,
+          0,
+          0,
+          2,
+          101,
+          170
+        ]))).toBe(true);
+      });
+      test("non-IDR AVC I-slice in AVCC", () => {
+        expect(detectH264Keyframe(new Uint8Array([
+          0,
+          0,
+          0,
+          2,
+          65,
+          136
+        ]))).toBe(true);
+      });
+      test("raw H.264 IDR NAL", () => {
+        expect(detectH264Keyframe(new Uint8Array([101, 136, 132]))).toBe(true);
+      });
+      test("raw H.264 non-IDR I-slice NAL", () => {
+        expect(detectH264Keyframe(new Uint8Array([65, 136]))).toBe(true);
+      });
+      test("classifies partial length-prefixed IDR only when requested", () => {
+        const partial = new Uint8Array([0, 0, 32, 0, 101]);
+        expect(classifyH264Keyframe(partial)).toBeUndefined();
+        expect(classifyH264Keyframe(partial, { allowPartialAvcc: true })).toBe(true);
+      });
+      test("rejects P-frame", () => {
+        expect(detectH264Keyframe(new Uint8Array([0, 0, 0, 1, 65]))).toBe(false);
+      });
+      test("rejects AVCC sample with only non-IDR slices", () => {
+        expect(detectH264Keyframe(new Uint8Array([
+          0,
+          0,
+          0,
+          2,
+          65,
+          192,
+          0,
+          0,
+          0,
+          2,
+          65,
+          192
+        ]))).toBe(false);
+      });
+    });
+    describe("avccToAnnexB", () => {
+      test("converts with SPS/PPS on keyframe", () => {
+        const avcc = new Uint8Array([0, 0, 0, 3, 101, 170, 187]);
+        const spsPps = { sps: new Uint8Array([103, 66]), pps: new Uint8Array([104, 1]) };
+        const annexB = avccToAnnexB(avcc, true, spsPps);
+        expect(annexB[3]).toBe(1);
+        expect(annexB[4]).toBe(103);
+      });
+    });
+    describe("codecStringFromAvcC", () => {
+      test("derives avc1.64002a", () => {
+        expect(codecStringFromAvcC(new Uint8Array([1, 100, 0, 42]))).toBe("avc1.64002a");
+      });
+    });
+    describe("extractAacAscFromInitSegment", () => {
+      function buildMinimalAacInit(asc) {
+        const box = (type, payload) => {
+          const sz = 8 + payload.length;
+          const out = new Uint8Array(sz);
+          out[0] = sz >>> 24 & 255;
+          out[1] = sz >>> 16 & 255;
+          out[2] = sz >>> 8 & 255;
+          out[3] = sz & 255;
+          out[4] = type.charCodeAt(0);
+          out[5] = type.charCodeAt(1);
+          out[6] = type.charCodeAt(2);
+          out[7] = type.charCodeAt(3);
+          out.set(payload, 8);
+          return out;
+        };
+        const concat = (...arrs) => {
+          const total = arrs.reduce((n, a) => n + a.length, 0);
+          const out = new Uint8Array(total);
+          let off = 0;
+          for (const a of arrs) {
+            out.set(a, off);
+            off += a.length;
+          }
+          return out;
+        };
+        const ftyp = box("ftyp", new Uint8Array([
+          105,
+          115,
+          111,
+          53,
+          // 'iso5'
+          0,
+          0,
+          2,
+          0,
+          // minor 0x200
+          105,
+          115,
+          111,
+          53,
+          // 'iso5'
+          105,
+          115,
+          111,
+          54
+          // 'iso6'
+        ]));
+        const dsi = new Uint8Array(2 + asc.length);
+        dsi[0] = 5;
+        dsi[1] = asc.length;
+        dsi.set(asc, 2);
+        const dcd = new Uint8Array(2 + 13 + dsi.length);
+        dcd[0] = 4;
+        dcd[1] = 13 + dsi.length;
+        dcd[2] = 64;
+        dcd[3] = 5 << 2 | 1;
+        dcd.set(dsi, 15);
+        const esd = new Uint8Array(2 + 3 + dcd.length);
+        esd[0] = 3;
+        esd[1] = 3 + dcd.length;
+        esd.set(dcd, 5);
+        const esdsPayload = new Uint8Array(4 + esd.length);
+        esdsPayload.set(esd, 4);
+        const esds = box("esds", esdsPayload);
+        const mp4aFixed = new Uint8Array(28);
+        mp4aFixed[7] = 1;
+        mp4aFixed[16] = 0;
+        mp4aFixed[17] = 1;
+        mp4aFixed[18] = 0;
+        mp4aFixed[19] = 16;
+        mp4aFixed[24] = 187;
+        mp4aFixed[25] = 128;
+        const mp4a = box("mp4a", concat(mp4aFixed, esds));
+        const stsdPayload = new Uint8Array(8 + mp4a.length);
+        stsdPayload[7] = 1;
+        stsdPayload.set(mp4a, 8);
+        const stsd = box("stsd", stsdPayload);
+        const stbl = box("stbl", stsd);
+        const minf = box("minf", stbl);
+        const mdia = box("mdia", minf);
+        const trak = box("trak", mdia);
+        const moov = box("moov", trak);
+        return concat(ftyp, moov);
+      }
+      test("extracts AAC-LC mono 48k ASC and derives codec", () => {
+        const asc = new Uint8Array([17, 136]);
+        const init = buildMinimalAacInit(asc);
+        const result = extractAacAscFromInitSegment(init);
+        expect(result).toBeDefined();
+        expect(result.codec).toBe("mp4a.40.2");
+        expect(Array.from(result.description)).toEqual([17, 136]);
+      });
+      test("derives AOT 5 (HE-AAC) from ASC[0] >> 3", () => {
+        const asc = new Uint8Array([41, 136]);
+        const init = buildMinimalAacInit(asc);
+        expect(extractAacAscFromInitSegment(init)?.codec).toBe("mp4a.40.5");
+      });
+      test("rejects data without ftyp/moov magic", () => {
+        expect(extractAacAscFromInitSegment(new Uint8Array(64))).toBeUndefined();
+      });
+      test("rejects ftyp+moov with no audio (no mp4a sample entry)", () => {
+        const ftyp = new Uint8Array([
+          0,
+          0,
+          0,
+          24,
+          102,
+          116,
+          121,
+          112,
+          105,
+          115,
+          111,
+          53,
+          0,
+          0,
+          2,
+          0,
+          105,
+          115,
+          111,
+          53,
+          105,
+          115,
+          111,
+          54
+        ]);
+        const moov = new Uint8Array([0, 0, 0, 8, 109, 111, 111, 118]);
+        const cat = new Uint8Array(ftyp.length + moov.length);
+        cat.set(ftyp);
+        cat.set(moov, ftyp.length);
+        expect(extractAacAscFromInitSegment(cat)).toBeUndefined();
+      });
+    });
+    describe("hevc", () => {
+      const vps = new Uint8Array([
+        64,
+        1,
+        12,
+        1,
+        255,
+        255,
+        1,
+        96,
+        0,
+        0,
+        3,
+        0,
+        144,
+        0,
+        0,
+        3,
+        0,
+        0,
+        3,
+        0,
+        60,
+        146,
+        128,
+        144
+      ]);
+      const sps = new Uint8Array([
+        66,
+        1,
+        1,
+        1,
+        96,
+        0,
+        0,
+        3,
+        0,
+        144,
+        0,
+        0,
+        3,
+        0,
+        0,
+        3,
+        0,
+        60,
+        160,
+        10,
+        8,
+        15,
+        22,
+        89,
+        42,
+        73,
+        50,
+        188,
+        5,
+        160,
+        32,
+        0,
+        0,
+        3,
+        0,
+        32,
+        0,
+        0,
+        3,
+        3,
+        193
+      ]);
+      const pps = new Uint8Array([68, 1, 193, 114, 180, 98, 64]);
+      const idr = new Uint8Array([38, 1, 175, 6]);
+      const lp = (...nals) => {
+        const parts = [];
+        for (const n of nals) {
+          parts.push(n.length >> 24 & 255, n.length >> 16 & 255, n.length >> 8 & 255, n.length & 255, ...n);
+        }
+        return Uint8Array.from(parts);
+      };
+      test("isHevcCodec", () => {
+        expect(isHevcCodec("hev1.1.6.L93.B0")).toBe(true);
+        expect(isHevcCodec("hvc1.1.6.L93.B0")).toBe(true);
+        expect(isHevcCodec("avc1.640033")).toBe(false);
+      });
+      test("removeEmulationPrevention strips 0x03", () => {
+        expect(Array.from(removeEmulationPrevention(new Uint8Array([0, 0, 3, 1])))).toEqual([0, 0, 1]);
+        expect(Array.from(removeEmulationPrevention(new Uint8Array([170, 187])))).toEqual([170, 187]);
+      });
+      test("splitAvccNalUnits splits length-prefixed NALs", () => {
+        const nals = splitAvccNalUnits(lp(vps, sps));
+        expect(nals.length).toBe(2);
+        expect(nals[0]).toEqual(vps);
+        expect(nals[1]).toEqual(sps);
+      });
+      test("isCompleteAvccSample accepts complete length-prefixed NAL samples", () => {
+        expect(isCompleteAvccSample(lp(new Uint8Array([9]), idr))).toBe(true);
+      });
+      test("isCompleteAvccSample rejects Annex-B start-code samples", () => {
+        expect(isCompleteAvccSample(new Uint8Array([0, 0, 0, 1, 101, 170]))).toBe(false);
+      });
+      test("isCompleteAvccSample rejects truncated length-prefixed samples", () => {
+        expect(isCompleteAvccSample(new Uint8Array([0, 0, 0, 4, 101, 170]))).toBe(false);
+      });
+      test("normalizeH264SampleToAvcc leaves complete AVCC samples unchanged", () => {
+        const avcc = lp(new Uint8Array([9]), idr);
+        const normalized = normalizeH264SampleToAvcc(avcc);
+        expect(normalized.format).toBe("avcc");
+        expect(normalized.data).toBe(avcc);
+      });
+      test("normalizeH264SampleToAvcc converts a single raw H.264 NAL to AVCC", () => {
+        const raw = new Uint8Array([101, 136, 132]);
+        const normalized = normalizeH264SampleToAvcc(raw);
+        expect(normalized.format).toBe("raw-nal");
+        expect(normalized.data).toEqual(new Uint8Array([0, 0, 0, 3, 101, 136, 132]));
+      });
+      test("splitH264SampleNalUnits exposes Annex-B NALs without AVCC conversion", () => {
+        const annexB = new Uint8Array([0, 0, 0, 1, 101, 136, 132]);
+        const sample = splitH264SampleNalUnits(annexB);
+        expect(sample.format).toBe("annexb");
+        expect(sample.nals).toHaveLength(1);
+        expect(sample.nals[0]).toEqual(new Uint8Array([101, 136, 132]));
+      });
+      test("splitH264SampleNalUnits exposes single raw H.264 NALs without wrapping", () => {
+        const raw = new Uint8Array([101, 136, 132]);
+        const sample = splitH264SampleNalUnits(raw);
+        expect(sample.format).toBe("raw-nal");
+        expect(sample.nals).toEqual([raw]);
+      });
+      test("splitH264SampleNalUnits can expose partial AVCC NAL headers", () => {
+        const partial = new Uint8Array([0, 0, 0, 5, 101, 136]);
+        const sample = splitH264SampleNalUnits(partial, { allowPartialAvcc: true });
+        expect(sample.format).toBe("partial-avcc");
+        expect(sample.nals).toHaveLength(1);
+        expect(sample.nals[0]).toEqual(new Uint8Array([101, 136]));
+      });
+      test("extractHevcParameterSets finds VPS/SPS/PPS (length-prefixed)", () => {
+        const sets = extractHevcParameterSets(lp(vps, sps, pps, idr));
+        expect(sets.vps).toEqual(vps);
+        expect(sets.sps).toEqual(sps);
+        expect(sets.pps).toEqual(pps);
+      });
+      test("extractHevcParameterSets finds VPS/SPS/PPS (Annex-B)", () => {
+        const sc = new Uint8Array([0, 0, 0, 1]);
+        const annexb = Uint8Array.from([...sc, ...vps, ...sc, ...sps, ...sc, ...pps, ...sc, ...idr]);
+        const sets = extractHevcParameterSets(annexb);
+        expect(sets.vps).toEqual(vps);
+        expect(sets.sps).toEqual(sps);
+        expect(sets.pps).toEqual(pps);
+      });
+      test("generateHvcCFromParameterSets builds a valid hvcC", () => {
+        const hvcc = generateHvcCFromParameterSets({ vps, sps, pps });
+        expect(hvcc).not.toBeNull();
+        expect(hvcc[0]).toBe(1);
+        expect(hvcc[1]).toBe(sps[3]);
+        expect(hvcc[22]).toBe(3);
+        expect(hvcc[23] & 63).toBe(32);
+        expect(hvcc[24] << 8 | hvcc[25]).toBe(1);
+      });
+      test("generateHvcCFromParameterSets returns null without SPS/PPS", () => {
+        expect(generateHvcCFromParameterSets({ vps })).toBeNull();
+      });
+      test("extractHevcCodecDescription end-to-end from keyframe", () => {
+        const desc = extractHevcCodecDescription(lp(vps, sps, pps, idr));
+        expect(desc).not.toBeNull();
+        expect(desc[0]).toBe(1);
+      });
+      test("hevcVclOnly strips parameter-set NALs, keeps VCL", () => {
+        const stripped = hevcVclOnly(lp(vps, sps, pps, idr));
+        const nals = splitAvccNalUnits(stripped);
+        expect(nals.length).toBe(1);
+        expect(nals[0]).toEqual(idr);
+      });
+      test("hevcVclOnly is a no-op for VCL-only length-prefixed input", () => {
+        const vclOnly = lp(idr);
+        expect(hevcVclOnly(vclOnly)).toBe(vclOnly);
+      });
+    });
+  });
+}
+export {
+  HEVC_NAL_HEADER_LENGTH,
+  HEVC_NAL_UNIT_TYPE,
+  annexBToAvcc,
+  avccToAnnexB,
+  classifyH264Keyframe,
+  classifyHevcKeyframe,
+  codecStringFromAvcC,
+  detectH264Keyframe,
+  detectHevcKeyframe,
+  extractAacAscFromInitSegment,
+  extractAvcCFromInitSegment,
+  extractCodecDescriptionFromAnnexB,
+  extractHevcCodecDescription,
+  extractHevcParameterSets,
+  extractSpsPpsFromAvcC,
+  findAnnexBStartCode,
+  generateFallbackAvcC,
+  generateHvcCFromParameterSets,
+  hevcCodecStringFromSps,
+  hevcNalUnitType,
+  hevcVclOnly,
+  isAnnexB,
+  isCompleteAvccSample,
+  isFmp4InitSegment,
+  isHevcCodec,
+  isHevcIrapNalUnitType,
+  mmtpTimestampToMicros,
+  normalizeH264SampleToAvcc,
+  normalizeHevcSampleToLengthPrefixed,
+  normalizeMmtpInitSegment,
+  parseHevcSps,
+  prepareHevcCmafSample,
+  removeEmulationPrevention,
+  splitAnnexBNalUnits,
+  splitAvccNalUnits,
+  splitH264SampleNalUnits,
+  videoCodecFamily,
+  videoSampleEntryFromCodecString,
+  wrapAdtsFrame
+};
+//# sourceMappingURL=codec-utils.js.map