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

package/dist/bundles/mediabunny.cjs

@@ -58413,6 +58413,57 @@ ${baseUrl}${p.getFileName()}`;
     enca: 28
   };
   var readU323 = (bytes2, offset) => (bytes2[offset] << 24 | bytes2[offset + 1] << 16 | bytes2[offset + 2] << 8 | bytes2[offset + 3]) >>> 0;
+  var writeU32 = (bytes2, offset, value) => {
+    bytes2[offset] = value >>> 24 & 255;
+    bytes2[offset + 1] = value >>> 16 & 255;
+    bytes2[offset + 2] = value >>> 8 & 255;
+    bytes2[offset + 3] = value & 255;
+  };
+  var u32Bytes = (value) => [
+    value >>> 24 & 255,
+    value >>> 16 & 255,
+    value >>> 8 & 255,
+    value & 255
+  ];
+  var u64Bytes = (value) => {
+    const big = BigInt(value);
+    return Array.from({ length: 8 }, (_, i) => Number(big >> BigInt(56 - i * 8) & 0xffn));
+  };
+  var boxFlags = (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_POSITION = 4 + 4;
+  var TRUN_DATA_OFFSET_PRESENT = 1;
+  var trafsOf = (moof2) => (moof2.children ?? []).filter((box2) => box2.type === "traf");
+  var trunsOf = (traf2) => (traf2.children ?? []).filter((box2) => box2.type === "trun");
+  var tfhdOf = (traf2) => (traf2.children ?? []).find((box2) => box2.type === "tfhd");
+  var offsetsFollowMoof = (traf2, indexInMoof) => {
+    const tfhd2 = tfhdOf(traf2);
+    if (tfhd2?.data === void 0) {
+      return indexInMoof === 0;
+    }
+    const flags = boxFlags(tfhd2.data);
+    if (flags & TFHD_BASE_DATA_OFFSET_PRESENT) {
+      return false;
+    }
+    return (flags & TFHD_DEFAULT_BASE_IS_MOOF) !== 0 || indexInMoof === 0;
+  };
+  var shiftTrunDataOffsets = (moof2, delta) => {
+    for (const [index, traf2] of trafsOf(moof2).entries()) {
+      if (!offsetsFollowMoof(traf2, index)) {
+        continue;
+      }
+      for (const trun2 of trunsOf(traf2)) {
+        if (trun2.data !== void 0 && boxFlags(trun2.data) & TRUN_DATA_OFFSET_PRESENT) {
+          writeU32(
+            trun2.data,
+            TRUN_DATA_OFFSET_POSITION,
+            readU323(trun2.data, TRUN_DATA_OFFSET_POSITION) + delta
+          );
+        }
+      }
+    }
+  };
   var boxType = (bytes2, offset) => String.fromCharCode(bytes2[offset], bytes2[offset + 1], bytes2[offset + 2], bytes2[offset + 3]);
   var parseBoxes = (bytes2, start, end) => {
     const boxes = [];
@@ -58491,6 +58542,13 @@ ${baseUrl}${p.getFileName()}`;
     }
     return out;
   };
