mediabunny 1.4.4 → 1.5.0

package/dist/bundles/mediabunny.cjs

@@ -5660,7 +5660,11 @@ var Mediabunny = (() => {
     readString(length) {
       const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + length);
       this.pos += length;
-      return String.fromCharCode(...new Uint8Array(view2.buffer, offset, length));
+      let strLength = 0;
+      while (strLength < length && view2.getUint8(offset + strLength) !== 0) {
+        strLength += 1;
+      }
+      return String.fromCharCode(...new Uint8Array(view2.buffer, offset, strLength));
     }
     readElementId() {
       const size = this.readVarIntSize();
@@ -5726,6 +5730,27 @@ var Mediabunny = (() => {
     "pcm-f64": "A_PCM/FLOAT/IEEE",
     "webvtt": "S_TEXT/WEBVTT"
   };
+  var readVarInt = (data, offset) => {
+    if (offset >= data.length) {
+      throw new Error("Offset out of bounds.");
+    }
+    const firstByte = data[offset];
+    let width = 1;
+    let mask = 1 << 7;
+    while ((firstByte & mask) === 0 && width < 8) {
+      width++;
+      mask >>= 1;
+    }
+    if (offset + width > data.length) {
+      throw new Error("VarInt extends beyond data bounds.");
+    }
+    let value = firstByte & mask - 1;
+    for (let i = 1; i < width; i++) {
+      value *= 1 << 8;
+      value += data[offset + i];
+    }
+    return { value, width };
+  };
   function assertDefinedSize(size) {
     if (size === null) {
       throw new Error("Undefined element size is used in a place where it is not supported.");
@@ -13636,7 +13661,6 @@ ${cue.notes ?? ""}`;
         throw new Error("Packet was not created from this track.");
       }
       const trackData = locationInFragment.fragment.trackData.get(this.internalTrack.id);
-      const fragmentSample = trackData.samples[locationInFragment.sampleIndex];
       const fragmentIndex = binarySearchExact(
         this.internalTrack.fragments,
         locationInFragment.fragment.moofOffset,
@@ -13677,7 +13701,8 @@ ${cue.notes ?? ""}`;
             };
           }
         },
-        fragmentSample.presentationTimestamp,
+        -Infinity,
+        // Use -Infinity as a search timestamp to avoid using the lookup entries
         Infinity,
         options
       );
@@ -13710,7 +13735,6 @@ ${cue.notes ?? ""}`;
         throw new Error("Packet was not created from this track.");
       }
       const trackData = locationInFragment.fragment.trackData.get(this.internalTrack.id);
-      const fragmentSample = trackData.samples[locationInFragment.sampleIndex];
       const fragmentIndex = binarySearchExact(
         this.internalTrack.fragments,
         locationInFragment.fragment.moofOffset,
@@ -13756,7 +13780,8 @@ ${cue.notes ?? ""}`;
             };
           }
         },
-        fragmentSample.presentationTimestamp,
+        -Infinity,
+        // Use -Infinity as a search timestamp to avoid using the lookup entries
         Infinity,
         options
       );
@@ -14401,12 +14426,15 @@ ${cue.notes ?? ""}`;
       this.currentCluster = cluster;
       this.readContiguousElements(this.clusterReader, size);
       for (const [trackId, trackData] of cluster.trackData) {
-        let blockReferencesExist = false;
+        const track = segment.tracks.find((x) => x.id === trackId) ?? null;
         assert(trackData.blocks.length > 0);
+        let blockReferencesExist = false;
+        let hasLacedBlocks = false;
         for (let i = 0; i < trackData.blocks.length; i++) {
           const block = trackData.blocks[i];
           block.timestamp += cluster.timestamp;
           blockReferencesExist ||= block.referencedTimestamps.length > 0;
+          hasLacedBlocks ||= block.lacing !== 0 /* None */;
         }
         if (blockReferencesExist) {
           trackData.blocks = sortBlocksByReferences(trackData.blocks);
@@ -14421,13 +14449,23 @@ ${cue.notes ?? ""}`;
           if (i < trackData.presentationTimestamps.length - 1) {
             const nextEntry = trackData.presentationTimestamps[i + 1];
             currentBlock.duration = nextEntry.timestamp - currentBlock.timestamp;
+          } else if (currentBlock.duration === 0) {
+            if (track?.defaultDuration != null) {
+              if (currentBlock.lacing === 0 /* None */) {
+                currentBlock.duration = track.defaultDuration;
+              } else {
+              }
+            }
           }
         }
