@ahmedrowaihi/mediabunny 1.65.2-beta.325 → 1.65.2-beta.415

package/dist/bundles/mediabunny.cjs

@@ -312,6 +312,8 @@ var Mediabunny = (() => {
     buildMdcvBox: () => buildMdcvBox,
     buildPlayReadyObject: () => buildPlayReadyObject,
     buildPlayReadyPssh: () => buildPlayReadyPssh,
+    buildTfrfBox: () => buildTfrfBox,
+    buildTfxdBox: () => buildTfxdBox,
     buildWidevinePssh: () => buildWidevinePssh,
     canDecode: () => canDecode,
     canDecodeAudio: () => canDecodeAudio,
@@ -412,6 +414,7 @@ var Mediabunny = (() => {
     hlsVariant: () => hlsVariant,
     hlsVersionOf: () => hlsVersionOf,
     insertBoxesBeforeMoof: () => insertBoxesBeforeMoof,
+    insertBoxesIntoTraf: () => insertBoxesIntoTraf,
     isInitializationSegment: () => isInitializationSegment,
     iterateIsobmffBoxes: () => iterateIsobmffBoxes,
     keepCodecs: () => keepCodecs,
@@ -61983,6 +61986,23 @@ ${baseUrl}${p.getFileName()}`;
 
   // src/crypto/h265-slice-header-parser.ts
   var ceilLog2 = (n) => Math.ceil(Math.log2(n));
+  var skipScalingListData2 = (bs) => {
+    for (let sizeId = 0; sizeId < 4; sizeId++) {
+      for (let matrixId = 0; matrixId < 6; matrixId += sizeId === 3 ? 3 : 1) {
+        if (bs.readBits(1) === 0) {
+          readExpGolomb(bs);
+          continue;
+        }
+        if (sizeId > 1) {
+          readSignedExpGolomb(bs);
+        }
+        const coefNum = Math.min(64, 1 << 4 + (sizeId << 1));
+        for (let i = 0; i < coefNum; i++) {
+          readSignedExpGolomb(bs);
+        }
+      }
+    }
+  };
   var H265_BLA_W_LP = 16;
   var H265_IDR_W_RADL = 19;
   var H265_IDR_N_LP = 20;
@@ -62186,7 +62206,7 @@ ${baseUrl}${p.getFileName()}`;
         readExpGolomb(bs);
         if (bs.readBits(1) === 1) {
           if (bs.readBits(1) === 1) {
-            throw new UnsupportedMediaError("SPS scaling list data not supported");
+            skipScalingListData2(bs);
           }
         }
         bs.skipBits(1);
@@ -62282,7 +62302,7 @@ ${baseUrl}${p.getFileName()}`;
           }
         }
         if (bs.readBits(1) === 1) {
-          throw new UnsupportedMediaError("PPS scaling list data not supported");
+          skipScalingListData2(bs);
         }
         const listsModificationPresentFlag = bs.readBits(1) === 1;
         readExpGolomb(bs);
@@ -65249,6 +65269,220 @@ ${baseUrl}${p.getFileName()}`;
     return out;
   };
 
+  // src/smooth-streaming.ts
+  var UUID_TYPE = [117, 117, 105, 100];
+  var TFXD_UUID = [
+    109,
+    29,
+    155,
+    5,
+    66,
+    213,
+    68,
+    230,
+    128,
+    226,
+    20,
+    29,
+    175,
+    247,
+    87,
+    178
+  ];
+  var TFRF_UUID = [
+    212,
+    128,
+    126,
+    242,
+    202,
+    57,
+    70,
+    149,
+    142,
+    84,
+    38,
+    203,
+    158,
+    70,
+    167,
+    159
+  ];
+  var uuidBox = (uuid, body) => Uint8Array.from([...u32Bytes(8 + uuid.length + body.length), ...UUID_TYPE, ...uuid, ...body]);
+  var checkTime = (label, value) => {
+    if (!Number.isSafeInteger(value) || value < 0) {
+      throw new TypeError(`${label} must be a non-negative integer below 2^53.`);
+    }
+  };
+  var buildTfxdBox = (timing) => {
+    checkTime("time", timing.time);
+    checkTime("duration", timing.duration);
+    return uuidBox(TFXD_UUID, [1, 0, 0, 0, ...u64Bytes(timing.time), ...u64Bytes(timing.duration)]);
+  };
+  var buildTfrfBox = (fragments, options = {}) => {
+    if (fragments.length === 0) {
+      throw new InvalidUsageError("A tfrf box must announce at least one fragment.");
+    }
+    const countBytes = options.fragmentCountBytes ?? 1;
+    if (countBytes !== 1 && countBytes !== 4) {
+      throw new InvalidUsageError("fragmentCountBytes must be 1 or 4.");
+    }
+    if (countBytes === 1 && fragments.length > 255) {
+      throw new InvalidUsageError("A one-byte fragment count cannot state more than 255 fragments.");
+    }
+    const body = [1, 0, 0, 0, ...countBytes === 1 ? [fragments.length] : u32Bytes(fragments.length)];
+    for (const fragment of fragments) {
+      checkTime("time", fragment.time);
+      checkTime("duration", fragment.duration);
+      body.push(...u64Bytes(fragment.time), ...u64Bytes(fragment.duration));
+    }
+    return uuidBox(TFRF_UUID, body);
+  };
+  var u32At = (data, offset) => (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
+  var setU32At = (data, offset, value) => {
+    data[offset] = value >>> 24 & 255;
+    data[offset + 1] = value >>> 16 & 255;
+    data[offset + 2] = value >>> 8 & 255;
+    data[offset + 3] = value & 255;
+  };
+  var boxFlags2 = (data) => data[1] << 16 | data[2] << 8 | data[3];
+  var TFHD_BASE_DATA_OFFSET_PRESENT = 1;
+  var TFHD_DEFAULT_BASE_IS_MOOF = 131072;
+  var TRUN_DATA_OFFSET_PRESENT2 = 1;
+  var TRUN_DATA_OFFSET_POSITION2 = 8;
+  var childrenOf = (box2) => box2.children ?? [];
+  var trafsOf = (moof2) => childrenOf(moof2).filter((box2) => box2.type === "traf");
+  var trackIdOf2 = (traf2) => {
+    const tfhd2 = childrenOf(traf2).find((box2) => box2.type === "tfhd");
+    return tfhd2?.data === void 0 ? null : u32At(tfhd2.data, 4);
+  };
+  var offsetsFollowMoof = (traf2, indexInMoof) => {
+    const tfhd2 = childrenOf(traf2).find((box2) => box2.type === "tfhd");
+    if (tfhd2?.data === void 0) {
+      return indexInMoof === 0;
+    }
+    const flags = boxFlags2(tfhd2.data);
+    if (flags & TFHD_BASE_DATA_OFFSET_PRESENT) {
+      return false;
+    }
+    return (flags & TFHD_DEFAULT_BASE_IS_MOOF) !== 0 || indexInMoof === 0;
+  };
+  var shiftSaioOffsets = (traf2, added) => {
+    for (const saio2 of childrenOf(traf2).filter((box2) => box2.type === "saio")) {
+      const data = saio2.data;
+      if (data === void 0) {
+        continue;
+      }
+      const version = data[0];
+      let position = 4 + (boxFlags2(data) & 1 ? 8 : 0);
+      const entryCount = u32At(data, position);
+      position += 4;
+      const view2 = new DataView(data.buffer, data.byteOffset, data.byteLength);
+      for (let i = 0; i < entryCount; i++) {
+        if (version === 0) {
+          setU32At(data, position, u32At(data, position) + added);
+          position += 4;
+        } else {
+          view2.setBigUint64(position, view2.getBigUint64(position) + BigInt(added));
+          position += 8;
+        }
+      }
+    }
+  };
+  var growSidxReferencedSize = (sidx2, fragmentIndex, added) => {
+    const data = sidx2.data;
+    if (data === void 0) {
+      return;
+    }
+    const version = data[0];
+    const position = 4 + 4 + 4 + (version === 0 ? 8 : 16) + 2;
+    const referenceCount = data[position] << 8 | data[position + 1];
+    if (fragmentIndex >= referenceCount) {
+      return;
+    }
+    const at = position + 2 + fragmentIndex * 12;
+    const word = u32At(data, at);
+    setU32At(data, at, word & 2147483648 | (word & 2147483647) + added & 2147483647);
+  };
+  var insertBoxesIntoTraf = (segment, trackId, boxes) => {
+    if (boxes.length === 0) {
+      return segment;
+    }
+    const inserted = boxes.map((bytes2) => {
+      const boxList = parseBoxes(bytes2, 0, bytes2.length);
+      if (boxList.length !== 1) {
+        throw new InvalidUsageError("Each entry must be exactly one complete top-level box.");
+      }
+      return boxList[0];
+    });
+    const added = inserted.reduce((total, box2) => total + measureBox(box2), 0);
+    const parsed = parseBoxes(segment, 0, segment.length);
+    const sidxFirstFragment = /* @__PURE__ */ new Map();
+    let fragmentIndex = -1;
+    let target = null;
+    for (const box2 of parsed) {
+      if (box2.type === "sidx") {
+        sidxFirstFragment.set(box2, fragmentIndex + 1);
+        continue;
+      }
+      if (box2.type !== "moof") {
+        continue;
+      }
+      fragmentIndex++;
+      if (target !== null) {
+        continue;
+      }
+      const traf3 = trafsOf(box2).find((candidate) => trackIdOf2(candidate) === trackId);
+      if (traf3 !== void 0) {
+        target = { moof: box2, traf: traf3 };
+      }
+    }
+    if (target === null) {
+      throw new MalformedInputError(`The segment has no traf for track ${trackId}.`);
+    }
+    const targetFragment = parsed.filter((box2) => box2.type === "moof").indexOf(target.moof);
+    const { moof: moof2, traf: traf2 } = target;
+    const children = childrenOf(traf2);
+    const lastTrun = children.map((box2) => box2.type).lastIndexOf("trun");
+    if (lastTrun === -1) {
+      throw new MalformedInputError(`The traf for track ${trackId} has no trun to insert after.`);
+    }
+    traf2.children = [...children.slice(0, lastTrun + 1), ...inserted, ...children.slice(lastTrun + 1)];
+    const trafs = trafsOf(moof2);
+    const targetIndex = trafs.indexOf(traf2);
+    for (const [index, other] of trafs.entries()) {
+      if (!offsetsFollowMoof(other, index)) {
+        continue;
+      }
+      for (const trun2 of childrenOf(other).filter((box2) => box2.type === "trun")) {
+        if (trun2.data !== void 0 && boxFlags2(trun2.data) & TRUN_DATA_OFFSET_PRESENT2) {
+          setU32At(
+            trun2.data,
+            TRUN_DATA_OFFSET_POSITION2,
+            u32At(trun2.data, TRUN_DATA_OFFSET_POSITION2) + added
+          );
+        }
+      }
+      if (index >= targetIndex) {
+        shiftSaioOffsets(other, added);
+      }
+    }
+    for (const [sidx2, firstFragment] of sidxFirstFragment) {
+      if (targetFragment >= firstFragment) {
+        growSidxReferencedSize(sidx2, targetFragment - firstFragment, added);
+      }
+    }
+    const out = serializeBoxes(parsed);
+    let moofStart = 0;
+    for (const box2 of parsed) {
+      if (box2 === moof2) {
+        break;
+      }
+      moofStart += measureBox(box2);
+    }
+    shiftBaseDataOffsets(out.subarray(moofStart), added);
+    return out;
+  };
+
   // src/mpeg-ts/scte35.ts
   var SYNC_BYTE = 71;
   var SPLICE_INFO_TABLE_ID = 252;