+  var parseSingleBoxes = (boxes) => 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];
+  });
   var findBox = (boxes, type) => {
     for (const box2 of boxes) {
       if (box2.type === type) {
@@ -62709,10 +62767,9 @@ ${baseUrl}${p.getFileName()}`;
   var toMutable = (box2) => parseBoxes(forkBoxToBytes(box2), 0, measureForkBox(box2))[0];
   var u324 = (data, offset) => new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(offset);
   var setU32 = (data, offset, value) => new DataView(data.buffer, data.byteOffset, data.byteLength).setUint32(offset, value);
-  var boxFlags = (data) => data[1] << 16 | data[2] << 8 | data[3];
   var SENC_ENTRIES_OFFSET = 8 + 4 + 4;
-  var TRUN_DATA_OFFSET_PRESENT = 1;
-  var TRUN_DATA_OFFSET_POSITION = 4 + 4;
+  var TRUN_DATA_OFFSET_PRESENT2 = 1;
+  var TRUN_DATA_OFFSET_POSITION2 = 4 + 4;
   var parseTrun = (data, defaultSampleSize, defaultSampleDuration) => {
     const flags = boxFlags(data);
     const sampleCount = u324(data, 4);
@@ -63234,7 +63291,7 @@ ${baseUrl}${p.getFileName()}`;
     }
     return flags & 16 ? u324(tfhd2.data, offset) : 0;
   };
-  var trunsOf = (traf2) => (traf2.children ?? []).filter((box2) => box2.type === "trun");
+  var trunsOf2 = (traf2) => (traf2.children ?? []).filter((box2) => box2.type === "trun");
   var baseDataOffsetOf = (tfhd2, moofOffset) => {
     const data = tfhd2.data;
     if (!(boxFlags(data) & 1)) {
@@ -63281,7 +63338,7 @@ ${baseUrl}${p.getFileName()}`;
       const periodPerSample = [];
       let decodeTime = rotation === void 0 ? 0 : baseMediaDecodeTime2(traf2, track.trackId);
       let cursor = moofSizeBefore + 8 - (mdatDataStart - base);
-      for (const trun2 of trunsOf(traf2)) {
+      for (const trun2 of trunsOf2(traf2)) {
         const parsed = parseTrun(trun2.data, defaultSampleSize, track.defaultSampleDuration);
         if (parsed.dataOffsetPos >= 0) {
           cursor = base + u324(trun2.data, parsed.dataOffsetPos) - mdatDataStart;
@@ -63337,9 +63394,9 @@ ${baseUrl}${p.getFileName()}`;
     }
     const delta = measureBox(moof2) - moofSizeBefore;
     for (const traf2 of (moof2.children ?? []).filter((b) => b.type === "traf")) {
-      for (const trun2 of trunsOf(traf2)) {
-        if (boxFlags(trun2.data) & TRUN_DATA_OFFSET_PRESENT) {
-          setU32(trun2.data, TRUN_DATA_OFFSET_POSITION, u324(trun2.data, TRUN_DATA_OFFSET_POSITION) + delta);
+      for (const trun2 of trunsOf2(traf2)) {
+        if (boxFlags(trun2.data) & TRUN_DATA_OFFSET_PRESENT2) {
+          setU32(trun2.data, TRUN_DATA_OFFSET_POSITION2, u324(trun2.data, TRUN_DATA_OFFSET_POSITION2) + delta);
         }
       }
     }
@@ -63564,7 +63621,7 @@ ${baseUrl}${p.getFileName()}`;
         const base = baseDataOffsetOf(tfhd2, moofOffset);
         const defaultSampleSize = defaultSampleSizeOf(tfhd2);
         let cursor = measureBox(moof2) + 8 - (mdatDataStart - base);
-        for (const trun2 of trunsOf(traf2)) {
+        for (const trun2 of trunsOf2(traf2)) {
           const parsed = parseTrun(trun2.data, defaultSampleSize, 0);
           if (parsed.dataOffsetPos >= 0) {
             cursor = base + u324(trun2.data, parsed.dataOffsetPos) - mdatDataStart;
@@ -65105,16 +65162,6 @@ ${baseUrl}${p.getFileName()}`;
 
   // src/emsg.ts
   var nullTerminated = (text) => [...textEncoder.encode(text), 0];
-  var u32Bytes = (value) => [
-    value >>> 24 & 255,
-    value >>> 16 & 255,
-    value >>> 8 & 255,
-    value & 255
-  ];
-  var u64Bytes = (value) => {
-    const big = BigInt(value);
-    return Array.from({ length: 8 }, (_, i) => Number(big >> BigInt(56 - i * 8) & 0xffn));
-  };
   var parseEmsgBody = (body) => {
     if (body.length < 4) {
       throw new MalformedInputError("emsg box is too short to hold its version and flags.");
@@ -65337,49 +65384,20 @@ ${baseUrl}${p.getFileName()}`;
     }
     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")) {
+    for (const saio2 of (traf2.children ?? []).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);
+      let position = 4 + (boxFlags(data) & 1 ? 8 : 0);
+      const entryCount = readU323(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);
+          writeU32(data, position, readU323(data, position) + added);
           position += 4;
         } else {
           view2.setBigUint64(position, view2.getBigUint64(position) + BigInt(added));
@@ -65400,86 +65418,63 @@ ${baseUrl}${p.getFileName()}`;
       return;
     }
     const at = position + 2 + fragmentIndex * 12;
-    const word = u32At(data, at);
-    setU32At(data, at, word & 2147483648 | (word & 2147483647) + added & 2147483647);
+    const word = readU323(data, at);
+    const grown = (word & 2147483647) + added;
+    if (grown > 2147483647) {
+      throw new InvalidUsageError("The grown fragment no longer fits a sidx referenced_size.");
+    }
+    writeU32(data, at, word & 2147483648 | grown);
   };
   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 inserted = parseSingleBoxes(boxes);
     const added = inserted.reduce((total, box2) => total + measureBox(box2), 0);
     const parsed = parseBoxes(segment, 0, segment.length);
-    const sidxFirstFragment = /* @__PURE__ */ new Map();
+    const sidxes = [];
     let fragmentIndex = -1;
+    let start = 0;
     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 };
+        sidxes.push({ sidx: box2, firstFragment: fragmentIndex + 1 });
+      } else if (box2.type === "moof") {
+        fragmentIndex++;
+        const traf3 = trafsOf(box2).find((candidate) => {
+          const tfhd2 = tfhdOf(candidate);
+          return tfhd2?.data !== void 0 && readU323(tfhd2.data, 4) === trackId;
+        });
+        if (traf3 !== void 0 && target === null) {
+          target = { moof: box2, traf: traf3, fragment: fragmentIndex, start };
+        }
       }
+      start += measureBox(box2);
     }
     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 children = traf2.children ?? [];
     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)];
+    shiftTrunDataOffsets(moof2, added);
     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 (let index = trafs.indexOf(traf2); index < trafs.length; index++) {
+      if (offsetsFollowMoof(trafs[index], index)) {
+        shiftSaioOffsets(trafs[index], added);
       }
     }
-    for (const [sidx2, firstFragment] of sidxFirstFragment) {
-      if (targetFragment >= firstFragment) {
-        growSidxReferencedSize(sidx2, targetFragment - firstFragment, added);
+    for (const { sidx: sidx2, firstFragment } of sidxes) {
+      if (target.fragment >= firstFragment) {
+        growSidxReferencedSize(sidx2, target.fragment - 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);
+    shiftBaseDataOffsets(out.subarray(target.start), added);
     return out;
   };