mediabunny 1.24.4 → 1.24.6

package/dist/bundles/mediabunny.cjs

@@ -624,13 +624,13 @@ var Mediabunny = (() => {
       return this.currentPromise = this.currentPromise.then(fn);
     }
   };
-  var isSafariCache = null;
-  var isSafari = () => {
-    if (isSafariCache !== null) {
-      return isSafariCache;
+  var isWebKitCache = null;
+  var isWebKit = () => {
+    if (isWebKitCache !== null) {
+      return isWebKitCache;
     }
-    const result = !!(typeof navigator !== "undefined" && navigator.vendor?.match(/apple/i) && !navigator.userAgent?.match(/crios/i) && !navigator.userAgent?.match(/fxios/i) && !navigator.userAgent?.match(/Opera|OPT\//));
-    isSafariCache = result;
+    const result = !!(typeof navigator !== "undefined" && navigator.vendor?.match(/apple/i));
+    isWebKitCache = result;
     return result;
   };
   var isFirefoxCache = null;
@@ -1123,18 +1123,19 @@ var Mediabunny = (() => {
   var extractVideoCodecString = (trackInfo) => {
     const { codec, codecDescription, colorSpace, avcCodecInfo, hevcCodecInfo, vp9CodecInfo, av1CodecInfo } = trackInfo;
     if (codec === "avc") {
+      assert(trackInfo.avcType !== null);
       if (avcCodecInfo) {
         const bytes2 = new Uint8Array([
           avcCodecInfo.avcProfileIndication,
           avcCodecInfo.profileCompatibility,
           avcCodecInfo.avcLevelIndication
         ]);
-        return `avc1.${bytesToHexString(bytes2)}`;
+        return `avc${trackInfo.avcType}.${bytesToHexString(bytes2)}`;
       }
       if (!codecDescription || codecDescription.byteLength < 4) {
         throw new TypeError("AVC decoder description is not provided or is not at least 4 bytes long.");
       }
-      return `avc1.${bytesToHexString(codecDescription.subarray(1, 4))}`;
+      return `avc${trackInfo.avcType}.${bytesToHexString(codecDescription.subarray(1, 4))}`;
     } else if (codec === "hevc") {
       let generalProfileSpace;
       let generalProfileIdc;
@@ -1337,6 +1338,40 @@ var Mediabunny = (() => {
       numberOfChannels
     };
   };
+  var buildAacAudioSpecificConfig = (config) => {
+    let frequencyIndex = aacFrequencyTable.indexOf(config.sampleRate);
+    let customSampleRate = null;
+    if (frequencyIndex === -1) {
+      frequencyIndex = 15;
+      customSampleRate = config.sampleRate;
+    }
+    const channelConfiguration = aacChannelMap.indexOf(config.numberOfChannels);
+    if (channelConfiguration === -1) {
+      throw new TypeError(`Unsupported number of channels: ${config.numberOfChannels}`);
+    }
+    let bitCount = 5 + 4 + 4;
+    if (config.objectType >= 32) {
+      bitCount += 6;
+    }
+    if (frequencyIndex === 15) {
+      bitCount += 24;
+    }
+    const byteCount = Math.ceil(bitCount / 8);
+    const bytes2 = new Uint8Array(byteCount);
+    const bitstream = new Bitstream(bytes2);
+    if (config.objectType < 32) {
+      bitstream.writeBits(5, config.objectType);
+    } else {
+      bitstream.writeBits(5, 31);
+      bitstream.writeBits(6, config.objectType - 32);
+    }
+    bitstream.writeBits(4, frequencyIndex);
+    if (frequencyIndex === 15) {
+      bitstream.writeBits(24, customSampleRate);
+    }
+    bitstream.writeBits(4, channelConfiguration);
+    return bytes2;
+  };
   var OPUS_SAMPLE_RATE = 48e3;
   var PCM_CODEC_REGEX = /^pcm-([usf])(\d+)+(be)?$/;
   var parsePcmCodec = (codec) => {
@@ -3312,7 +3347,10 @@ var Mediabunny = (() => {
         this.sideData.alphaByteLength = this.sideData.alpha.byteLength;
       }
     }
-    /** If this packet is a metadata-only packet. Metadata-only packets don't contain their packet data. */
+    /**
+     * If this packet is a metadata-only packet. Metadata-only packets don't contain their packet data. They are the
+     * result of retrieving packets with {@link PacketRetrievalOptions.metadataOnly} set to `true`.
+     */
     get isMetadataOnly() {
       return this.data === PLACEHOLDER_DATA;
     }
@@ -3890,12 +3928,14 @@ var Mediabunny = (() => {
         dx = (canvasWidth - newWidth) / 2;
         dy = (canvasHeight - newHeight) / 2;
       }
+      context.save();
       const aspectRatioChange = rotation % 180 === 0 ? 1 : newWidth / newHeight;
       context.translate(canvasWidth / 2, canvasHeight / 2);
       context.rotate(rotation * Math.PI / 180);
       context.scale(1 / aspectRatioChange, aspectRatioChange);
       context.translate(-canvasWidth / 2, -canvasHeight / 2);
       context.drawImage(this.toCanvasImageSource(), sx, sy, sWidth, sHeight, dx, dy, newWidth, newHeight);
+      context.restore();
     }
     /** @internal */
     _rotateSourceRegion(sx, sy, sWidth, sHeight, rotation) {
@@ -5123,7 +5163,7 @@ var Mediabunny = (() => {
         void this.customDecoderCallSerializer.call(() => this.customDecoder.decode(packet)).then(() => this.customDecoderQueueSize--);
       } else {
         assert(this.decoder);
-        if (!isSafari()) {
+        if (!isWebKit()) {
           insertSorted(this.inputTimestamps, packet.timestamp, (x) => x);
         }
         this.decoder.decode(packet.toEncodedVideoChunk());
@@ -5220,7 +5260,7 @@ var Mediabunny = (() => {
     }
     /** Handler for the WebCodecs VideoDecoder for ironing out browser differences. */
     sampleHandler(sample) {
-      if (isSafari()) {
+      if (isWebKit()) {
         if (this.sampleQueue.length > 0 && sample.timestamp >= last(this.sampleQueue).timestamp) {
           for (const sample2 of this.sampleQueue) {
             this.finalizeAndEmitSample(sample2);
@@ -5278,7 +5318,7 @@ var Mediabunny = (() => {
         this.currentAlphaPacketIndex = 0;
         this.alphaRaslSkipped = false;
       }
-      if (isSafari()) {
+      if (isWebKit()) {
         for (const sample of this.sampleQueue) {
           this.finalizeAndEmitSample(sample);
         }
@@ -6841,6 +6881,7 @@ var Mediabunny = (() => {
                 codec: null,
                 codecDescription: null,
                 colorSpace: null,
+                avcType: null,
                 avcCodecInfo: null,
                 hevcCodecInfo: null,
                 vp9CodecInfo: null,
@@ -6891,8 +6932,9 @@ var Mediabunny = (() => {
               track.internalCodecId = sampleBoxInfo.name;
               const lowercaseBoxName = sampleBoxInfo.name.toLowerCase();
               if (track.info.type === "video") {
-                if (lowercaseBoxName === "avc1") {
+                if (lowercaseBoxName === "avc1" || lowercaseBoxName === "avc3") {
                   track.info.codec = "avc";
+                  track.info.avcType = lowercaseBoxName === "avc1" ? 1 : 3;
                 } else if (lowercaseBoxName === "hvc1" || lowercaseBoxName === "hev1") {
                   track.info.codec = "hevc";
                 } else if (lowercaseBoxName === "vp08") {
@@ -9645,10 +9687,10 @@ var Mediabunny = (() => {
         }
         assert(frameSizes.length === frameCount);
         blocks.splice(blockIndex, 1);
+        const blockDuration = originalBlock.duration || frameCount * (track.defaultDuration ?? 0);
         for (let i = 0; i < frameCount; i++) {
           const frameSize = frameSizes[i];
           const frameData = readBytes(slice, frameSize);
-          const blockDuration = originalBlock.duration || frameCount * (track.defaultDuration ?? 0);
           const frameTimestamp = originalBlock.timestamp + blockDuration * i / frameCount;
           const frameDuration = blockDuration / frameCount;
           blocks.splice(blockIndex + i, 0, {
@@ -10996,6 +11038,8 @@ var Mediabunny = (() => {
             codec: this.internalTrack.info.codec,
             codecDescription: this.internalTrack.info.codecDescription,
             colorSpace: this.internalTrack.info.colorSpace,
+            avcType: 1,
+            // We don't know better (or do we?) so just assume 'avc1'
             avcCodecInfo: this.internalTrack.info.codec === "avc" && firstPacket ? extractAvcDecoderConfigurationRecord(firstPacket.data) : null,
             hevcCodecInfo: this.internalTrack.info.codec === "hevc" && firstPacket ? extractHevcDecoderConfigurationRecord(firstPacket.data) : null,
             vp9CodecInfo: this.internalTrack.info.codec === "vp9" && firstPacket ? extractVp9CodecInfoFromPacket(firstPacket.data) : null,
@@ -14379,10 +14423,11 @@ var Mediabunny = (() => {
         }
         const nextByte = readU8(slice);
         if (nextByte === 255) {
+          const positionBeforeReading = slice.filePos;
           const byteAfterNextByte = readU8(slice);
           const expected = this.blockingBit === 1 ? 249 : 248;
           if (byteAfterNextByte !== expected) {
-            slice.skip(-1);
+            slice.filePos = positionBeforeReading;
             continue;
           }
           slice.skip(-2);
@@ -14392,17 +14437,17 @@ var Mediabunny = (() => {
             isFirstPacket: false
           });
           if (!nextFrameHeader) {
-            slice.skip(-1);
+            slice.filePos = positionBeforeReading;
             continue;
           }
           if (this.blockingBit === 0) {
             if (nextFrameHeader.num - frameHeader.num !== 1) {
-              slice.skip(-1);
+              slice.filePos = positionBeforeReading;
               continue;
             }
           } else {
             if (nextFrameHeader.num - frameHeader.num !== frameHeader.blockSize) {
-              slice.skip(-1);
+              slice.filePos = positionBeforeReading;
               continue;
             }
           }
@@ -15068,7 +15113,7 @@ var Mediabunny = (() => {
     async _runWorker(worker) {
       let reader = this._readers.get(worker);
       if (reader === void 0) {
-        if ("stream" in this._blob) {
+        if ("stream" in this._blob && !isWebKit()) {
           const slice = this._blob.slice(worker.currentPos);
           reader = slice.stream().getReader();
         } else {
@@ -17092,7 +17137,7 @@ var Mediabunny = (() => {
     let sampleDescription;
     if (trackData.type === "video") {
       sampleDescription = videoSampleDescription(
-        VIDEO_CODEC_TO_BOX_NAME[trackData.track.source._codec],
+        videoCodecToBoxName(trackData.track.source._codec, trackData.info.decoderConfig.codec),
         trackData
       );
     } else if (trackData.type === "audio") {
@@ -18048,12 +18093,19 @@ var Mediabunny = (() => {
       ...textEncoder.encode(value)
     ]);
   };
-  var VIDEO_CODEC_TO_BOX_NAME = {
-    avc: "avc1",
-    hevc: "hvc1",
-    vp8: "vp08",
-    vp9: "vp09",
-    av1: "av01"
+  var videoCodecToBoxName = (codec, fullCodecString) => {
+    switch (codec) {
+      case "avc":
+        return fullCodecString.startsWith("avc3") ? "avc3" : "avc1";
+      case "hevc":
+        return "hvc1";
+      case "vp8":
+        return "vp08";
+      case "vp9":
+        return "vp09";
+      case "av1":
+        return "av01";
+    }
   };
   var VIDEO_CODEC_TO_CONFIGURATION_BOX = {
     avc: avcC,
@@ -22972,6 +23024,7 @@ ${cue.notes ?? ""}`;
       this.customEncoder = null;
       this.customEncoderCallSerializer = new CallSerializer();
       this.customEncoderQueueSize = 0;
+      this.lastEndSampleIndex = null;
       /**
        * Encoders typically throw their errors "out of band", meaning asynchronously in some other execution context.
        * However, we want to surface these errors to the user within the normal control flow, so they don't go uncaught.
@@ -23003,6 +23056,27 @@ ${cue.notes ?? ""}`;
           }
         }
         assert(this.encoderInitialized);
+        {
+          const startSampleIndex = Math.round(
+            audioSample.timestamp * audioSample.sampleRate
+          );
+          const endSampleIndex = Math.round(
+            (audioSample.timestamp + audioSample.duration) * audioSample.sampleRate
+          );
+          if (this.lastEndSampleIndex !== null && startSampleIndex > this.lastEndSampleIndex) {
+            const sampleCount = startSampleIndex - this.lastEndSampleIndex;
+            const fillSample = new AudioSample({
+              data: new Float32Array(sampleCount * audioSample.numberOfChannels),
+              format: "f32-planar",
+              sampleRate: audioSample.sampleRate,
+              numberOfChannels: audioSample.numberOfChannels,
+              numberOfFrames: sampleCount,
+              timestamp: this.lastEndSampleIndex / audioSample.sampleRate
+            });
+            await this.add(fillSample, true);
+          }
+          this.lastEndSampleIndex = endSampleIndex;
+        }
         if (this.customEncoder) {
           this.customEncoderQueueSize++;
           const clonedSample = audioSample.clone();
@@ -23132,6 +23206,25 @@ ${cue.notes ?? ""}`;
           }
           this.encoder = new AudioEncoder({
             output: (chunk, meta) => {
+              if (this.encodingConfig.codec === "aac" && meta?.decoderConfig) {
+                let needsDescriptionOverwrite = false;
+                if (!meta.decoderConfig.description || meta.decoderConfig.description.byteLength < 2) {
+                  needsDescriptionOverwrite = true;
+                } else {
+                  const audioSpecificConfig = parseAacAudioSpecificConfig(
+                    toUint8Array(meta.decoderConfig.description)
+                  );
+                  needsDescriptionOverwrite = audioSpecificConfig.objectType === 0;
+                }
+                if (needsDescriptionOverwrite) {
+                  const objectType = Number(last(encoderConfig.codec.split(".")));
+                  meta.decoderConfig.description = buildAacAudioSpecificConfig({
+                    objectType,
+                    numberOfChannels: meta.decoderConfig.numberOfChannels,
+                    sampleRate: meta.decoderConfig.sampleRate
+                  });
+                }
+              }
               const packet = EncodedPacket.fromEncodedChunk(chunk);
               this.encodingConfig.onEncodedPacket?.(packet, meta);
               void this.muxer.addEncodedAudioPacket(this.source._connectedTrack, packet, meta).catch((error) => {
@@ -24330,7 +24423,7 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
       }
       const firstTimestamp = await track.getFirstTimestamp();
       const needsTranscode = !!trackOptions.forceTranscode || this._startTimestamp > 0 || firstTimestamp < 0 || !!trackOptions.frameRate || trackOptions.keyFrameInterval !== void 0 || trackOptions.process !== void 0;
-      let needsRerender = width !== originalWidth || height !== originalHeight || totalRotation !== 0 && !outputSupportsRotation || !!crop;
+      let needsRerender = width !== originalWidth || height !== originalHeight || totalRotation !== 0 && (!outputSupportsRotation || trackOptions.process !== void 0) || !!crop;
       const alpha = trackOptions.alpha ?? "discard";
       let videoCodecs = this.output.format.getSupportedVideoCodecs();
       if (!needsTranscode && !trackOptions.bitrate && !needsRerender && videoCodecs.includes(sourceCodec) && (!trackOptions.codec || trackOptions.codec === sourceCodec)) {