+        if (hasLacedBlocks) {
+          this.expandLacedBlocks(trackData.blocks, track);
+          trackData.presentationTimestamps = trackData.blocks.map((block, i) => ({ timestamp: block.timestamp, blockIndex: i })).sort((a, b) => a.timestamp - b.timestamp);
+        }
         const firstBlock = trackData.blocks[trackData.presentationTimestamps[0].blockIndex];
         const lastBlock = trackData.blocks[last(trackData.presentationTimestamps).blockIndex];
         trackData.startTimestamp = firstBlock.timestamp;
         trackData.endTimestamp = lastBlock.timestamp + lastBlock.duration;
-        const track = segment.tracks.find((x) => x.id === trackId);
         if (track) {
           const insertionIndex2 = binarySearchLessOrEqual(
             track.clusters,
@@ -14469,6 +14507,95 @@ ${cue.notes ?? ""}`;
       }
       return trackData;
     }
+    expandLacedBlocks(blocks, track) {
+      for (let blockIndex = 0; blockIndex < blocks.length; blockIndex++) {
+        const originalBlock = blocks[blockIndex];
+        if (originalBlock.lacing === 0 /* None */) {
+          continue;
+        }
+        const data = originalBlock.data;
+        let pos = 0;
+        const frameSizes = [];
+        const frameCount = data[pos] + 1;
+        pos++;
+        switch (originalBlock.lacing) {
+          case 1 /* Xiph */:
+            {
+              let totalUsedSize = 0;
+              for (let i = 0; i < frameCount - 1; i++) {
+                let frameSize = 0;
+                while (pos < data.length) {
+                  const value = data[pos];
+                  frameSize += value;
+                  pos++;
+                  if (value < 255) {
+                    frameSizes.push(frameSize);
+                    totalUsedSize += frameSize;
+                    break;
+                  }
+                }
+              }
+              frameSizes.push(data.length - (pos + totalUsedSize));
+            }
+            ;
+            break;
+          case 2 /* FixedSize */:
+            {
+              const totalDataSize = data.length - 1;
+              const frameSize = Math.floor(totalDataSize / frameCount);
+              for (let i = 0; i < frameCount; i++) {
+                frameSizes.push(frameSize);
+              }
+            }
+            ;
+            break;
+          case 3 /* Ebml */:
+            {
+              const firstResult = readVarInt(data, pos);
+              let currentSize = firstResult.value;
+              frameSizes.push(currentSize);
+              pos += firstResult.width;
+              let totalUsedSize = currentSize;
+              for (let i = 1; i < frameCount - 1; i++) {
+                const diffResult = readVarInt(data, pos);
+                const unsignedDiff = diffResult.value;
+                const bias = (1 << diffResult.width * 7 - 1) - 1;
+                const diff = unsignedDiff - bias;
+                currentSize += diff;
+                frameSizes.push(currentSize);
+                pos += diffResult.width;
+                totalUsedSize += currentSize;
+              }
+              frameSizes.push(data.length - (pos + totalUsedSize));
+            }
+            ;
+            break;
+          default:
+            assert(false);
+        }
+        assert(frameSizes.length === frameCount);
+        blocks.splice(blockIndex, 1);
+        let dataOffset = pos;
+        for (let i = 0; i < frameCount; i++) {
+          const frameSize = frameSizes[i];
+          const frameData = data.subarray(dataOffset, dataOffset + 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, {
+            timestamp: frameTimestamp,
+            duration: frameDuration,
+            isKeyFrame: originalBlock.isKeyFrame,
+            referencedTimestamps: originalBlock.referencedTimestamps,
+            data: frameData,
+            lacing: 0 /* None */
+          });
+          dataOffset += frameSize;
+        }
+        blockIndex += frameCount;
+        blockIndex--;
+      }
+    }
     readContiguousElements(reader, totalSize) {
       const startIndex = reader.pos;
       while (reader.pos - startIndex <= totalSize - MIN_HEADER_SIZE) {
@@ -14543,6 +14670,7 @@ ${cue.notes ?? ""}`;
               inputTrack: null,
               codecId: null,
               codecPrivate: null,
+              defaultDuration: null,
               languageCode: UNDETERMINED_LANGUAGE,
               info: null
             };
@@ -14690,6 +14818,13 @@ ${cue.notes ?? ""}`;
           }
           ;
           break;
+        case 2352003 /* DefaultDuration */:
+          {
+            if (!this.currentTrack) break;
+            this.currentTrack.defaultDuration = this.currentTrack.segment.timestampFactor * reader.readUnsignedInt(size) / 1e9;
+          }
+          ;
+          break;
         case 2274716 /* Language */:
           {
             if (!this.currentTrack) break;
@@ -14868,14 +15003,17 @@ ${cue.notes ?? ""}`;
             const relativeTimestamp = reader.readS16();
             const flags = reader.readU8();
             const isKeyFrame = !!(flags & 128);
+            const lacing = flags >> 1 & 3;
             const trackData = this.getTrackDataInCluster(this.currentCluster, trackNumber);
             trackData.blocks.push({
               timestamp: relativeTimestamp,
               // We'll add the cluster's timestamp to this later
               duration: 0,
+              // Will set later
               isKeyFrame,
               referencedTimestamps: [],
-              data: reader.readBytes(size - (reader.pos - dataStartPos))
+              data: reader.readBytes(size - (reader.pos - dataStartPos)),
+              lacing
             });
           }
           ;
