mediabunny 1.1.0 → 1.2.0

package/dist/bundles/mediabunny.cjs

@@ -9411,6 +9411,18 @@ ${cue.notes ?? ""}`;
       this.pos += 4;
       return view2.getUint32(offset, this.littleEndian);
     }
+    readU64() {
+      let low;
+      let high;
+      if (this.littleEndian) {
+        low = this.readU32();
+        high = this.readU32();
+      } else {
+        high = this.readU32();
+        low = this.readU32();
+      }
+      return high * 4294967296 + low;
+    }
     readAscii(length) {
       const { view: view2, offset } = this.reader.getViewAndOffset(this.pos, this.pos + length);
       this.pos += length;
@@ -9438,25 +9450,38 @@ ${cue.notes ?? ""}`;
       return this.metadataPromise ??= (async () => {
         const actualFileSize = await this.metadataReader.reader.source.getSize();
         const riffType = this.metadataReader.readAscii(4);
-        this.metadataReader.littleEndian = riffType === "RIFF";
-        const totalFileSize = Math.min(this.metadataReader.readU32() + 8, actualFileSize);
+        this.metadataReader.littleEndian = riffType !== "RIFX";
+        const isRf64 = riffType === "RF64";
+        const outerChunkSize = this.metadataReader.readU32();
+        let totalFileSize = isRf64 ? actualFileSize : Math.min(outerChunkSize + 8, actualFileSize);
         const format = this.metadataReader.readAscii(4);
         if (format !== "WAVE") {
           throw new Error("Invalid WAVE file - wrong format");
         }
         this.metadataReader.pos = 12;
+        let chunksRead = 0;
+        let dataChunkSize = null;
         while (this.metadataReader.pos < totalFileSize) {
           await this.metadataReader.reader.loadRange(this.metadataReader.pos, this.metadataReader.pos + 8);
           const chunkId = this.metadataReader.readAscii(4);
           const chunkSize = this.metadataReader.readU32();
           const startPos = this.metadataReader.pos;
+          if (isRf64 && chunksRead === 0 && chunkId !== "ds64") {
+            throw new Error('Invalid RF64 file: First chunk must be "ds64".');
+          }
           if (chunkId === "fmt ") {
             await this.parseFmtChunk(chunkSize);
           } else if (chunkId === "data") {
+            dataChunkSize ??= chunkSize;
             this.dataStart = this.metadataReader.pos;
-            this.dataSize = Math.min(chunkSize, totalFileSize - this.dataStart);
+            this.dataSize = Math.min(dataChunkSize, totalFileSize - this.dataStart);
+          } else if (chunkId === "ds64") {
+            const riffChunkSize = this.metadataReader.readU64();
+            dataChunkSize = this.metadataReader.readU64();
+            totalFileSize = Math.min(riffChunkSize + 8, actualFileSize);
           }
           this.metadataReader.pos = startPos + chunkSize + (chunkSize & 1);
+          chunksRead++;
         }
         if (!this.audioInfo) {
           throw new Error('Invalid WAVE file - missing "fmt " chunk');
@@ -9651,13 +9676,18 @@ ${cue.notes ?? ""}`;
       this.helper = new Uint8Array(8);
       this.helperView = new DataView(this.helper.buffer);
     }
+    writeU16(value) {
+      this.helperView.setUint16(0, value, true);
+      this.writer.write(this.helper.subarray(0, 2));
+    }
     writeU32(value) {
       this.helperView.setUint32(0, value, true);
       this.writer.write(this.helper.subarray(0, 4));
     }
-    writeU16(value) {
-      this.helperView.setUint16(0, value, true);
-      this.writer.write(this.helper.subarray(0, 2));
+    writeU64(value) {
+      this.helperView.setUint32(0, value, true);
+      this.helperView.setUint32(4, Math.floor(value / 2 ** 32), true);
+      this.writer.write(this.helper);
     }
     writeAscii(text) {
       this.writer.write(new TextEncoder().encode(text));
@@ -9670,9 +9700,12 @@ ${cue.notes ?? ""}`;
       super(output);
       this.headerWritten = false;
       this.dataSize = 0;
+      this.sampleRate = null;
+      this.sampleCount = 0;
       this.format = format;
       this.writer = output._writer;
       this.riffWriter = new RiffWriter(output._writer);
+      this.isRf64 = !!format._options.large;
     }
     async start() {
     }
@@ -9690,11 +9723,18 @@ ${cue.notes ?? ""}`;
           assert(meta);
           assert(meta.decoderConfig);
           this.writeHeader(track, meta.decoderConfig);
+          this.sampleRate = meta.decoderConfig.sampleRate;
           this.headerWritten = true;
         }
         this.validateAndNormalizeTimestamp(track, packet.timestamp, packet.type === "key");
+        if (!this.isRf64 && this.writer.getPos() + packet.data.byteLength >= 2 ** 32) {
+          throw new Error(
+            "Adding more audio data would exceed the maximum RIFF size of 4 GiB. To write larger files, use RF64 by setting `large: true` in the WavOutputFormatOptions."
+          );
+        }
         this.writer.write(packet.data);
         this.dataSize += packet.data.byteLength;
+        this.sampleCount += Math.round(packet.duration * this.sampleRate);
         await this.writer.flush();
       } finally {
         release();
@@ -9722,9 +9762,21 @@ ${cue.notes ?? ""}`;
       const channels = config.numberOfChannels;
       const sampleRate = config.sampleRate;
       const blockSize = pcmInfo.sampleSize * channels;
-      this.riffWriter.writeAscii("RIFF");
-      this.riffWriter.writeU32(0);
+      this.riffWriter.writeAscii(this.isRf64 ? "RF64" : "RIFF");
+      if (this.isRf64) {
+        this.riffWriter.writeU32(4294967295);
+      } else {
+        this.riffWriter.writeU32(0);
+      }
       this.riffWriter.writeAscii("WAVE");
+      if (this.isRf64) {
+        this.riffWriter.writeAscii("ds64");
+        this.riffWriter.writeU32(28);
+        this.riffWriter.writeU64(0);
+        this.riffWriter.writeU64(0);
+        this.riffWriter.writeU64(0);
+        this.riffWriter.writeU32(0);
+      }
       this.riffWriter.writeAscii("fmt ");
       this.riffWriter.writeU32(16);
       this.riffWriter.writeU16(format);
@@ -9734,7 +9786,11 @@ ${cue.notes ?? ""}`;
       this.riffWriter.writeU16(blockSize);
       this.riffWriter.writeU16(8 * pcmInfo.sampleSize);
       this.riffWriter.writeAscii("data");
-      this.riffWriter.writeU32(0);
+      if (this.isRf64) {
+        this.riffWriter.writeU32(4294967295);
+      } else {
+        this.riffWriter.writeU32(0);
+      }
       if (this.format._options.onHeader) {
         const { data, start } = this.writer.stopTrackingWrites();
         this.format._options.onHeader(data, start);
@@ -9743,10 +9799,19 @@ ${cue.notes ?? ""}`;
     async finalize() {
       const release = await this.mutex.acquire();
       const endPos = this.writer.getPos();
-      this.writer.seek(4);
-      this.riffWriter.writeU32(this.dataSize + 36);
-      this.writer.seek(40);
-      this.riffWriter.writeU32(this.dataSize);
+      if (this.isRf64) {
+        this.writer.seek(20);
+        this.riffWriter.writeU64(endPos - 8);
+        this.writer.seek(28);
+        this.riffWriter.writeU64(this.dataSize);
+        this.writer.seek(36);
+        this.riffWriter.writeU64(this.sampleCount);
+      } else {
+        this.writer.seek(4);
+        this.riffWriter.writeU32(endPos - 8);
+        this.writer.seek(40);
+        this.riffWriter.writeU32(this.dataSize);
+      }
       this.writer.seek(endPos);
       release();
     }
@@ -10005,6 +10070,9 @@ ${cue.notes ?? ""}`;
       if (!options || typeof options !== "object") {
         throw new TypeError("options must be an object.");
       }
+      if (options.large !== void 0 && typeof options.large !== "boolean") {
+        throw new TypeError("options.large, when provided, must be a boolean.");
+      }
       if (options.onHeader !== void 0 && typeof options.onHeader !== "function") {
         throw new TypeError("options.onHeader, when provided, must be a function.");
       }
@@ -13649,7 +13717,7 @@ ${cue.notes ?? ""}`;
       return this.readMetadataPromise ??= (async () => {
         this.metadataReader.pos = 0;
         const fileSize = await this.input.source.getSize();
-        while (this.metadataReader.pos < fileSize - MIN_HEADER_SIZE) {
+        while (this.metadataReader.pos <= fileSize - MIN_HEADER_SIZE) {
           await this.metadataReader.reader.loadRange(
             this.metadataReader.pos,
             this.metadataReader.pos + MAX_HEADER_SIZE
@@ -13898,7 +13966,7 @@ ${cue.notes ?? ""}`;
     }
     readContiguousElements(reader, totalSize) {
       const startIndex = reader.pos;
-      while (reader.pos - startIndex < totalSize) {
+      while (reader.pos - startIndex <= totalSize - MIN_HEADER_SIZE) {
         this.traverseElement(reader);
       }
     }
@@ -14712,7 +14780,7 @@ ${cue.notes ?? ""}`;
               size = (nextElementPos ?? segment.elementEndPos) - dataStartPos;
             }
             const endPos = dataStartPos + size;
-            if (endPos >= segment.elementEndPos - MIN_HEADER_SIZE) {
+            if (endPos > segment.elementEndPos - MIN_HEADER_SIZE) {
               break;
             } else {
               clusterReader.pos = endPos;
@@ -15973,7 +16041,7 @@ ${cue.notes ?? ""}`;
       }
       const riffReader = new RiffReader(input._mainReader);
       const riffType = riffReader.readAscii(4);
-      if (riffType !== "RIFF" && riffType !== "RIFX") {
+      if (riffType !== "RIFF" && riffType !== "RIFX" && riffType !== "RF64") {
         return false;
       }
       riffReader.pos = 8;