mediabunny 1.45.3 → 1.45.5

package/dist/bundles/mediabunny.cjs

@@ -120,6 +120,7 @@ var Mediabunny = (() => {
     CustomAudioDecoder: () => CustomAudioDecoder,
     CustomAudioEncoder: () => CustomAudioEncoder,
     CustomPathedSource: () => CustomPathedSource,
+    CustomSource: () => CustomSource,
     CustomVideoDecoder: () => CustomVideoDecoder,
     CustomVideoEncoder: () => CustomVideoEncoder,
     EncodedAudioPacketSource: () => EncodedAudioPacketSource,
@@ -2283,7 +2284,7 @@ var Mediabunny = (() => {
   };
 
   // shared/mp3-misc.ts
-  var FRAME_HEADER_SIZE = 4;
+  var MP3_FRAME_HEADER_SIZE = 4;
   var SAMPLING_RATES = [44100, 48e3, 32e3];
   var KILOBIT_RATES = [
     // lowSamplingFrequency === 0
@@ -2551,6 +2552,9 @@ var Mediabunny = (() => {
     }
     return unsynchsafed;
   };
+  var getMp3ChannelCount = (channel) => {
+    return channel === 3 ? 1 : 2;
+  };
 
   // shared/ac3-misc.ts
   var AC3_SAMPLE_RATES = [48e3, 44100, 32e3];
@@ -6349,18 +6353,21 @@ var Mediabunny = (() => {
             }
             assert(track.info?.type === "video");
             const colourType = readAscii(slice, 4);
-            if (colourType !== "nclx") {
+            if (colourType !== "nclx" && colourType !== "nclc") {
               break;
             }
             const colourPrimaries = readU16Be(slice);
             const transferCharacteristics = readU16Be(slice);
             const matrixCoefficients = readU16Be(slice);
-            const fullRangeFlag = Boolean(readU8(slice) & 128);
+            let fullRange = void 0;
+            if (colourType === "nclx") {
+              fullRange = Boolean(readU8(slice) & 128);
+            }
             track.info.colorSpace = {
               primaries: COLOR_PRIMARIES_MAP_INVERSE[colourPrimaries],
               transfer: TRANSFER_CHARACTERISTICS_MAP_INVERSE[transferCharacteristics],
               matrix: MATRIX_COEFFICIENTS_MAP_INVERSE[matrixCoefficients],
-              fullRange: fullRangeFlag
+              fullRange
             };
           }
           ;
@@ -10880,20 +10887,22 @@ var Mediabunny = (() => {
   };
 
   // src/mp3/mp3-reader.ts
-  var readNextMp3FrameHeader = async (reader, startPos, until) => {
+  var readNextMp3FrameHeader = async (reader, startPos, until, ref = null) => {
     const CHUNK_SIZE = 2 ** 16;
     let currentPos = startPos;
     while (until === null || currentPos < until) {
       const maxLength = until !== null ? Math.min(CHUNK_SIZE, until - currentPos) : CHUNK_SIZE;
-      let slice = reader.requestSliceRange(currentPos, FRAME_HEADER_SIZE, maxLength);
+      let slice = reader.requestSliceRange(currentPos, MP3_FRAME_HEADER_SIZE, maxLength);
       if (slice instanceof Promise) slice = await slice;
-      if (!slice || slice.length < FRAME_HEADER_SIZE) break;
-      while (slice.remainingLength >= FRAME_HEADER_SIZE) {
+      if (!slice || slice.length < MP3_FRAME_HEADER_SIZE) break;
+      while (slice.remainingLength >= MP3_FRAME_HEADER_SIZE) {
         const posBeforeRead = slice.filePos;
         const word = readU32Be(slice);
         const remainingBytes = reader.fileSize !== null ? reader.fileSize - currentPos : null;
         const result = readMp3FrameHeader(word, remainingBytes);
-        if (result.header) {
+        if (result.header && (!ref || // This condition helps us recover malformed streams
+        // https://stackoverflow.com/a/20884944
+        result.header.sampleRate === ref.sampleRate && result.header.mpegVersionId === ref.mpegVersionId && result.header.layer === ref.layer && getMp3ChannelCount(result.header.channel) === getMp3ChannelCount(ref.channel))) {
           return { header: result.header, startPos: currentPos };
         }
         slice.filePos = posBeforeRead + result.bytesAdvanced;
@@ -10948,7 +10957,12 @@ var Mediabunny = (() => {
           this.lastLoadedPos = slice2.filePos + id3V2Header.size;
         }
       }
-      const result = await readNextMp3FrameHeader(this.reader, this.lastLoadedPos, this.reader.fileSize);
+      const result = await readNextMp3FrameHeader(
+        this.reader,
+        this.lastLoadedPos,
+        this.reader.fileSize,
+        this.firstFrameHeader
+      );
       if (!result) {
         this.lastSampleLoaded = true;
         return;
@@ -10982,11 +10996,6 @@ var Mediabunny = (() => {
         this.firstFrameHeader = header;
         this.firstFrameHeaderPos = result.startPos;
       }
-      if (header.sampleRate !== this.firstFrameHeader.sampleRate) {
-        console.warn(
-          `MP3 changed sample rate mid-file: ${this.firstFrameHeader.sampleRate} Hz to ${header.sampleRate} Hz. Might be a bug, so please report this file.`
-        );
-      }
       const sampleDuration = header.audioSamplesInFrame / this.firstFrameHeader.sampleRate;
       const sample = {
         timestamp: this.nextTimestampInSamples / this.firstFrameHeader.sampleRate,
@@ -11113,7 +11122,7 @@ var Mediabunny = (() => {
     }
     getNumberOfChannels() {
       assert(this.demuxer.firstFrameHeader);
-      return this.demuxer.firstFrameHeader.channel === 3 ? 1 : 2;
+      return getMp3ChannelCount(this.demuxer.firstFrameHeader.channel);
     }
     getSampleRate() {
       assert(this.demuxer.firstFrameHeader);
@@ -11128,7 +11137,7 @@ var Mediabunny = (() => {
       assert(this.demuxer.firstFrameHeader);
       return {
         codec: "mp3",
-        numberOfChannels: this.demuxer.firstFrameHeader.channel === 3 ? 1 : 2,
+        numberOfChannels: getMp3ChannelCount(this.demuxer.firstFrameHeader.channel),
         sampleRate: this.demuxer.firstFrameHeader.sampleRate
       };
     }
@@ -13850,7 +13859,7 @@ var Mediabunny = (() => {
                         "Invalid MP3 audio stream; could not read frame header from first packet."
                       );
                     }
-                    elementaryStream.info.numberOfChannels = result.header.channel === 3 ? 1 : 2;
+                    elementaryStream.info.numberOfChannels = getMp3ChannelCount(result.header.channel);
                     elementaryStream.info.sampleRate = result.header.sampleRate;
                   } else if (elementaryStream.info.codec === "ac3") {
                     const frameInfo = parseAc3SyncFrame(context.suppliedPacket.data);
@@ -14914,12 +14923,12 @@ var Mediabunny = (() => {
               }
               this.skip(-1);
               const possibleHeaderStartPos = this.currentPos;
-              let remaining2 = this.ensureBuffered(FRAME_HEADER_SIZE);
+              let remaining2 = this.ensureBuffered(MP3_FRAME_HEADER_SIZE);
               if (remaining2 instanceof Promise) remaining2 = await remaining2;
-              if (remaining2 < FRAME_HEADER_SIZE) {
+              if (remaining2 < MP3_FRAME_HEADER_SIZE) {
                 return;
               }
-              const headerBytes = this.readBytes(FRAME_HEADER_SIZE);
+              const headerBytes = this.readBytes(MP3_FRAME_HEADER_SIZE);
               const word = toDataView(headerBytes).getUint32(0);
               const result = readMp3FrameHeader(word, null);
               if (result.header) {
@@ -15562,9 +15571,15 @@ var Mediabunny = (() => {
   var node = typeof nodeAlias !== "undefined" ? nodeAlias : void 0;
   var DEFAULT_MIN_READ_POSITION = 0;
   var DEFAULT_MAX_READ_POSITION = Infinity;
+  var sourceFinalizationRegistry = null;
+  if (typeof FinalizationRegistry !== "undefined") {
+    sourceFinalizationRegistry = new FinalizationRegistry((cleanup) => {
+      cleanup();
+    });
+  }
   var Source = class extends EventEmitter {
     constructor() {
-      super(...arguments);
+      super();
       /** @internal */
       this._disposed = false;
       /** @internal */
@@ -15574,6 +15589,13 @@ var Mediabunny = (() => {
        * @internal
        */
       this._usedForHls = false;
+      /**
+       * FinalizationRegistry for rogue refs to this source that didn't get freed. It lives on the Source itself so that
+       * in case the Source transitively points back to itself and forms a cycle (for example through a custom
+       * CustomSource callback) that we're not leaking memory.
+       * @internal
+       */
+      this._refFinalizationRegistry = null;
       /** @internal */
       this._sizePromise = null;
       /**
@@ -15582,6 +15604,11 @@ var Mediabunny = (() => {
        * @deprecated Use `source.on('read', ({ start, end }) => ...)` instead.
        */
       this.onread = null;
+      if (typeof FinalizationRegistry !== "undefined") {
+        this._refFinalizationRegistry = new FinalizationRegistry((source) => {
+          source._decrementRefCount();
+        });
+      }
     }
     /**
      * Resolves with the total size of the file in bytes. This function is memoized, meaning only the first call
@@ -15647,6 +15674,18 @@ var Mediabunny = (() => {
     ref() {
       return new SourceRef(this);
     }
+    /** @internal */
+    _incrementRefCount() {
+      this._refCount++;
+    }
+    /** @internal */
+    _decrementRefCount() {
+      this._refCount--;
+      if (this._refCount === 0) {
+        this._dispose();
+        this._disposed = true;
+      }
+    }
   };
   var SourceRef = class {
     /** @internal */
@@ -15656,7 +15695,8 @@ var Mediabunny = (() => {
       if (source._disposed) {
         throw new Error("Cannot ref a disposed source.");
       }
-      source._refCount++;
+      source._incrementRefCount();
+      source._refFinalizationRegistry?.register(this, source, this);
       this._source = source;
     }
     /** The {@link Source} this ref references. Accessing this field throws an error after having freed the ref. */
@@ -15680,11 +15720,8 @@ var Mediabunny = (() => {
       }
       const source = this.source;
       assert(source._refCount > 0);
-      source._refCount--;
-      if (source._refCount === 0) {
-        source._dispose();
-        source._disposed = true;
-      }
+      source._decrementRefCount();
+      source._refFinalizationRegistry?.unregister(this);
       this._freed = true;
       this._source = null;
     }
@@ -15922,8 +15959,8 @@ var Mediabunny = (() => {
     /**
      * Creates a new {@link UrlSource} backed by the resource at the specified URL.
      *
-     * When passing a `Request` instance, note that the `signal` and `headers.Range` options will be overridden by
-     * Mediabunny. If you want to cancel ongoing requests, use {@link Input.dispose}.
+     * When passing a `Request` instance, note that its `signal` will be overridden by Mediabunny; if you want to cancel
+     * ongoing requests, use {@link Input.dispose}.
      */
     constructor(url2, options = {}) {
       if (typeof url2 !== "string" && !(url2 instanceof URL) && !(typeof Request !== "undefined" && url2 instanceof Request)) {
@@ -15949,6 +15986,10 @@ var Mediabunny = (() => {
       }
       const urlString = url2 instanceof Request ? url2.url : url2 instanceof URL ? url2.href : url2;
       super(urlString, (request) => new _UrlSource(request.path, this._options));
+      /** @internal */
+      this._offset = 0;
+      /** @internal */
+      this._length = null;
       /**
        * Note that this value being true does NOT mean the file size can't change anymore; it just signals that we have at
        * least checked if we know the file size or not.
@@ -15958,6 +15999,33 @@ var Mediabunny = (() => {
       this._url = url2;
       this._options = options;
       this._getRetryDelay = options.getRetryDelay ?? DEFAULT_RETRY_DELAY;
+      this._requestInit = { ...options.requestInit };
+      let rangeHeaderValue = null;
+      if (options.requestInit?.headers) {
+        const headers = { ...normalizeHeaders(options.requestInit.headers) };
+        const rangeKey = Object.keys(headers).find((key) => key.toLowerCase() === "range");
+        if (rangeKey !== void 0) {
+          rangeHeaderValue = headers[rangeKey];
+          delete headers[rangeKey];
+          this._requestInit.headers = headers;
+        }
+      }
+      if (url2 instanceof Request) {
+        const requestRange = url2.headers.get("Range");
+        if (requestRange !== null) {
+          rangeHeaderValue ??= requestRange;
+          const strippedRequest = new Request(url2);
+          strippedRequest.headers.delete("Range");
+          this._url = strippedRequest;
+        }
+      }
+      if (rangeHeaderValue !== null) {
+        const parsed = parseByteRangeHeader(rangeHeaderValue);
+        if (parsed) {
+          this._offset = parsed.offset;
+          this._length = parsed.length;
+        }
+      }
       const DEFAULT_PARALLELISM = 2;
       this._orchestrator = new ReadOrchestrator({
         maxCacheSize: options.maxCacheSize ?? 64 * 2 ** 20,
@@ -15968,11 +16036,39 @@ var Mediabunny = (() => {
     }
     /** @internal */
     _getFileSize() {
-      return this._fileSizeDetermined ? this._orchestrator.fileSize : void 0;
+      if (!this._fileSizeDetermined) {
+        return this._length !== null ? this._length : void 0;
+      }
+      const baseSize = this._orchestrator.fileSize;
+      if (baseSize === null) {
+        return this._length !== null ? this._length : null;
+      }
+      return clamp(baseSize - this._offset, 0, this._length ?? Infinity);
     }
     /** @internal */
     _read(start, end, minReadPosition, maxReadPosition) {
-      return this._orchestrator.read(start, end, minReadPosition, maxReadPosition);
+      if (this._length !== null && end > this._length) {
+        return null;
+      }
+      const offset = this._offset;
+      const result = this._orchestrator.read(
+        offset + start,
+        offset + end,
+        Math.max(offset + minReadPosition, offset),
+        offset + Math.min(maxReadPosition, this._length ?? Infinity)
+      );
+      const processResult = (result2) => {
+        if (!result2) {
+          return null;
+        }
+        result2.offset -= this._offset;
+        return result2;
+      };
+      if (result instanceof Promise) {
+        return result.then(processResult);
+      } else {
+        return processResult(result);
+      }
     }
     /** @internal */
     async _runWorker(worker) {
@@ -15981,7 +16077,7 @@ var Mediabunny = (() => {
         const response = await retriedFetch(
           this._options.fetchFn ?? fetch,
           this._url,
-          mergeRequestInit(this._options.requestInit ?? {}, {
+          mergeRequestInit(this._requestInit, {
             headers: {
               // Always sending a range request is a good way to probe if the server supports them
               Range: `bytes=${worker.currentPos}-`
@@ -16090,6 +16186,22 @@ var Mediabunny = (() => {
       this._orchestrator.dispose();
     }
   };
+  var BYTE_RANGE_REGEX = /^bytes=(\d+)-(\d*)$/;
+  var parseByteRangeHeader = (value) => {
+    const match = BYTE_RANGE_REGEX.exec(value.trim());
+    if (!match) {
+      return null;
+    }
+    const offset = Number(match[1]);
+    const end = match[2] === "" ? null : Number(match[2]);
+    if (end !== null && end < offset) {
+      return null;
+    }
+    return {
+      offset,
+      length: end !== null ? end - offset + 1 : null
+    };
+  };
   var FilePathSource = class _FilePathSource extends PathedSource {
     /** Creates a new {@link FilePathSource} backed by the file at the specified file path. */
     constructor(filePath, options = {}) {
@@ -16110,10 +16222,14 @@ var Mediabunny = (() => {
       super(filePath, (request) => new _FilePathSource(request.path, options));
       /** @internal */
       this._fileHandle = null;
-      this._streamSource = new StreamSource({
+      this._customSource = new CustomSource({
         getSize: async () => {
-          this._fileHandle = await node.fs.open(filePath, "r");
-          const stats = await this._fileHandle.stat();
+          const fileHandle = await node.fs.open(filePath, "r");
+          this._fileHandle = fileHandle;
+          sourceFinalizationRegistry?.register(this, () => {
+            void fileHandle.close();
+          }, this);
+          const stats = await fileHandle.stat();
           return stats.size;
         },
         read: async (start, end) => {
@@ -16128,21 +16244,24 @@ var Mediabunny = (() => {
     }
     /** @internal */
     _read(start, end, minReadPosition, maxReadPosition) {
-      return this._streamSource._read(start, end, minReadPosition, maxReadPosition);
+      return this._customSource._read(start, end, minReadPosition, maxReadPosition);
     }
     /** @internal */
     _getFileSize() {
-      return this._streamSource._getFileSize();
+      return this._customSource._getFileSize();
     }
     /** @internal */
     _dispose() {
-      this._streamSource._dispose();
-      void this._fileHandle?.close();
-      this._fileHandle = null;
+      this._customSource._dispose();
+      if (this._fileHandle) {
+        void this._fileHandle.close();
+        this._fileHandle = null;
+        sourceFinalizationRegistry?.unregister(this);
+      }
     }
   };
-  var StreamSource = class extends Source {
-    /** Creates a new {@link StreamSource} whose behavior is specified by `options`.  */
+  var CustomSource = class extends Source {
+    /** Creates a new {@link CustomSource} whose behavior is specified by `options`.  */
     constructor(options) {
       if (!options || typeof options !== "object") {
         throw new TypeError("options must be an object.");
@@ -16253,6 +16372,7 @@ var Mediabunny = (() => {
       this._options.dispose?.();
     }
   };
+  var StreamSource = CustomSource;
   var ReadableStreamSource = class extends Source {
     /** Creates a new {@link ReadableStreamSource} backed by the specified `ReadableStream<Uint8Array>`. */
     constructor(stream, options = {}) {
@@ -16995,20 +17115,17 @@ var Mediabunny = (() => {
         this._offset + minReadPosition,
         this._offset + maxReadPosition
       );
-      if (result instanceof Promise) {
-        return result.then((result2) => {
-          if (!result2) {
-            return null;
-          }
-          result2.offset -= this._offset;
-          return result2;
-        });
-      } else {
-        if (!result) {
+      const processResult = (result2) => {
+        if (!result2) {
           return null;
         }
-        result.offset -= this._offset;
-        return result;
+        result2.offset -= this._offset;
+        return result2;
+      };
+      if (result instanceof Promise) {
+        return result.then(processResult);
+      } else {
+        return processResult(result);
       }
     }
     /** @internal */
@@ -18449,7 +18566,11 @@ var Mediabunny = (() => {
         return true;
       }
       currentPos = firstResult.startPos + firstResult.header.totalSize;
-      const secondResult = await readNextMp3FrameHeader(input._reader, currentPos, currentPos + FRAME_HEADER_SIZE);
+      const secondResult = await readNextMp3FrameHeader(
+        input._reader,
+        currentPos,
+        currentPos + MP3_FRAME_HEADER_SIZE
+      );
       if (!secondResult) {
         return false;
       }
@@ -22084,6 +22205,9 @@ var Mediabunny = (() => {
             const filteredNalUnits = [];
             for (const loc of iterateAvcNalUnits(packet.data, this.decoderConfig)) {
               const type = extractNalUnitTypeForAvc(packet.data[loc.offset]);
+              if (type === 9 /* AUD */) {
+                filteredNalUnits.length = 0;
+              }
               if (!(type >= 20 && type <= 31)) {
                 filteredNalUnits.push(packet.data.subarray(loc.offset, loc.offset + loc.length));
               }
@@ -23770,7 +23894,7 @@ var Mediabunny = (() => {
     /** If this method returns true, the track's samples use a high dynamic range (HDR). */
     async hasHighDynamicRange() {
       const colorSpace = await this._backing.getColorSpace();
-      return colorSpace.primaries === "bt2020" || colorSpace.primaries === "smpte432" || colorSpace.transfer === "pg" || colorSpace.transfer === "hlg" || colorSpace.matrix === "bt2020-ncl";
+      return colorSpace.primaries === "bt2020" || colorSpace.primaries === "smpte432" || colorSpace.transfer === "pq" || colorSpace.transfer === "hlg" || colorSpace.matrix === "bt2020-ncl";
     }
     /** Checks if this track may contain transparent samples with alpha data. */
     async canBeTransparent() {
@@ -24050,16 +24174,6 @@ var Mediabunny = (() => {
   polyfillSymbolDispose();
   var DEFAULT_SOURCE_CACHE_GROUP = 1;
   var ENCRYPTION_KEY_CACHE_GROUP = 2;
-  var inputFinalizationRegistry = null;
-  if (typeof FinalizationRegistry !== "undefined") {
-    inputFinalizationRegistry = new FinalizationRegistry((refs) => {
-      for (const ref of refs) {
-        if (!ref.freed) {
-          ref.free();
-        }
-      }
-    });
-  }
   var Input = class _Input extends EventEmitter {
     /**
      * Creates a new input file from the specified options. No reading operations will be performed until methods are
@@ -24114,7 +24228,6 @@ var Mediabunny = (() => {
         this._rootRef = options.source;
       }
       this._sourceRefs.push(this._rootRef);
-      inputFinalizationRegistry?.register(this, this._sourceRefs, this);
     }
     /** True if the input has been disposed. */
     get disposed() {
@@ -24402,7 +24515,6 @@ var Mediabunny = (() => {
         ref.free();
       }
       this._sourceRefs.length = 0;
-      inputFinalizationRegistry?.unregister(this);
       void this._demuxerPromise?.then((demuxer) => demuxer.dispose());
     }
     /**
@@ -24516,13 +24628,13 @@ var Mediabunny = (() => {
           if (chunks.length === 1 && this.fileSizeNonStrict !== null) {
             return this.requestSlice(0, this.fileSizeNonStrict);
           }
-          const startOffset = chunks.length * CHUNK_SIZE;
-          let slice = this.requestSliceRange(startOffset, 0, CHUNK_SIZE);
+          let slice = this.requestSliceRange(currentSize, 0, CHUNK_SIZE);
           if (slice instanceof Promise) slice = await slice;
-          if (!slice) {
+          if (!slice || slice.length === 0) {
             break;
           }
-          chunks.push(readBytes(slice, slice.length));
+          const chunk = readBytes(slice, slice.length);
+          chunks.push(chunk);
           currentSize += slice.length;
         }
         const joined = new Uint8Array(currentSize);
@@ -24918,7 +25030,7 @@ var Mediabunny = (() => {
     const yearText = readId3V1String(slice, 4);
     const year = Number.parseInt(yearText, 10);
     if (Number.isInteger(year) && year > 0) {
-      tags.date ??= new Date(year, 0, 1);
+      tags.date ??= new Date(String(year));
     }
     const commentBytes = readBytes(slice, 30);
     let comment;
@@ -25138,7 +25250,7 @@ var Mediabunny = (() => {
             const yearText = reader.readId3V2EncodingAndText(frameEndPos);
             const year = Number.parseInt(yearText, 10);
             if (Number.isInteger(year)) {
-              tags.date ??= new Date(year, 0, 1);
+              tags.date ??= new Date(String(year));
             }
           }
           ;
@@ -26379,12 +26491,14 @@ var Mediabunny = (() => {
   };
   var mdat = (reserveLargeSize) => ({ type: "mdat", largeSize: reserveLargeSize });
   var free = (size) => ({ type: "free", size });
-  var moov = (muxer) => box("moov", void 0, [
-    mvhd(muxer.creationTime, muxer.trackDatas),
-    ...muxer.trackDatas.map((x) => trak(x, muxer.creationTime)),
-    muxer.isFragmented ? mvex(muxer.trackDatas) : null,
-    udta(muxer)
-  ]);
+  var moov = (muxer) => {
+    return box("moov", void 0, [
+      mvhd(muxer.creationTime, muxer.trackDatas),
+      ...muxer.trackDatas.map((x) => trak(x, muxer.creationTime)),
+      muxer.isFragmented ? mvex(muxer.trackDatas) : null,
+      udta(muxer)
+    ]);
+  };
   var mvhd = (creationTime, trackDatas) => {
     const duration = Math.max(
       0,
@@ -26695,7 +26809,7 @@ var Mediabunny = (() => {
     ]);
   };
   var colr = (trackData) => box("colr", [
-    ascii("nclx"),
+    ascii(trackData.muxer.isQuickTime ? "nclc" : "nclx"),
     // Colour type
     u16(COLOR_PRIMARIES_MAP[trackData.info.decoderConfig.colorSpace.primaries]),
     // Colour primaries
@@ -26703,7 +26817,7 @@ var Mediabunny = (() => {
     // Transfer characteristics
     u16(MATRIX_COEFFICIENTS_MAP[trackData.info.decoderConfig.colorSpace.matrix]),
     // Matrix coefficients
-    u8((trackData.info.decoderConfig.colorSpace.fullRange ? 1 : 0) << 7)
+    trackData.muxer.isQuickTime ? [] : u8((trackData.info.decoderConfig.colorSpace.fullRange ? 1 : 0) << 7)
     // Full range flag
   ]);
   var avcC = (trackData) => trackData.info.decoderConfig && box("avcC", [
@@ -29203,6 +29317,7 @@ var Mediabunny = (() => {
         if (this.format._options.onMoov) {
           boxWriter.writer.startTrackingWrites();
         }
+        this.ensureOneEnabledTrack();
         const movieBox = moov(this);
         boxWriter.writeBox(movieBox);
         if (this.format._options.onMoov) {
@@ -29285,6 +29400,7 @@ var Mediabunny = (() => {
       assert(this.boxWriter);
       if (this.allTracksAreKnown()) {
         if (!this.mdat) {
+          this.ensureOneEnabledTrack();
           const moovBox = moov(this);
           const moovSize = this.boxWriter.measureBox(moovBox);
           const reservedSize = moovSize + this.computeSampleTableSizeUpperBound() + 4096;
@@ -29341,10 +29457,27 @@ var Mediabunny = (() => {
       }
       release();
     }
+    ensureOneEnabledTrack() {
+      for (const type of ["video", "audio", "subtitle"]) {
+        const tracks = this.trackDatas.filter((t) => t.type === type);
+        if (tracks.length === 0) {
+          continue;
+        }
+        const hasEnabled = tracks.some((t) => t.track.metadata.disposition?.default !== false);
+        if (!hasEnabled) {
+          const firstTrack = tracks[0];
+          firstTrack.track.metadata.disposition = {
+            ...firstTrack.track.metadata.disposition,
+            default: true
+          };
+        }
+      }
+    }
     /** Finalizes the file, making it ready for use. Must be called after all video and audio chunks have been added. */
     async finalize() {
       const release = await this.mutex.acquire();
       this.allTracksKnown.resolve();
+      this.ensureOneEnabledTrack();
       for (const trackData of this.trackDatas) {
         trackData.closed = true;
         if (trackData.type === "subtitle" && trackData.track.source._codec === "webvtt") {