@@ -14899,14 +15037,17 @@ ${cue.notes ?? ""}`;
             const trackNumber = reader.readVarInt();
             const relativeTimestamp = reader.readS16();
             const flags = reader.readU8();
+            const lacing = flags >> 1 & 3;
             const trackData = this.getTrackDataInCluster(this.currentCluster, trackNumber);
             this.currentBlock = {
               timestamp: relativeTimestamp,
               // We'll add the cluster's timestamp to this later
               duration: 0,
+              // Will set later
               isKeyFrame: true,
               referencedTimestamps: [],
-              data: reader.readBytes(size - (reader.pos - dataStartPos))
+              data: reader.readBytes(size - (reader.pos - dataStartPos)),
+              lacing
             };
             trackData.blocks.push(this.currentBlock);
           }
@@ -15009,7 +15150,6 @@ ${cue.notes ?? ""}`;
         throw new Error("Packet was not created from this track.");
       }
       const trackData = locationInCluster.cluster.trackData.get(this.internalTrack.id);
-      const block = trackData.blocks[locationInCluster.blockIndex];
       const clusterIndex = binarySearchExact(
         this.internalTrack.clusters,
         locationInCluster.cluster.elementStartPos,
@@ -15050,7 +15190,8 @@ ${cue.notes ?? ""}`;
             };
           }
         },
-        block.timestamp,
+        -Infinity,
+        // Use -Infinity as a search timestamp to avoid using the cues
         Infinity,
         options
       );
@@ -15070,7 +15211,6 @@ ${cue.notes ?? ""}`;
         throw new Error("Packet was not created from this track.");
       }
       const trackData = locationInCluster.cluster.trackData.get(this.internalTrack.id);
