@byteplus/veplayer-plugin 2.4.0 → 2.4.1-rc.1

package/esm/veplayer.plugin.hls.development.js

@@ -1640,7 +1640,7 @@ util.getCurrentTimeByOffset = function(offsetTime, segments) {
   }
   return offsetTime;
 };
-var version = "3.0.19-rc.0";
+var version = "3.0.20-rc.3";
 var ERROR_MAP = {
   1: 5101,
   2: 5102,
@@ -2674,7 +2674,7 @@ function _arrayLikeToArray$1(arr, len) {
     arr2[i] = arr[i];
   return arr2;
 }
-function _createForOfIteratorHelper(o, allowArrayLike) {
+function _createForOfIteratorHelper$1(o, allowArrayLike) {
   var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
   if (!it) {
     if (Array.isArray(o) || (it = _unsupportedIterableToArray$1(o)) || allowArrayLike && o && typeof o.length === "number") {
@@ -2862,6 +2862,21 @@ var Buffer$1 = /* @__PURE__ */ function() {
         length: Buffer2.totalLength && Buffer2.totalLength(buffers)
       };
     }
+  }, {
+    key: "isBuffered",
+    value: function isBuffered(media, pos) {
+      if (media) {
+        var buffered = Buffer2.get(media);
+        if (buffered !== null && buffered !== void 0 && buffered.length) {
+          for (var i = 0; i < buffered.length; i++) {
+            if (pos >= buffered.start(i) && pos <= buffered.end(i)) {
+              return true;
+            }
+          }
+        }
+      }
+      return false;
+    }
   }]);
   return Buffer2;
 }();
