mediabunny 1.56.0 → 1.56.2

package/dist/bundles/mediabunny.cjs

@@ -273,6 +273,13 @@ var Mediabunny = (() => {
     const result = (1 << leadingZeroBits) - 1 + bitstream.readBits(leadingZeroBits);
     return result;
   };
+  var writeExpGolomb = (bitstream, value) => {
+    const codeNum = value + 1;
+    const leadingZeroBits = Math.floor(Math.log2(codeNum));
+    bitstream.writeBits(leadingZeroBits, 0);
+    bitstream.writeBits(1, 1);
+    bitstream.writeBits(leadingZeroBits, codeNum - 2 ** leadingZeroBits);
+  };
   var readSignedExpGolomb = (bitstream) => {
     const codeNum = readExpGolomb(bitstream);
     return (codeNum & 1) === 0 ? -(codeNum >> 1) : codeNum + 1 >> 1;
@@ -1299,9 +1306,9 @@ var Mediabunny = (() => {
         throw new TypeError("tags.raw, when provided, must be an object.");
       }
       for (const value of Object.values(tags.raw)) {
-        if (value !== null && typeof value !== "string" && !(value instanceof Uint8Array) && !(value instanceof RichImageData) && !(value instanceof AttachedFile) && !isRecordStringString(value)) {
+        if (value !== null && typeof value !== "string" && !(Array.isArray(value) && value.every((x) => typeof x === "string")) && !(value instanceof Uint8Array) && !(value instanceof RichImageData) && !(value instanceof AttachedFile) && !isRecordStringString(value)) {
           throw new TypeError(
-            "Each value in tags.raw must be a string, Uint8Array, RichImageData, AttachedFile, Record<string, string>, or null."
+            "Each value in tags.raw must be a string, string array, Uint8Array, RichImageData, AttachedFile, Record<string, string>, or null."
           );
         }
       }
@@ -1387,6 +1394,16 @@ var Mediabunny = (() => {
       }
       this.pos = end;
     }
+    copyBits(n, other) {
+      let i = 0;
+      for (i; i < n - 7; i += 8) {
+        this.writeBits(8, other.readBits(8));
+      }
+      const leftover = n - i;
+      if (leftover > 0) {
+        this.writeBits(leftover, other.readBits(leftover));
+      }
+    }
     readAlignedByte() {
       if (this.pos % 8 !== 0) {
         throw new Error("Bitstream is not byte-aligned.");
@@ -1663,6 +1680,19 @@ var Mediabunny = (() => {
     }
     return new Uint8Array(result);
   };
+  var addEmulationPreventionBytes = (data) => {
+    const result = [];
+    let zeroCount = 0;
+    for (const byte of data) {
+      if (zeroCount === 2 && byte <= 3) {
+        result.push(3);
+        zeroCount = 0;
+      }
+      result.push(byte);
+      zeroCount = byte === 0 ? zeroCount + 1 : 0;
+    }
+    return new Uint8Array(result);
+  };
   var ANNEX_B_START_CODE = new Uint8Array([0, 0, 0, 1]);
   var concatNalUnitsInAnnexB = (nalUnits) => {
     const totalLength = nalUnits.reduce((a, b) => a + ANNEX_B_START_CODE.byteLength + b.byteLength, 0);
@@ -1782,8 +1812,7 @@ var Mediabunny = (() => {
         bytes2.push(pps[i]);
       }
     }
-    if (record.avcProfileIndication === 100 || record.avcProfileIndication === 110 || record.avcProfileIndication === 122 || record.avcProfileIndication === 144) {
-      assert(record.chromaFormat !== null);
+    if ((record.avcProfileIndication === 100 || record.avcProfileIndication === 110 || record.avcProfileIndication === 122 || record.avcProfileIndication === 144) && record.chromaFormat !== null) {
       assert(record.bitDepthLumaMinus8 !== null);
       assert(record.bitDepthChromaMinus8 !== null);
       assert(record.sequenceParameterSetExt !== null);
@@ -1883,7 +1912,8 @@ var Mediabunny = (() => {
   };
   var parseAvcSps = (sps) => {
     try {
-      const bitstream = new Bitstream(removeEmulationPreventionBytes(sps));
+      const emulationUnpreventedBytes = removeEmulationPreventionBytes(sps);
+      const bitstream = new Bitstream(emulationUnpreventedBytes);
       bitstream.skipBits(1);
       bitstream.skipBits(2);
       const nalUnitType = bitstream.readBits(5);
@@ -1979,6 +2009,9 @@ var Mediabunny = (() => {
       let pixelAspectRatio = { num: 1, den: 1 };
       let numReorderFrames = null;
       let maxDecFrameBuffering = null;
+      let bitstreamRestrictionFlagBitOffset = null;
+      let bitstreamRestrictionFlag = null;
+      const vuiParametersFlagBitOffset = bitstream.pos;
       const vuiParametersPresentFlag = bitstream.readBits(1);
       if (vuiParametersPresentFlag) {
         const aspectRatioInfoPresentFlag = bitstream.readBits(1);
@@ -2034,7 +2067,8 @@ var Mediabunny = (() => {
           bitstream.skipBits(1);
         }
         bitstream.skipBits(1);
-        const bitstreamRestrictionFlag = bitstream.readBits(1);
+        bitstreamRestrictionFlagBitOffset = bitstream.pos;
+        bitstreamRestrictionFlag = bitstream.readBits(1);
         if (bitstreamRestrictionFlag) {
           bitstream.skipBits(1);
           readExpGolomb(bitstream);
@@ -2068,6 +2102,7 @@ var Mediabunny = (() => {
       }
       assert(maxDecFrameBuffering !== null);
       return {
+        emulationUnpreventedBytes,
         profileIdc,
         constraintFlags,
         levelIdc,
@@ -2085,7 +2120,10 @@ var Mediabunny = (() => {
         transferCharacteristics,
         fullRangeFlag,
         numReorderFrames,
-        maxDecFrameBuffering
+        maxDecFrameBuffering,
+        vuiParametersFlagBitOffset,
+        bitstreamRestrictionFlagBitOffset,
+        bitstreamRestrictionFlag
       };
     } catch (error) {
       Logging._error("Error parsing AVC SPS:", error);
@@ -2106,6 +2144,40 @@ var Mediabunny = (() => {
     bitstream.skipBits(5);
     bitstream.skipBits(5);
   };
+  var addAvcBitstreamRestriction = (sps) => {
+    assert(sps.bitstreamRestrictionFlag !== 1);
+    const modifiedBytes = new Uint8Array(sps.emulationUnpreventedBytes.byteLength + 64);
+    const oldBitstream = new Bitstream(sps.emulationUnpreventedBytes);
+    const newBitstream = new Bitstream(modifiedBytes);
+    if (sps.bitstreamRestrictionFlag === null) {
+      newBitstream.copyBits(sps.vuiParametersFlagBitOffset, oldBitstream);
+      newBitstream.writeBits(1, 1);
+      newBitstream.writeBits(1, 0);
+      newBitstream.writeBits(1, 0);
+      newBitstream.writeBits(1, 0);
+      newBitstream.writeBits(1, 0);
+      newBitstream.writeBits(1, 0);
+      newBitstream.writeBits(1, 0);
+      newBitstream.writeBits(1, 0);
+      newBitstream.writeBits(1, 0);
+    } else {
+      assert(sps.bitstreamRestrictionFlagBitOffset !== null);
+      newBitstream.copyBits(sps.bitstreamRestrictionFlagBitOffset, oldBitstream);
+    }
+    newBitstream.writeBits(1, 1);
+    newBitstream.writeBits(1, 1);
+    writeExpGolomb(newBitstream, 2);
+    writeExpGolomb(newBitstream, 1);
+    writeExpGolomb(newBitstream, 16);
+    writeExpGolomb(newBitstream, 16);
+    writeExpGolomb(newBitstream, sps.numReorderFrames);
+    writeExpGolomb(newBitstream, sps.maxDecFrameBuffering);
+    newBitstream.writeBits(1, 1);
+    newBitstream.writeBits((8 - newBitstream.pos % 8) % 8, 0);
+    const byteLength = newBitstream.pos / 8;
+    assert(Number.isInteger(byteLength));
+    return addEmulationPreventionBytes(modifiedBytes.subarray(0, byteLength));
+  };
   var concatHevcNalUnits = (nalUnits, decoderConfig) => {
     if (decoderConfig.description) {
       const bytes2 = toUint8Array(decoderConfig.description);
@@ -3422,7 +3494,13 @@ var Mediabunny = (() => {
       const key = string.slice(0, separatorIndex).toUpperCase();
       const value = string.slice(separatorIndex + 1);
       metadataTags.raw ??= {};
-      metadataTags.raw[key] ??= value;
+      if (Array.isArray(metadataTags.raw[key])) {
+        metadataTags.raw[key] = [...metadataTags.raw[key], value];
+      } else if (typeof metadataTags.raw[key] === "string") {
+        metadataTags.raw[key] = [metadataTags.raw[key], value];
+      } else {
+        metadataTags.raw[key] ??= value;
+      }
       switch (key) {
         case "TITLE":
           {
@@ -3569,7 +3647,7 @@ var Mediabunny = (() => {
     currentView.setUint32(0, encodedVendorString.length, true);
     currentBuffer.set(encodedVendorString, 4);
     commentHeaderParts.push(currentBuffer);
-    const writtenTags = /* @__PURE__ */ new Set();
+    const writtenTags = [];
     const addCommentTag = (key, value) => {
       const joined = `${key}=${value}`;
       const encoded = textEncoder.encode(joined);
@@ -3578,7 +3656,7 @@ var Mediabunny = (() => {
       currentView.setUint32(0, encoded.length, true);
       currentBuffer.set(encoded, 4);
       commentHeaderParts.push(currentBuffer);
-      writtenTags.add(key);
+      writtenTags.push(key);
     };
     for (const { key, value } of keyValueIterator(tags)) {
       switch (key) {
@@ -3620,12 +3698,7 @@ var Mediabunny = (() => {
           break;
         case "date":
           {
-            const rawVersion = tags.raw?.["DATE"] ?? tags.raw?.["date"];
-            if (rawVersion && typeof rawVersion === "string") {
-              addCommentTag("DATE", rawVersion);
-            } else {
-              addCommentTag("DATE", value.toISOString().slice(0, 10));
-            }
+            addCommentTag("DATE", value.toISOString().slice(0, 10));
           }
           ;
           break;
@@ -3714,16 +3787,23 @@ var Mediabunny = (() => {
     if (tags.raw) {
       for (const key in tags.raw) {
         const value = tags.raw[key] ?? tags.raw[key.toLowerCase()];
-        if (key === "vendor" || value == null || writtenTags.has(key)) {
+        if (key === "vendor" || value == null || writtenTags.includes(key)) {
           continue;
         }
         if (typeof value === "string") {
           addCommentTag(key, value);
+        } else if (Array.isArray(value)) {
+          const isOnlyStrings = value.every((x) => typeof x === "string");
+          if (isOnlyStrings) {
+            for (const elem of value) {
+              addCommentTag(key, elem);
+            }
+          }
         }
       }
     }
     const listLengthBuffer = new Uint8Array(4);
-    toDataView(listLengthBuffer).setUint32(0, writtenTags.size, true);
+    toDataView(listLengthBuffer).setUint32(0, writtenTags.length, true);
     commentHeaderParts.splice(2, 0, listLengthBuffer);
     const commentHeaderLength = commentHeaderParts.reduce((a, b) => a + b.length, 0);
     const commentHeader = new Uint8Array(commentHeaderLength);
@@ -24070,11 +24150,20 @@ var Mediabunny = (() => {
             );
             if (record && record.sequenceParameterSets.length > 0) {
               const sps = parseAvcSps(record.sequenceParameterSets[0]);
-              if (sps && sps.frameMbsOnlyFlag === 0) {
-                this.decoderConfig = {
-                  ...this.decoderConfig,
-                  hardwareAcceleration: "prefer-software"
-                };
+              if (sps) {
+                if (sps.frameMbsOnlyFlag === 0) {
+                  this.decoderConfig = {
+                    ...this.decoderConfig,
+                    hardwareAcceleration: "prefer-software"
+                  };
+                }
+                if (sps.maxDecFrameBuffering !== 0 && sps.bitstreamRestrictionFlag !== 1) {
+                  record.sequenceParameterSets[0] = addAvcBitstreamRestriction(sps);
+                  this.decoderConfig = {
+                    ...this.decoderConfig,
+                    description: serializeAvcDecoderConfigurationRecord(record)
+                  };
+                }
               }
             }
           }
@@ -24151,6 +24240,19 @@ var Mediabunny = (() => {
                 filteredNalUnits.push(packet.data.subarray(loc.offset, loc.offset + loc.length));
               }
             }
+            if (!this.decoderConfig.description) {
+              for (let i = 0; i < filteredNalUnits.length; i++) {
+                const nalUnit = filteredNalUnits[i];
+                if (extractNalUnitTypeForAvc(nalUnit[0]) !== 7 /* SPS */) {
+                  continue;
+                }
+                const sps = parseAvcSps(nalUnit);
+                if (sps && sps.maxDecFrameBuffering !== 0 && sps.bitstreamRestrictionFlag !== 1) {
+                  filteredNalUnits[i] = addAvcBitstreamRestriction(sps);
+                }
+                break;
+              }
+            }
             const newData = concatAvcNalUnits(filteredNalUnits, this.decoderConfig);
             packet = new EncodedPacket(newData, packet.type, packet.timestamp, packet.duration);
           } else if (this.codec === "hevc") {
@@ -34450,11 +34552,11 @@ ${cue.notes ?? ""}`;
         };
       } else if (sourceNum === 2 && targetNum === 4) {
         this.channelMixer = (sourceData, sourceFrameIndex, targetChannelIndex) => {
-          return sourceData[sourceFrameIndex * sourceNum + targetChannelIndex] * +(targetChannelIndex < 2);
+          return targetChannelIndex < 2 ? sourceData[sourceFrameIndex * sourceNum + targetChannelIndex] : 0;
         };
       } else if (sourceNum === 2 && targetNum === 6) {
         this.channelMixer = (sourceData, sourceFrameIndex, targetChannelIndex) => {
-          return sourceData[sourceFrameIndex * sourceNum + targetChannelIndex] * +(targetChannelIndex < 2);
+          return targetChannelIndex < 2 ? sourceData[sourceFrameIndex * sourceNum + targetChannelIndex] : 0;
         };
       } else if (sourceNum === 4 && targetNum === 1) {
         this.channelMixer = (sourceData, sourceFrameIndex) => {
@@ -39642,7 +39744,7 @@ ${cue.notes ?? ""}`;
         }
         const inputAndOutputFormatMatch = inputFormat.mimeType === this.output.format.mimeType;
         const rawTagsAreUnchanged = inputTags.raw === outputTags.raw;
-        if (inputTags.raw && rawTagsAreUnchanged && !inputAndOutputFormatMatch) {
+        if (rawTagsAreUnchanged && !inputAndOutputFormatMatch) {
           delete outputTags.raw;
         }
         this.output.setMetadataTags(outputTags);