-      const block = trackData.blocks[locationInCluster.blockIndex];
       const clusterIndex = binarySearchExact(
         this.internalTrack.clusters,
         locationInCluster.cluster.elementStartPos,
@@ -15116,7 +15256,8 @@ ${cue.notes ?? ""}`;
             };
           }
         },
-        block.timestamp,
+        -Infinity,
+        // Use -Infinity as a search timestamp to avoid using the cues
         Infinity,
         options
       );
@@ -16773,8 +16914,11 @@ ${cue.notes ?? ""}`;
       if (options.video?.rotate !== void 0 && ![0, 90, 180, 270].includes(options.video.rotate)) {
         throw new TypeError("options.video.rotate, when provided, must be 0, 90, 180 or 270.");
       }
+      if (options.video?.frameRate !== void 0 && (!Number.isFinite(options.video.frameRate) || options.video.frameRate <= 0)) {
+        throw new TypeError("options.video.frameRate, when provided, must be a finite positive number.");
+      }
       if (options.audio !== void 0 && (!options.audio || typeof options.audio !== "object")) {
-        throw new TypeError("options.video, when provided, must be an object.");
+        throw new TypeError("options.audio, when provided, must be an object.");
       }
       if (options.audio?.discard !== void 0 && typeof options.audio.discard !== "boolean") {
         throw new TypeError("options.audio.discard, when provided, must be a boolean.");
@@ -16941,7 +17085,7 @@ ${cue.notes ?? ""}`;
         height = ceilToMultipleOfTwo(this._options.video.height);
       }
       const firstTimestamp = await track.getFirstTimestamp();
-      const needsTranscode = !!this._options.video?.forceTranscode || this._startTimestamp > 0 || firstTimestamp < 0;
+      const needsTranscode = !!this._options.video?.forceTranscode || this._startTimestamp > 0 || firstTimestamp < 0 || !!this._options.video?.frameRate;
       const needsRerender = width !== originalWidth || height !== originalHeight || totalRotation !== 0 && !outputSupportsRotation;
       let videoCodecs = this.output.format.getSupportedVideoCodecs();
       if (!needsTranscode && !this._options.video?.bitrate && !needsRerender && videoCodecs.includes(sourceCodec) && (!this._options.video?.codec || this._options.video?.codec === sourceCodec)) {
@@ -16992,9 +17136,9 @@ ${cue.notes ?? ""}`;
           bitrate,
           onEncodedPacket: (sample) => this._reportProgress(track.id, sample.timestamp + sample.duration)
         };
+        const source = new VideoSampleSource(encodingConfig);
+        videoSource = source;
         if (needsRerender) {
-          const source = new VideoSampleSource(encodingConfig);
-          videoSource = source;
           this._trackPromises.push((async () => {
             await this._started;
             const sink = new CanvasSink(track, {
@@ -17006,6 +17150,22 @@ ${cue.notes ?? ""}`;
               poolSize: 1
             });
             const iterator = sink.canvases(this._startTimestamp, this._endTimestamp);
+            const frameRate = this._options.video?.frameRate;
+            let lastCanvas = null;
+            let lastCanvasTimestamp = null;
+            let lastCanvasEndTimestamp = null;
+            const padFrames = async (until) => {
+              assert(lastCanvas);
+              assert(frameRate !== void 0);
+              const frameDifference = Math.round((until - lastCanvasTimestamp) * frameRate);
+              for (let i = 1; i < frameDifference; i++) {
+                const sample = new VideoSample(lastCanvas, {
+                  timestamp: lastCanvasTimestamp + i / frameRate,
+                  duration: 1 / frameRate
+                });
+                await source.add(sample);
+              }
+            };
             for await (const { canvas, timestamp, duration } of iterator) {
               if (this._synchronizer.shouldWait(track.id, timestamp)) {
                 await this._synchronizer.wait(timestamp);
@@ -17013,30 +17173,98 @@ ${cue.notes ?? ""}`;
               if (this._canceled) {
                 return;
               }
+              let adjustedSampleTimestamp = Math.max(timestamp - this._startTimestamp, 0);
+              lastCanvasEndTimestamp = timestamp + duration;
+              if (frameRate !== void 0) {
+                const alignedTimestamp = Math.floor(adjustedSampleTimestamp * frameRate) / frameRate;
+                if (lastCanvas !== null) {
+                  if (alignedTimestamp <= lastCanvasTimestamp) {
+                    lastCanvas = canvas;
+                    lastCanvasTimestamp = alignedTimestamp;
+                    continue;
+                  } else {
+                    await padFrames(alignedTimestamp);
+                  }
+                }
+                adjustedSampleTimestamp = alignedTimestamp;
+              }
               const sample = new VideoSample(canvas, {
-                timestamp: Math.max(timestamp - this._startTimestamp, 0),
-                duration
+                timestamp: adjustedSampleTimestamp,
+                duration: frameRate !== void 0 ? 1 / frameRate : duration
               });
               await source.add(sample);
-              sample.close();
+              if (frameRate !== void 0) {
+                lastCanvas = canvas;
+                lastCanvasTimestamp = adjustedSampleTimestamp;
+              } else {
+                sample.close();
+              }
             }
+            if (lastCanvas) {
+              assert(lastCanvasEndTimestamp !== null);
+              assert(frameRate !== void 0);
+              await padFrames(Math.floor(lastCanvasEndTimestamp * frameRate) / frameRate);
+            }
+            source.close();
+            this._synchronizer.closeTrack(track.id);
           })());
         } else {
-          const source = new VideoSampleSource(encodingConfig);
-          videoSource = source;
           this._trackPromises.push((async () => {
             await this._started;
             const sink = new VideoSampleSink(track);
+            const frameRate = this._options.video?.frameRate;
+            let lastSample = null;
+            let lastSampleTimestamp = null;
+            let lastSampleEndTimestamp = null;
+            const padFrames = async (until) => {
+              assert(lastSample);
+              assert(frameRate !== void 0);
+              const frameDifference = Math.round((until - lastSampleTimestamp) * frameRate);
+              for (let i = 1; i < frameDifference; i++) {
+                lastSample.setTimestamp(lastSampleTimestamp + i / frameRate);
+                lastSample.setDuration(1 / frameRate);
+                await source.add(lastSample);
+              }
+              lastSample.close();
+            };
             for await (const sample of sink.samples(this._startTimestamp, this._endTimestamp)) {
               if (this._synchronizer.shouldWait(track.id, sample.timestamp)) {
                 await this._synchronizer.wait(sample.timestamp);
               }
-              sample.setTimestamp(Math.max(sample.timestamp - this._startTimestamp, 0));
               if (this._canceled) {
+                lastSample?.close();
                 return;
               }
+              let adjustedSampleTimestamp = Math.max(sample.timestamp - this._startTimestamp, 0);
+              lastSampleEndTimestamp = sample.timestamp + sample.duration;
+              if (frameRate !== void 0) {
+                const alignedTimestamp = Math.floor(adjustedSampleTimestamp * frameRate) / frameRate;
+                if (lastSample !== null) {
+                  if (alignedTimestamp <= lastSampleTimestamp) {
+                    lastSample.close();
+                    lastSample = sample;
+                    lastSampleTimestamp = alignedTimestamp;
+                    continue;
+                  } else {
+                    await padFrames(alignedTimestamp);
+                  }
+                }
+                adjustedSampleTimestamp = alignedTimestamp;
+                sample.setDuration(1 / frameRate);
+              }
+              sample.setTimestamp(adjustedSampleTimestamp);
               await source.add(sample);
-              sample.close();
+              if (frameRate !== void 0) {
+                lastSample = sample;
+                lastSampleTimestamp = adjustedSampleTimestamp;
+              } else {
+                sample.close();
+              }
+            }
+            if (lastSample) {
+              assert(lastSampleEndTimestamp !== null);
+              assert(frameRate !== void 0);
+              await padFrames(Math.floor(lastSampleEndTimestamp * frameRate) / frameRate);
             }
             source.close();
             this._synchronizer.closeTrack(track.id);
@@ -17044,6 +17272,7 @@ ${cue.notes ?? ""}`;
         }
       }
       this.output.addVideoTrack(videoSource, {
+        frameRate: this._options.video?.frameRate,
         languageCode: track.languageCode,
         rotation: needsRerender ? 0 : totalRotation
         // Rerendering will bake the rotation into the output