@@ -4766,7 +4781,7 @@ var XhrLoader = /* @__PURE__ */ function(_EventEmitter) {
     value: function _getHeaders(xhr) {
       var headerLines = xhr.getAllResponseHeaders().trim().split("\r\n");
       var headers = {};
-      var _iterator = _createForOfIteratorHelper(headerLines), _step;
+      var _iterator = _createForOfIteratorHelper$1(headerLines), _step;
       try {
         for (_iterator.s(); !(_step = _iterator.n()).done; ) {
           var header = _step.value;
@@ -5604,6 +5619,60 @@ function _nonIterableSpread() {
 function _nonIterableRest() {
   throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (!it) {
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (it)
+        o = it;
+      var i = 0;
+      var F = function() {
+      };
+      return {
+        s: F,
+        n: function() {
+          if (i >= o.length)
+            return {
+              done: true
+            };
+          return {
+            done: false,
+            value: o[i++]
+          };
+        },
+        e: function(e) {
+          throw e;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var normalCompletion = true, didErr = false, err;
+  return {
+    s: function() {
+      it = it.call(o);
+    },
+    n: function() {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    },
+    e: function(e) {
+      didErr = true;
+      err = e;
+    },
+    f: function() {
+      try {
+        if (!normalCompletion && it.return != null)
+          it.return();
+      } finally {
+        if (didErr)
+          throw err;
+      }
+    }
+  };
+}
 function _toPrimitive(input, hint) {
   if (typeof input !== "object" || input === null)
     return input;
@@ -5626,6 +5695,7 @@ var TrackType = {
   METADATA: "metadata"
 };
 var VideoCodecType = {
+  AV1: "av1",
   AVC: "avc",
   HEVC: "hevc"
 };
@@ -5672,6 +5742,7 @@ var VideoTrack = /* @__PURE__ */ function() {
     _defineProperty(this, "isVideoEncryption", false);
     _defineProperty(this, "isAudioEncryption", false);
     _defineProperty(this, "isVideo", true);
+    _defineProperty(this, "lastKeyFrameDts", 0);
     _defineProperty(this, "kid", null);
     _defineProperty(this, "pssh", null);
     _defineProperty(this, "ext", void 0);
@@ -5714,6 +5785,9 @@ var VideoTrack = /* @__PURE__ */ function() {
   }, {
     key: "exist",
     value: function exist() {
+      if (/av01/.test(this.codec)) {
+        return true;
+      }
       return !!(this.pps.length && this.sps.length && this.codec);
     }
   }, {
@@ -5982,7 +6056,7 @@ var AAC = /* @__PURE__ */ function() {
           continue;
         }
         frameLength = (data[i + 3] & 3) << 11 | data[i + 4] << 3 | (data[i + 5] & 224) >> 5;
-        if (len - i < frameLength)
+        if (!frameLength || len - i < frameLength)
           break;
         protectionSkipBytes = (~data[i + 1] & 1) * 2;
         frames.push({
@@ -6176,6 +6250,15 @@ function parse2(a) {
     return parseInt(item, 16);
   });
 }
+function combineToFloat(integer, decimal) {
+  return Number(integer + "." + decimal);
+}
+function toDegree(matrix) {
+  if (matrix.length < 5)
+    return 0;
+  var scaled0 = Math.hypot(matrix[0], matrix[3]), scaled1 = Math.hypot(matrix[1], matrix[4]);
+  return 0 === scaled0 || 0 === scaled1 ? 0 : 180 * Math.atan2(matrix[1] / scaled1, matrix[0] / scaled0) / Math.PI;
+}
 var NALu = /* @__PURE__ */ function() {
   function NALu2() {
     _classCallCheck(this, NALu2);
@@ -6838,13 +6921,16 @@ var MAX_SILENT_FRAME_DURATION = 9e4;
 var AUDIO_EXCETION_LOG_EMIT_DURATION = 5 * 9e4;
 var MAX_VIDEO_FRAME_DURATION = 9e4;
 var MAX_DTS_DELTA_WITH_NEXT_CHUNK = 9e4 / 2;
+var LARGE_AV_FIRST_FRAME_FORCE_FIX_THRESHOLD = 9e4 * 5;
 var TsFixer = /* @__PURE__ */ function() {
-  function TsFixer2(videoTrack, audioTrack, metadataTrack) {
+  function TsFixer2(videoTrack, audioTrack, metadataTrack, fixerConfig) {
     _classCallCheck(this, TsFixer2);
     this.videoTrack = videoTrack;
     this.audioTrack = audioTrack;
     this.metadataTrack = metadataTrack;
     this._baseDts = -1;
+    this._baseVideoDts = -1;
+    this._baseAudioDts = -1;
     this._baseDtsInited = false;
     this._audioNextPts = void 0;
     this._videoNextDts = void 0;
@@ -6853,6 +6939,8 @@ var TsFixer = /* @__PURE__ */ function() {
     this._lastAudioExceptionGapDot = 0;
     this._lastAudioExceptionOverlapDot = 0;
     this._lastAudioExceptionLargeGapDot = 0;
+    this._needForceFixLargeGap = fixerConfig === null || fixerConfig === void 0 ? void 0 : fixerConfig.forceFixLargeGap;
+    this._largeGapThreshold = (fixerConfig === null || fixerConfig === void 0 ? void 0 : fixerConfig.largeGapThreshold) || LARGE_AV_FIRST_FRAME_FORCE_FIX_THRESHOLD;
   }
   _createClass(TsFixer2, [{
     key: "fix",
@@ -6880,10 +6968,16 @@ var TsFixer = /* @__PURE__ */ function() {
       if (discontinuity) {
         this._calculateBaseDts(this.audioTrack, this.videoTrack);
         this._baseDts -= startTime;
+        this._baseAudioDts -= startTime;
+        this._baseVideoDts -= startTime;
       }
       if (!contiguous) {
         this._videoNextDts = vaDelta > 0 ? startTime + vaDelta : startTime;
         this._audioNextPts = vaDelta > 0 ? startTime : startTime - vaDelta;
+        if (this._needForceFixLargeGap) {
+          this._videoNextDts = 0;
+          this._audioNextPts = 0;
+        }
         var vDeltaToNextDts = firstVideoSample ? firstVideoSample.dts - this._baseDts - this._videoNextDts : 0;
         var aDeltaToNextDts = firstAudioSample ? firstAudioSample.pts - this._baseDts - this._audioNextPts : 0;
         if (Math.abs(vDeltaToNextDts || aDeltaToNextDts) > MAX_VIDEO_FRAME_DURATION) {
@@ -6916,8 +7010,8 @@ var TsFixer = /* @__PURE__ */ function() {
       if (!samples.length)
         return;
       samples.forEach(function(x) {
-        x.dts -= _this2._baseDts;
-        x.pts -= _this2._baseDts;
+        x.dts -= _this2._needForceFixLargeGap ? _this2._baseVideoDts : _this2._baseDts;
+        x.pts -= _this2._needForceFixLargeGap ? _this2._baseVideoDts : _this2._baseDts;
       });
       if (this._videoNextDts === void 0) {
         var samp0 = samples[0];
@@ -7010,7 +7104,7 @@ var TsFixer = /* @__PURE__ */ function() {
       if (!samples.length)
         return;
       samples.forEach(function(x) {
-        x.pts -= _this3._baseDts;
+        x.pts -= _this3._needForceFixLargeGap ? _this3._baseAudioDts : _this3._baseDts;
         x.dts = x.pts;
       });
       this._doFixAudioInternal(audioTrack, samples, 9e4);
@@ -7027,12 +7121,15 @@ var TsFixer = /* @__PURE__ */ function() {
       var videoBaseDts = Infinity;
       if (audioSamps.length) {
         audioTrack.baseDts = audioBasePts = audioSamps[0].pts;
+        this._baseAudioDts = audioBasePts;
       }
       if (videoSamps.length) {
         videoTrack.baseDts = videoBaseDts = videoSamps[0].dts;
+        this._baseVideoDts = videoBaseDts;
       }
       this._baseDts = Math.min(audioBasePts, videoBaseDts);
       var delta = videoBaseDts - audioBasePts;
+      var largeGap = false;
       if (Number.isFinite(delta) && Math.abs(delta) > LARGE_AV_FIRST_FRAME_GAP) {
         videoTrack.warnings.push({
           type: WarningType.LARGE_AV_SHIFT,
@@ -7042,6 +7139,16 @@ var TsFixer = /* @__PURE__ */ function() {
           delta
         });
       }
+      if (Number.isFinite(delta) && Math.abs(delta) > this._largeGapThreshold * MAX_SILENT_FRAME_DURATION) {
+        largeGap = true;
+      }
+      if (!this._baseDtsInited) {
+        if (largeGap && this._needForceFixLargeGap) {
+          this._needForceFixLargeGap = true;
+        } else {
+          this._needForceFixLargeGap = false;
+        }
+      }
       this._baseDtsInited = true;
       return true;
     }
@@ -7135,6 +7242,7 @@ var TsFixer = /* @__PURE__ */ function() {
 var logger$4 = new Logger$1("TsDemuxer");
 var TsDemuxer = /* @__PURE__ */ function() {
   function TsDemuxer2(videoTrack, audioTrack, metadataTrack) {
+    var fixerConfig = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
     _classCallCheck(this, TsDemuxer2);
     _defineProperty(this, "_pmtId", -1);
     _defineProperty(this, "_remainingPacketData", null);
@@ -7144,7 +7252,7 @@ var TsDemuxer = /* @__PURE__ */ function() {
     this.videoTrack = videoTrack || new VideoTrack();
     this.audioTrack = audioTrack || new AudioTrack();
     this.metadataTrack = metadataTrack || new MetadataTrack();
-    this._fixer = new TsFixer(this.videoTrack, this.audioTrack, this.metadataTrack);
+    this._fixer = new TsFixer(this.videoTrack, this.audioTrack, this.metadataTrack, fixerConfig);
   }
   _createClass(TsDemuxer2, [{
     key: "demux",
@@ -7491,6 +7599,207 @@ var TsDemuxer = /* @__PURE__ */ function() {
   }]);
   return TsDemuxer2;
 }();
+var ByteReader = /* @__PURE__ */ function() {
+  function ByteReader2(buf, offset, len) {
+    _classCallCheck(this, ByteReader2);
+    this.dv = new DataView(buf);
+    this.start = this.offset = offset || this.dv.byteOffset;
+    this.end = len ? this.start + len : this.start + this.dv.byteLength;
+  }
+  _createClass(ByteReader2, [{
+    key: "buffer",
+    get: function get() {
+      return this.dv.buffer;
+    }
+  }, {
+    key: "unreadLength",
+    get: function get() {
+      return Math.max(this.end - this.offset, 0);
+    }
+  }, {
+    key: "size",
+    get: function get() {
+      return this.end - this.start;
+    }
+  }, {
+    key: "readFloat",
+    value: function readFloat(byteNum) {
+      var val = 0;
+      switch (byteNum) {
+        case 4:
+          val = this.dv.getFloat32(this.offset);
+          break;
+        case 8:
+          val = this.dv.getFloat64(this.offset);
+          break;
+        default:
+          throw new Error("read ".concat(byteNum, "-byte float is not supported"));
+      }
+      this.offset += byteNum;
+      return val;
+    }
+  }, {
+    key: "back",
+    value: function back(byteNum) {
+      this.offset -= byteNum;
+    }
+  }, {
+    key: "skip",
+    value: function skip(byteNum) {
+      this.offset += byteNum;
+    }
+  }, {
+    key: "readInt",
+    value: function readInt(byteNum) {
+      var offset = this.offset;
+      this.offset += byteNum;
+      switch (byteNum) {
+        case 1:
+          return this.dv.getInt8(offset);
+        case 2:
+          return this.dv.getInt16(offset);
+        case 4:
+          return this.dv.getInt32(offset);
+        default:
+          throw new Error("read ".concat(byteNum, "-byte integers is not supported"));
+      }
+    }
+  }, {
+    key: "read",
+    value: function read(byteNum) {
+      var offset = this.offset;
+      this.offset += byteNum;
+      switch (byteNum) {
+        case 1:
+          return this.dv.getUint8(offset);
+        case 2:
+          return this.dv.getUint16(offset);
+        case 3:
+          return (this.dv.getUint16(offset) << 8) + this.dv.getUint8(offset + 2);
+        case 4:
+          return this.dv.getUint32(offset);
+        default:
+          this.back(byteNum - 4);
+          return this.read(byteNum - 4) + this.dv.getUint32(offset) * Math.pow(256, byteNum - 4);
+      }
+    }
+  }, {
+    key: "write",
+    value: function write(byteNum, val) {
+      var offset = this.offset;
+      this.offset += byteNum;
+      switch (byteNum) {
+        case 1:
+          return this.dv.setUint8(offset, val);
+        case 2:
+          return this.dv.setUint16(offset, val);
+        case 3:
+          return this.dv.setUint8(offset, val >>> 16), this.dv.setUint16(offset + 1, 65535 & val);
+        case 4:
+          return this.dv.setUint32(offset, val);
+        default:
+          throw new Error("write ".concat(byteNum, "-byte integers is not supported"));
+      }
+    }
+  }, {
+    key: "readToBuffer",
+    value: function readToBuffer(len) {
+      var buffer;
+      if (this.offset || len) {
+        buffer = this.dv.buffer.slice(this.offset, len ? this.offset + len : this.end);
+      } else {
+        buffer = this.dv.buffer;
+      }
+      this.offset += buffer.byteLength;
+      return buffer;
+    }
+  }, {
+    key: "readToUint8",
+    value: function readToUint8(len) {
+      var uint8 = new Uint8Array(this.dv.buffer, this.offset, len || this.unreadLength);
+      this.offset += uint8.byteLength;
+      return uint8;
+    }
+  }, {
+    key: "readString",
+    value: function readString(len) {
+      var i = 0, str = "";
+      for (; i < len; i++) {
+        str += String.fromCharCode(this.dv.getUint8(this.offset));
+        this.offset++;
+      }
+      return str;
+    }
+  }], [{
+    key: "fromUint8",
+    value: function fromUint8(uint8) {
+      return new ByteReader2(uint8.buffer, uint8.byteOffset, uint8.byteLength);
+    }
+  }, {
+    key: "concatUint8s",
+    value: function concatUint8s(args) {
+      var uint8 = new Uint8Array(args.reduce(function(ret, v) {
+        return ret + v.byteLength;
+      }, 0));
+      var offset = 0;
+      args.forEach(function(v) {
+        uint8.set(v, offset);
+        offset += v.byteLength;
+      });
+      return uint8;
+    }
+  }, {
+    key: "concatUint8",
+    value: function concatUint8() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return this.concatUint8s(args);
+    }
+  }]);
+  return ByteReader2;
+}();
+var BitReader = /* @__PURE__ */ function() {
+  function BitReader2(val, size) {
+    _classCallCheck(this, BitReader2);
+    this.offset = 0;
+    this.val = val;
+    this.size = size;
+  }
+  _createClass(BitReader2, [{
+    key: "skip",
+    value: function skip(len) {
+      this.offset += len;
+    }
+  }, {
+    key: "read",
+    value: function read(len) {
+      var unreadLength = this.size - this.offset - len;
+      if (unreadLength >= 0) {
+        var bits = 0, i = 0;
+        this.offset += len;
+        if (this.size > 31) {
+          for (; i < len; i++) {
+            bits += Math.pow(2, i);
+          }
+          return this.val / Math.pow(2, unreadLength) & bits;
+        } else {
+          for (; i < len; i++) {
+            bits += 1 << i;
+          }
+          return this.val >>> unreadLength & bits;
+        }
+      }
+      throw new Error("the number of the read operation exceeds the total length limit of bits");
+    }
+  }], [{
+    key: "fromByte",
+    value: function fromByte(byte, len) {
+      return new BitReader2(byte.read(len), len << 3);
+    }
+  }]);
+  return BitReader2;
+}();
 var MP4Parser = /* @__PURE__ */ function() {
   function MP4Parser2() {
     _classCallCheck(this, MP4Parser2);
@@ -7648,18 +7957,36 @@ var MP4Parser = /* @__PURE__ */ function() {
     key: "tkhd",
     value: function tkhd(box) {
       return parseBox(box, true, function(ret, data) {
-        var start = 0;
+        var byte = ByteReader.fromUint8(data);
         if (ret.version === 1) {
-          ret.trackId = readBig32(data, 16);
-          ret.duration = readBig64(data, 24);
-          start += 32;
+          byte.read(8);
+          byte.read(8);
+          ret.trackId = byte.read(4);
+          byte.read(4);
+          ret.duration = byte.read(8);
         } else {
-          ret.trackId = readBig32(data, 8);
-          ret.duration = readBig32(data, 16);
-          start += 20;
+          byte.read(4);
+          byte.read(4);
+          ret.trackId = byte.read(4);
+          byte.read(4);
+          ret.duration = byte.read(4);
+        }
+        byte.skip(16);
+        ret.matrix = [];
+        for (var i = 0; i < 36; i++) {
+          ret.matrix.push(byte.read(1));
+        }
+        byte.back(36);
+        var caculatedMatrix = [];
+        for (var _i = 0, int32; _i < 3; _i++) {
+          caculatedMatrix.push(combineToFloat(byte.readInt(2), byte.readInt(2)));
+          caculatedMatrix.push(combineToFloat(byte.readInt(2), byte.readInt(2)));
+          int32 = byte.readInt(4);
+          caculatedMatrix.push(combineToFloat(int32 >> 30, int32 & 1073741823));
         }
-        ret.width = readBig32(data, start + 52);
-        ret.height = readBig32(data, start + 56);
+        ret.rotation = toDegree(caculatedMatrix);
+        ret.width = byte.read(4);
+        ret.height = byte.read(4);
       });
     }
   }, {
@@ -7789,7 +8116,7 @@ var MP4Parser = /* @__PURE__ */ function() {
         if (ret.version > 0) {
           var numKeyIds = readBig32(data, start);
           start += 4;
-          for (var _i = 0; _i < ("" + numKeyIds).length; _i++) {
+          for (var _i2 = 0; _i2 < ("" + numKeyIds).length; _i2++) {
             for (var j = 0; j < 16; j++) {
               var keyId = data[start];
               start += 1;
@@ -7812,6 +8139,8 @@ var MP4Parser = /* @__PURE__ */ function() {
         ret.entryCount = readBig32(data);
         ret.entries = MP4Parser2.findBox(data.subarray(4), [], start + 4).map(function(b) {
           switch (b.type) {
+            case "av01":
+              return MP4Parser2.av01(b);
             case "avc1":
             case "avc2":
             case "avc3":
@@ -7891,6 +8220,69 @@ var MP4Parser = /* @__PURE__ */ function() {
         }
       });
     }
+  }, {
+    key: "colr",
+    value: function colr(box) {
+      return parseBox(box, false, function(ret, data) {
+        var byte = ByteReader.fromUint8(data);
+        ret.data = box.data;
+        ret.colorType = byte.readString(4);
+        if (ret.colorType === "nclx") {
+          ret.colorPrimaries = byte.read(2);
+          ret.transferCharacteristics = byte.read(2);
+          ret.matrixCoefficients = byte.read(2);
+          ret.fullRangeFlag = byte.read(1) >> 7;
+        } else if (ret.colorType === "rICC" || ret.colorType === "prof") {
+          ret.iccProfile = data.readToUint8();
+        }
+      });
+    }
+  }, {
+    key: "av01",
+    value: function av01(box) {
+      return parseBox(box, false, function(ret, data, start) {
+        var bodyStart = parseVisualSampleEntry(ret, data);
+        var bodyData = data.subarray(bodyStart);
+        start += bodyStart;
+        ret.av1C = MP4Parser2.av1C(MP4Parser2.findBox(bodyData, ["av1C"], start)[0]);
+        ret.colr = MP4Parser2.colr(MP4Parser2.findBox(bodyData, ["colr"], start)[0]);
+      });
+    }
+  }, {
+    key: "av1C",
+    value: function av1C(box) {
+      return parseBox(box, false, function(ret, data) {
+        ret.data = box.data;
+        var byte = ByteReader.fromUint8(data);
+        var bit = BitReader.fromByte(byte, 4);
+        ret.marker = bit.read(1);
+        ret.version = bit.read(7);
+        ret.seqProfile = bit.read(3);
+        ret.seqLevelIdx0 = bit.read(5);
+        ret.seqTier0 = bit.read(1);
+        ret.highBitdepth = bit.read(1);
+        ret.twelveBit = bit.read(1);
+        ret.monochrome = bit.read(1);
+        ret.chromaSubsamplingX = bit.read(1);
+        ret.chromaSubsamplingY = bit.read(1);
+        ret.chromaSamplePosition = bit.read(2);
+        ret.reserved = bit.read(3);
+        ret.initialPresentationDelayPresent = bit.read(1);
+        if (ret.initialPresentationDelayPresent) {
+          ret.initialPresentationDelayMinusOne = bit.read(4);
+        } else {
+          ret.initialPresentationDelayMinusOne = 0;
+        }
+        ret.configOBUs = byte.readToUint8();
+        var bitdepth;
+        if (ret.seqLevelIdx0 === 2 && ret.highBitdepth === 1) {
+          bitdepth = ret.twelveBit === 1 ? "12" : "10";
+        } else if (ret.seqProfile <= 2) {
+          bitdepth = ret.highBitdepth === 1 ? "10" : "08";
+        }
+        ret.codec = ["av01", ret.seqProfile, (ret.seqLevelIdx0 < 10 ? "0" + ret.seqLevelIdx0 : ret.seqLevelIdx0) + (ret.seqTier0 ? "H" : "M"), bitdepth].join(".");
+      });
+    }
   }, {
     key: "avc1",
     value: function avc1(box) {
@@ -7925,7 +8317,7 @@ var MP4Parser = /* @__PURE__ */ function() {
         ret.ppsLength = data[start];
         start += 1;
         ret.pps = [];
-        for (var _i2 = 0; _i2 < ret.ppsLength; _i2++) {
+        for (var _i3 = 0; _i3 < ret.ppsLength; _i3++) {
           var _size = readBig16(data, start);
           start += 2;
           ret.pps.push(data.subarray(start, start += _size));
@@ -8094,7 +8486,7 @@ var MP4Parser = /* @__PURE__ */ function() {
             start += 8;
           }
         } else {
-          for (var _i3 = 0; _i3 < entryCount; _i3++) {
+          for (var _i4 = 0; _i4 < entryCount; _i4++) {
             entries.push({
               count: readBig32(data, start),
               offset: -(~readBig32(data, start + 4) + 1)
@@ -8316,13 +8708,20 @@ var MP4Parser = /* @__PURE__ */ function() {
         v.mvhdTimecale = moov.mvhd.timescale;
         v.timescale = v.formatTimescale = vTrack.mdia.mdhd.timescale;
         v.duration = vTrack.mdia.mdhd.duration || v.mvhdDurtion / v.mvhdTimecale * v.timescale;
+        v.rotation = vTrack.tkhd.rotation;
+        v.matrix = vTrack.tkhd.matrix;
         var e1 = vTrack.mdia.minf.stbl.stsd.entries[0];
         v.width = e1.width;
         v.height = e1.height;
         if (e1.pasp) {
           v.sarRatio = [e1.pasp.hSpacing, e1.pasp.vSpacing];
         }
-        if (e1.hvcC) {
+        if (e1.av1C) {
+          v.codecType = VideoCodecType.AV1;
+          v.codec = e1.av1C.codec;
+          v.av1C = e1.av1C.data;
+          v.colr = e1.colr.data;
+        } else if (e1.hvcC) {
           v.codecType = VideoCodecType.HEVC;
           v.codec = e1.hvcC.codec;
           v.vps = e1.hvcC.vps;
@@ -8641,8 +9040,9 @@ function parseAudioSampleEntry(ret, data) {
 function parseBox(box, isFullBox, parse3) {
   if (!box)
     return;
-  if (box.size !== box.data.length)
+  if (box.size !== box.data.length) {
     throw new Error("box ".concat(box.type, " size !== data.length"));
+  }
   var ret = {
     start: box.start,
     size: box.size,
@@ -8681,11 +9081,167 @@ var toHex = function toHex2() {
 var FMP4Demuxer = /* @__PURE__ */ function() {
   function FMP4Demuxer2(videoTrack, audioTrack, metadataTrack) {
     _classCallCheck(this, FMP4Demuxer2);
+    _defineProperty(this, "__loadedMoofWraps", []);
+    _defineProperty(this, "__lastRemainData", null);
+    _defineProperty(this, "__lastRemainDataStart", 0);
+    _defineProperty(this, "__nextMoofStart", -1);
     this.videoTrack = videoTrack || new VideoTrack();
     this.audioTrack = audioTrack || new AudioTrack();
     this.metadataTrack = metadataTrack || new MetadataTrack();
   }
   _createClass(FMP4Demuxer2, [{
+    key: "demuxPart",
+    value: function demuxPart(partData, partDataStart, moov) {
+      var _this = this;
+      var videoTrack = this.videoTrack, audioTrack = this.audioTrack;
+      var videoExist = videoTrack.exist();
+      var audioExist = audioTrack.exist();
+      var isAV01 = /av01/.test(videoTrack.codec);
+      videoTrack.samples = [];
+      audioTrack.samples = [];
+      var data = partData;
+      var dataStart = partDataStart;
+      if (this.__lastRemainData) {
+        var lastRemainDataEnd = this.__lastRemainDataStart + this.__lastRemainData.byteLength;
+        var continuous = partDataStart <= lastRemainDataEnd && partDataStart > this.__lastRemainDataStart && partDataStart + partData.byteLength > lastRemainDataEnd;
+        if (continuous) {
+          var noDuplicateData = partData.subarray(this.__lastRemainData.byteLength + this.__lastRemainDataStart - partDataStart);
+          data = concatUint8Array(this.__lastRemainData, noDuplicateData);
+          dataStart = this.__lastRemainDataStart;
+          this.__lastRemainData = null;
+        } else {
+          this.__lastRemainData = null;
+          this.__lastRemainDataStart = 0;
+          this.__nextMoofStart = -1;
+        }
+      }
+      if (!moov) {
+        var moovBox = MP4Parser.findBox(data, ["moov"])[0];
+        if (!moovBox)
+          throw new Error("cannot found moov box");
+        moov = MP4Parser.moov(moovBox);
+      }
+      if (data) {
+        var dataEnd = dataStart + data.byteLength;
+        if (!videoExist && !audioExist) {
+          MP4Parser.moovToTrack(moov, videoTrack, audioTrack);
+        }
+        var moofBoxes = [];
+        if (this.__nextMoofStart < 0) {
+          MP4Parser.findBox(data, ["moof"], dataStart).forEach(function(v) {
+            return moofBoxes.push(v);
+          });
+        } else if (this.__nextMoofStart >= dataStart && this.__nextMoofStart <= dataEnd - 8) {
+          MP4Parser.findBox(data.subarray(this.__nextMoofStart - dataStart), ["moof"], this.__nextMoofStart).forEach(function(v) {
+            return moofBoxes.push(v);
+          });
+        }
+        moofBoxes.filter(function(moofBox) {
+          return moofBox.size <= moofBox.data.length;
+        }).forEach(function(moofBox) {
+          var moof = MP4Parser.moof(moofBox);
+          _this.__nextMoofStart = moof.start + Math.max.apply(Math, _toConsumableArray(moof.traf.map(function(v) {
+            return v.trun.samples.reduce(function(ret, w) {
+              return ret + w.size;
+            }, v.trun.dataOffset || 0);
+          })));
+          _this.__loadedMoofWraps.push({
+            start: moof.start,
+            nextMoofStart: _this.__nextMoofStart,
+            moof
+          });
+          _this.__loadedMoofWraps.sort(function(p, n) {
+            return p.start - n.start;
+          });
+        });
+        var _iterator = _createForOfIteratorHelper(this.__loadedMoofWraps), _step;
+        try {
+          var _loop = function _loop2() {
+            var moofWrap = _step.value;
+            if (moofWrap.start > dataEnd || moofWrap.nextMoofStart < dataStart) {
+              return "continue";
+            }
+            var moofStart = moofWrap.start;
+            var tracks = MP4Parser.moofToSamples(moofWrap.moof, videoTrack, audioTrack);
+            var videoBaseMediaDecodeTime = videoTrack.baseMediaDecodeTime;
+            var audioBaseMediaDecodeTime = audioTrack.baseMediaDecodeTime;
+            var nalSize;
+            Object.keys(tracks).forEach(function(k) {
+              if (videoTrack.id == k) {
+                tracks[k].some(function(x) {
+                  var xStart = x.offset += moofStart;
+                  if (xStart < dataStart) {
+                    return;
+                  }
+                  if (xStart + x.size > dataEnd) {
+                    return true;
+                  }
+                  var sample = new VideoSample((x.pts || x.dts) + videoBaseMediaDecodeTime, x.dts + videoBaseMediaDecodeTime);
+                  sample.duration = x.duration;
+                  sample.gopId = x.gopId;
+                  if (x.keyframe)
+                    sample.setToKeyframe();
+                  var sampleData = data.subarray(xStart - dataStart, xStart - dataStart + x.size);
+                  sample.data = sampleData;
+                  if (!isAV01) {
+                    var start = 0;
+                    var len = sampleData.length - 1;
+                    while (start < len) {
+                      nalSize = readBig32(sampleData, start);
+                      start += 4;
+                      sample.units.push(sampleData.subarray(start, start + nalSize));
+                      start += nalSize;
+                    }
+                  }
+                  _this.__lastRemainDataStart = xStart + x.size;
+                  videoTrack.samples.push(sample);
+                });
+              } else if (audioTrack.id == k) {
+                tracks[k].some(function(x) {
+                  var xStart = x.offset + moofStart;
+                  if (xStart < dataStart) {
+                    return;
+                  }
+                  if (xStart + x.size > dataEnd) {
+                    return true;
+                  }
+                  var sampleData = data.subarray(xStart - dataStart, xStart - dataStart + x.size);
+                  audioTrack.samples.push(new AudioSample(x.dts + audioBaseMediaDecodeTime, sampleData, x.duration));
+                  _this.__lastRemainDataStart = xStart + x.size;
+                });
+              }
+            });
+          };
+          for (_iterator.s(); !(_step = _iterator.n()).done; ) {
+            var _ret = _loop();
+            if (_ret === "continue")
+              continue;
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+      if (this.__lastRemainDataStart > dataStart && this.__lastRemainDataStart < data.byteLength + dataStart) {
+        this.__lastRemainData = data.subarray(this.__lastRemainDataStart - dataStart);
+      } else {
+        this.__lastRemainData = data;
+        this.__lastRemainDataStart = dataStart;
+      }
+      if (videoTrack.samples.length) {
+        videoTrack.baseMediaDecodeTime = videoTrack.samples[0].pts;
+      }
+      if (audioTrack.samples.length) {
+        audioTrack.baseMediaDecodeTime = audioTrack.samples[0].pts;
+      }
+      return {
+        videoTrack,
+        audioTrack,
+        metadataTrack: this.metadataTrack
+      };
+    }
+  }, {
     key: "demux",
     value: function demux(videoData, audioData) {
       var videoTrack = this.videoTrack, audioTrack = this.audioTrack;
@@ -9181,6 +9737,8 @@ var MP4 = /* @__PURE__ */ function() {
         }
       } else if (track.useEME && track.encv) {
         content = MP42.encv(track);
+      } else if (track.av1C) {
+        content = MP42.av01(track);
       } else {
         content = MP42.avc1hev1(track);
       }
@@ -9393,6 +9951,90 @@ var MP4 = /* @__PURE__ */ function() {
       var schi = MP42.schi(data);
       return MP42.box(MP42.types.sinf, content, MP42.box(MP42.types.frma, frma), MP42.box(MP42.types.schm, schm), schi);
     }
+  }, {
+    key: "av01",
+    value: function av01(track) {
+      return MP42.box(MP42.types.av01, new Uint8Array([
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        track.width >> 8 & 255,
+        track.width & 255,
+        track.height >> 8 & 255,
+        track.height & 255,
+        0,
+        72,
+        0,
+        0,
+        0,
+        72,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        24,
+        17,
+        17
+      ]), track.av1C, track.colr);
+    }
   }, {
     key: "avc1hev1",
     value: function avc1hev1(track) {
@@ -10365,7 +11007,7 @@ var MP4 = /* @__PURE__ */ function() {
   }]);
   return MP42;
 }();
-_defineProperty(MP4, "types", ["avc1", "avcC", "hvc1", "hvcC", "dinf", "dref", "esds", "ftyp", "hdlr", "mdat", "mdhd", "mdia", "mfhd", "minf", "moof", "moov", "mp4a", "mvex", "mvhd", "pasp", "stbl", "stco", "stsc", "stsd", "stsz", "stts", "tfdt", "tfhd", "traf", "trak", "trex", "tkhd", "vmhd", "smhd", "ctts", "stss", "styp", "pssh", "sidx", "sbgp", "saiz", "saio", "senc", "trun", "encv", "enca", "sinf", "btrt", "frma", "tenc", "schm", "schi", "mehd", "fiel", "sdtp"].reduce(function(p, c) {
+_defineProperty(MP4, "types", ["av01", "av1C", "avc1", "avcC", "hvc1", "hvcC", "dinf", "dref", "esds", "ftyp", "hdlr", "mdat", "mdhd", "mdia", "mfhd", "minf", "moof", "moov", "mp4a", "mvex", "mvhd", "pasp", "stbl", "stco", "stsc", "stsd", "stsz", "stts", "tfdt", "tfhd", "traf", "trak", "trex", "tkhd", "vmhd", "smhd", "ctts", "stss", "styp", "pssh", "sidx", "sbgp", "saiz", "saio", "senc", "trun", "encv", "enca", "sinf", "btrt", "frma", "tenc", "schm", "schi", "mehd", "fiel", "sdtp"].reduce(function(p, c) {
   p[c] = [c.charCodeAt(0), c.charCodeAt(1), c.charCodeAt(2), c.charCodeAt(3)];
   return p;
 }, /* @__PURE__ */ Object.create(null)));
@@ -10700,30 +11342,46 @@ var FMP4Remuxer = /* @__PURE__ */ function() {
         };
       }
       var samples = track.samples;
+      var isAV01 = /av01/.test(track.codec);
       var mdatSize = 0;
-      samples.forEach(function(s) {
-        mdatSize += s.units.reduce(function(t, c) {
-          return t + c.byteLength;
-        }, 0);
-        mdatSize += s.units.length * 4;
-      });
-      var mdata = new Uint8Array(mdatSize);
-      var mdatView = new DataView(mdata.buffer);
-      var _loop = function _loop2(_offset, _sample) {
-        _sample = samples[i];
-        var sampleSize = 0;
-        _sample.units.forEach(function(u) {
-          mdatView.setUint32(_offset, u.byteLength);
-          _offset += 4;
-          mdata.set(u, _offset);
-          _offset += u.byteLength;
-          sampleSize += 4 + u.byteLength;
+      if (isAV01) {
+        samples.forEach(function(s) {
+          mdatSize += s.data.byteLength;
         });
-        _sample.size = sampleSize;
-        offset = _offset, sample = _sample;
-      };
-      for (var i = 0, l = samples.length, offset = 0, sample; i < l; i++) {
-        _loop(offset, sample);
+      } else {
+        samples.forEach(function(s) {
+          mdatSize += s.units.reduce(function(t, c) {
+            return t + c.byteLength;
+          }, 0);
+          mdatSize += s.units.length * 4;
+        });
+      }
+      var mdata = new Uint8Array(mdatSize);
+      if (isAV01) {
+        for (var i = 0, l = samples.length, offset = 0, sample; i < l; i++) {
+          sample = samples[i];
+          mdata.set(sample.data, offset);
+          sample.size = sample.data.byteLength;
+          offset += sample.size;
+        }
+      } else {
+        var mdatView = new DataView(mdata.buffer);
+        var _loop = function _loop2(_offset2, _sample2) {
+          _sample2 = samples[_i];
+          var sampleSize = 0;
+          _sample2.units.forEach(function(u) {
+            mdatView.setUint32(_offset2, u.byteLength);
+            _offset2 += 4;
+            mdata.set(u, _offset2);
+            _offset2 += u.byteLength;
+            sampleSize += 4 + u.byteLength;
+          });
+          _sample2.size = sampleSize;
+          _offset = _offset2, _sample = _sample2;
+        };
+        for (var _i = 0, _l = samples.length, _offset = 0, _sample; _i < _l; _i++) {
+          _loop(_offset, _sample);
+        }
       }
       var mdat = MP4.mdat(mdata);
       var moof = MP4.moof([track]);
@@ -10882,11 +11540,11 @@ var Event$1 = _objectSpread2$2(_objectSpread2$2({}, EVENT), {}, {
 });
 var logger$3 = new Logger$2("Transmuxer");
 var Transmuxer = /* @__PURE__ */ function() {
-  function Transmuxer2(hls, isMP4, needRemux) {
+  function Transmuxer2(hls, isMP4, needRemux, fixerConfig) {
     _classCallCheck$3(this, Transmuxer2);
     _defineProperty$3(this, "_initSegmentId", "");
     this.hls = hls;
-    this._demuxer = isMP4 ? new FMP4Demuxer() : new TsDemuxer();
+    this._demuxer = isMP4 ? new FMP4Demuxer() : new TsDemuxer(null, null, null, fixerConfig);
     this._isMP4 = isMP4;
     if (needRemux)
       this._remuxer = new FMP4Remuxer(this._demuxer.videoTrack, this._demuxer.audioTrack);
@@ -11153,11 +11811,11 @@ var BufferService = /* @__PURE__ */ function() {
         return;
       if (TsDemuxer.probe(chunk)) {
         if (!this._transmuxer)
-          this._transmuxer = new Transmuxer(this.hls, false, !this._softVideo);
+          this._transmuxer = new Transmuxer(this.hls, false, !this._softVideo, this.hls.config.fixerConfig);
       } else if (MP4Parser.probe(chunk)) {
         if (this._softVideo) {
           if (!this._transmuxer)
-            this._transmuxer = new Transmuxer(this.hls, true);
+            this._transmuxer = new Transmuxer(this.hls, true, null, this.hls.config.fixerConfig);
         } else {
           this._directAppend = true;
           var mix = false;
@@ -11600,7 +12258,11 @@ function getConfig(cfg) {
     minSegmentsStartPlay: 3,
     preferMMS: false,
     preferMMSStreaming: false,
-    mseLowLatency: true
+    mseLowLatency: true,
+    fixerConfig: {
+      forceFixLargeGap: false,
+      largeGapThreshold: 5
+    }
   }, cfg), {}, {
     media
   });
@@ -11994,9 +12656,6 @@ function parseMediaPlaylist(lines, parentUrl, useLowLatency) {
   var endOfList = false;
   var partSegmentIndex = 0;
   while (line = lines[index++]) {
-    if (endOfList) {
-      break;
-    }
     if (line[0] !== "#") {
       if (media.lowLatency) {
         curSN++;
@@ -12050,11 +12709,6 @@ function parseMediaPlaylist(lines, parentUrl, useLowLatency) {
         break;
       case "ENDLIST":
         {
-          var _lastSegment = media.segments[media.segments.length - 1];
-          if (_lastSegment) {
-            _lastSegment.isLast = true;
-          }
-          media.live = false;
           endOfList = true;
         }
         break;
@@ -12158,11 +12812,14 @@ function parseMediaPlaylist(lines, parentUrl, useLowLatency) {
   });
   var lastSegment = media.segments[media.segments.length - 1];
   if (lastSegment) {
-    media.endSN = lastSegment.sn;
-    media.endPartIndex = lastSegment.partIndex;
-    if (endOfList && !lastSegment.isLast) {
+    if (endOfList) {
       lastSegment.isLast = true;
     }
+    media.endSN = lastSegment.sn;
+    media.endPartIndex = lastSegment.partIndex;
+  }
+  if (endOfList) {
+    media.live = false;
   }
   media.totalDuration = totalDuration;
   media.endCC = curCC;
@@ -13259,7 +13916,7 @@ var Hls = /* @__PURE__ */ function(_EventEmitter) {
     _defineProperty$3(_assertThisInitialized$2(_this), "_switchUrlOpts", null);
     _defineProperty$3(_assertThisInitialized$2(_this), "_isProcessQuotaExceeded", false);
     _defineProperty$3(_assertThisInitialized$2(_this), "_loadSegment", /* @__PURE__ */ _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee() {
-      var nextSeg, _assertThisInitialize, config, bInfo, bufferThroughout;
+      var _this$_playlist, nextSegment, lastSegment, _assertThisInitialize, config, minFrameDuration, maxBufferThroughout, bInfo, bufferThroughout;
       return _regeneratorRuntime$1().wrap(function _callee$(_context) {
         while (1)
           switch (_context.prev = _context.next) {
@@ -13270,42 +13927,44 @@ var Hls = /* @__PURE__ */ function(_EventEmitter) {
               }
               return _context.abrupt("return");
             case 2:
-              nextSeg = _this._playlist.nextSegment;
+              _this$_playlist = _this._playlist, nextSegment = _this$_playlist.nextSegment, lastSegment = _this$_playlist.lastSegment;
               _assertThisInitialize = _assertThisInitialized$2(_this), config = _assertThisInitialize.config;
-              if (nextSeg) {
-                _context.next = 6;
+              minFrameDuration = 0.016;
+              maxBufferThroughout = Math.min(Math.max((lastSegment === null || lastSegment === void 0 ? void 0 : lastSegment.duration) - minFrameDuration / 2 || 0, minFrameDuration), 0.1);
+              if (nextSegment) {
+                _context.next = 8;
                 break;
               }
               return _context.abrupt("return");
-            case 6:
+            case 8:
               if (_this.isLive) {
-                _context.next = 16;
+                _context.next = 18;
                 break;
               }
               bInfo = _this.bufferInfo();
               if (_this.media.paused && !_this.media.currentTime) {
                 bInfo = _this.bufferInfo(bInfo.nextStart || 0.5);
               }
-              bufferThroughout = Math.abs(bInfo.end - _this.media.duration) < 0.1;
+              bufferThroughout = Math.abs(bInfo.end - _this.media.duration) < maxBufferThroughout;
               if (!(bInfo.remaining >= config.preloadTime || bufferThroughout)) {
-                _context.next = 13;
+                _context.next = 15;
                 break;
               }
               _this._tryEos();
               return _context.abrupt("return");
-            case 13:
+            case 15:
               if (!(config.preferMMSStreaming && !_this._bufferService.msStreaming)) {
-                _context.next = 15;
+                _context.next = 17;
                 break;
               }
               return _context.abrupt("return");
-            case 15:
-              if (!_this._urlSwitching && _this._prevSegSn !== nextSeg.sn - 1 && bInfo.end && Math.abs(nextSeg.start - bInfo.end) > 1) {
+            case 17:
+              if (!_this._urlSwitching && _this._prevSegSn !== nextSegment.sn - 1 && bInfo.end && Math.abs(nextSegment.start - bInfo.end) > 1) {
                 _this._playlist.setNextSegmentByIndex(_this._playlist.findSegmentIndexByTime(bInfo.end + 0.1));
               }
-            case 16:
+            case 18:
               return _context.abrupt("return", _this._loadSegmentDirect());
-            case 17:
+            case 19:
             case "end":
               return _context.stop();
           }
@@ -14558,8 +15217,8 @@ var Hls = /* @__PURE__ */ function(_EventEmitter) {
     value: function _tryEos() {
       var _this$_bufferService3, _this$_bufferService4;
       var media = this.media;
-      var _this$_playlist = this._playlist, nextSegment = _this$_playlist.nextSegment, lastSegment = _this$_playlist.lastSegment;
-      var eosAllowed = !nextSegment && media.readyState && media.duration > 0 && ((_this$_bufferService3 = this._bufferService) === null || _this$_bufferService3 === void 0 ? void 0 : _this$_bufferService3.msIsOpened) && !((_this$_bufferService4 = this._bufferService) !== null && _this$_bufferService4 !== void 0 && _this$_bufferService4.msHasOpTasks);
+      var _this$_playlist2 = this._playlist, nextSegment = _this$_playlist2.nextSegment, lastSegment = _this$_playlist2.lastSegment;
+      var eosAllowed = (!nextSegment || lastSegment && Buffer$1.isBuffered(media, lastSegment.start + lastSegment.duration / 2)) && media.readyState && media.duration > 0 && ((_this$_bufferService3 = this._bufferService) === null || _this$_bufferService3 === void 0 ? void 0 : _this$_bufferService3.msIsOpened) && !((_this$_bufferService4 = this._bufferService) !== null && _this$_bufferService4 !== void 0 && _this$_bufferService4.msHasOpTasks);
       if (!eosAllowed) {
         return;
       }
@@ -14595,7 +15254,7 @@ var Hls = /* @__PURE__ */ function(_EventEmitter) {
   }]);
   return Hls2;
 }(EventEmitter);
-_defineProperty$3(Hls, "version", "3.0.19-rc.0");
+_defineProperty$3(Hls, "version", "3.0.20-rc.3");
 try {
   if (localStorage.getItem("xgd")) {
     Hls.enableLogger();