xgplayer-mp4-loader 0.0.1-alpha.10

package/es/loader.js

@@ -0,0 +1,747 @@
+import { inherits as _inherits, createSuper as _createSuper, createClass as _createClass, classCallCheck as _classCallCheck, defineProperty as _defineProperty, assertThisInitialized as _assertThisInitialized, objectWithoutProperties as _objectWithoutProperties, asyncToGenerator as _asyncToGenerator, regeneratorRuntime as _regeneratorRuntime, slicedToArray as _slicedToArray, objectSpread2 as _objectSpread2 } from "./_virtual/_rollupPluginBabelHelpers.js";
+import "core-js/modules/es.array.find.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.array.slice.js";
+import { Logger, NetLoader, EVENT, concatUint8Array } from "xgplayer-streaming-shared";
+import { MP4Parser } from "xgplayer-transmuxer";
+import { getConfig } from "./config.js";
+import { MediaError } from "./error.js";
+import { Cache } from "./cache.js";
+import { isNumber, moovToSegments, moovToMeta } from "./utils.js";
+import EventEmitter from "eventemitter3";
+var _excluded = ["vid", "cache"];
+var MP4Loader = /* @__PURE__ */ function(_EventEmitter) {
+  _inherits(MP4Loader2, _EventEmitter);
+  var _super = _createSuper(MP4Loader2);
+  function MP4Loader2(config) {
+    var _this;
+    _classCallCheck(this, MP4Loader2);
+    _this = _super.call(this);
+    _defineProperty(_assertThisInitialized(_this), "vid", "");
+    _defineProperty(_assertThisInitialized(_this), "url", "");
+    _defineProperty(_assertThisInitialized(_this), "meta", {});
+    _defineProperty(_assertThisInitialized(_this), "downloadInfo", []);
+    _defineProperty(_assertThisInitialized(_this), "videoSegments", []);
+    _defineProperty(_assertThisInitialized(_this), "audioSegments", []);
+    _defineProperty(_assertThisInitialized(_this), "cache", null);
+    _defineProperty(_assertThisInitialized(_this), "_currentSegmentIndex", -1);
+    _defineProperty(_assertThisInitialized(_this), "_currentLoadingSegmentIndex", -1);
+    _defineProperty(_assertThisInitialized(_this), "buffer", void 0);
+    _defineProperty(_assertThisInitialized(_this), "_error", void 0);
+    _defineProperty(_assertThisInitialized(_this), "_transformError", function(error) {
+      return error;
+    });
+    _this._config = getConfig(config);
+    var _this$_config = _this._config, vid = _this$_config.vid, cache = _this$_config.cache, rest = _objectWithoutProperties(_this$_config, _excluded);
+    _this.cache = cache || new Cache();
+    _this.vid = vid || rest.url;
+    _this.url = rest.url;
+    rest.transformError = _this._transformError;
+    _this.logger = new Logger("MP4Loader_" + _this.vid);
+    !!config.openLog && Logger.enable();
+    rest.logger = _this.logger;
+    _this._loader = new NetLoader(rest);
+    _this._loader.on(EVENT.REAL_TIME_SPEED, function(data) {
+      _this.emit(EVENT.REAL_TIME_SPEED, data);
+    });
+    return _this;
+  }
+  _createClass(MP4Loader2, [{
+    key: "isMetaLoaded",
+    get: function get() {
+      return this.videoSegments.length || this.audioSegments.length;
+    }
+  }, {
+    key: "setCurrentSegment",
+    value: function setCurrentSegment(segIndex) {
+      if (isNumber(segIndex)) {
+        this._currentSegmentIndex = segIndex;
+      }
+    }
+  }, {
+    key: "isLastSegment",
+    value: function isLastSegment(segIndex) {
+      if (isNumber(segIndex)) {
+        var _this$videoSegments, _this$audioSegments;
+        var lastIndex = ((_this$videoSegments = this.videoSegments[this.videoSegments.length - 1]) === null || _this$videoSegments === void 0 ? void 0 : _this$videoSegments.index) || ((_this$audioSegments = this.audioSegments[this.audioSegments.length - 1]) === null || _this$audioSegments === void 0 ? void 0 : _this$audioSegments.index) || 0;
+        return segIndex >= lastIndex;
+      }
+      return false;
+    }
+  }, {
+    key: "isSegmentLoading",
+    value: function isSegmentLoading(segIndex) {
+      return segIndex === this._currentLoadingSegmentIndex;
+    }
+  }, {
+    key: "changeUrl",
+    value: function() {
+      var _changeUrl = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee(url) {
+        var vid, moovEnd, notCancelLoader, _args = arguments;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1)
+            switch (_context.prev = _context.next) {
+              case 0:
+                vid = _args.length > 1 && _args[1] !== void 0 ? _args[1] : url;
+                moovEnd = _args.length > 2 ? _args[2] : void 0;
+                notCancelLoader = _args.length > 3 ? _args[3] : void 0;
+                _context.next = 5;
+                return this.reset(notCancelLoader);
+              case 5:
+                if (url)
+                  this.url = url;
+                if (vid)
+                  this.vid = vid;
+                if (moovEnd)
+                  this._config.moovEnd = moovEnd;
+              case 8:
+              case "end":
+                return _context.stop();
+            }
+        }, _callee, this);
+      }));
+      function changeUrl(_x) {
+        return _changeUrl.apply(this, arguments);
+      }
+      return changeUrl;
+    }()
+  }, {
+    key: "getOrLoadMeta",
+    value: function() {
+      var _getOrLoadMeta = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee2(cache) {
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1)
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                if (this.isMetaLoaded) {
+                  _context2.next = 3;
+                  break;
+                }
+                _context2.next = 3;
+                return this.loadMeta(cache);
+              case 3:
+                return _context2.abrupt("return", this.meta);
+              case 4:
+              case "end":
+                return _context2.stop();
+            }
+        }, _callee2, this);
+      }));
+      function getOrLoadMeta(_x2) {
+        return _getOrLoadMeta.apply(this, arguments);
+      }
+      return getOrLoadMeta;
+    }()
+  }, {
+    key: "loadMetaProcess",
+    value: function() {
+      var _loadMetaProcess = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee4(cache, _ref, onProgress, config) {
+        var _this2 = this;
+        var _ref2, moovStart, moovEnd, OnProgressHandle;
+        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+          while (1)
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                _ref2 = _slicedToArray(_ref, 2), moovStart = _ref2[0], moovEnd = _ref2[1];
+                this._error = false;
+                this.logger.debug("[loadMetaProcess start], range,", [moovStart, moovEnd]);
+                OnProgressHandle = /* @__PURE__ */ function() {
+                  var _ref3 = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee3(data, state, options) {
+                    var moov, mdat, _moovStart, res, parsedMoov, segments, videoSegments, audioSegments;
+                    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+                      while (1)
+                        switch (_context3.prev = _context3.next) {
+                          case 0:
+                            if (_this2.meta && options !== null && options !== void 0 && options.range && options.range.length > 0 && options.range[1] >= moovEnd) {
+                              state = true;
+                              _this2.logger.debug("[loadMetaProcess],data done,setstate true,[", moovStart, moovEnd, "]");
+                            }
+                            if (state && options !== null && options !== void 0 && options.range && options.range.length > 0 && options.range[1] < moovEnd) {
+                              state = false;
+                              _this2.logger.debug("[loadMetaProcess],data not done,setstate false,[", moovStart, moovEnd, "]");
+                            }
+                            _this2.logger.debug("[loadMetaProcess],task,[", moovStart, moovEnd, "], range,", options.range, ",dataLen,", data ? data.byteLength : void 0, ", state,", state, ",err,", _this2._error);
+                            !_this2._error && data && data.byteLength > 0 && onProgress(data, state, options);
+                            if (!(_this2.meta.moov || _this2._error)) {
+                              _context3.next = 6;
+                              break;
+                            }
+                            return _context3.abrupt("return");
+                          case 6:
+                            if (!(data && data.byteLength > 0)) {
+                              _context3.next = 44;
+                              break;
+                            }
+                            _this2.buffer = concatUint8Array(_this2.buffer, data);
+                            moov = MP4Parser.findBox(_this2.buffer, ["moov"])[0];
+                            if (moov) {
+                              _context3.next = 23;
+                              break;
+                            }
+                            mdat = MP4Parser.findBox(_this2.buffer, ["mdat"])[0];
+                            if (!state) {
+                              _context3.next = 23;
+                              break;
+                            }
+                            if (mdat) {
+                              _context3.next = 18;
+                              break;
+                            }
+                            _this2._error = true;
+                            onProgress(null, state, options, {
+                              err: "cannot find moov or mdat box"
+                            });
+                            return _context3.abrupt("return");
+                          case 18:
+                            _moovStart = mdat.start + mdat.size;
+                            _context3.next = 21;
+                            return _this2.loadData([_moovStart, ""], cache, config);
+                          case 21:
+                            res = _context3.sent;
+                            if (res) {
+                              moov = MP4Parser.findBox(res.data, ["moov"])[0];
+                            }
+                          case 23:
+                            if (!(moov && state && moov.size > moov.data.length)) {
+                              _context3.next = 27;
+                              break;
+                            }
+                            _this2.logger.debug("[loadMetaProcess],moov not all, range,", options.range[1], ",dataLen,", _this2.buffer.byteLength, ", state,", state);
+                            _context3.next = 27;
+                            return _this2.loadMetaProcess(cache, [options.range[1], moov.start + moov.size - 1], onProgress);
+                          case 27:
+                            if (!(moov && moov.size <= moov.data.length && !_this2.meta.moov)) {
+                              _context3.next = 44;
+                              break;
+                            }
+                            parsedMoov = MP4Parser.moov(moov);
+                            if (parsedMoov) {
+                              _context3.next = 33;
+                              break;
+                            }
+                            _this2._error = true;
+                            onProgress(null, state, options, {
+                              err: "cannot parse moov box"
+                            });
+                            return _context3.abrupt("return");
+                          case 33:
+                            segments = moovToSegments(parsedMoov, _this2._config.segmentDuration);
+                            if (segments) {
+                              _context3.next = 38;
+                              break;
+                            }
+                            _this2._error = true;
+                            onProgress(null, state, options, {
+                              err: "cannot parse segments"
+                            });
+                            return _context3.abrupt("return");
+                          case 38:
+                            _this2.meta = moovToMeta(parsedMoov);
+                            videoSegments = segments.videoSegments, audioSegments = segments.audioSegments;
+                            _this2.videoSegments = videoSegments;
+                            _this2.audioSegments = audioSegments;
+                            _this2.logger.debug("[loadMetaProcess] moov ok");
+                            onProgress(void 0, state, {
+                              meta: {
+                                meta: _this2.meta,
+                                videoSegments,
+                                audioSegments
+                              }
+                            });
+                          case 44:
+                          case "end":
+                            return _context3.stop();
+                        }
+                    }, _callee3);
+                  }));
+                  return function OnProgressHandle2(_x7, _x8, _x9) {
+                    return _ref3.apply(this, arguments);
+                  };
+                }();
+                _context4.next = 6;
+                return this.loadData([moovStart, moovEnd || this._config.moovEnd], cache, _objectSpread2({
+                  onProgress: OnProgressHandle
+                }, config));
+              case 6:
+              case "end":
+                return _context4.stop();
+            }
+        }, _callee4, this);
+      }));
+      function loadMetaProcess(_x3, _x4, _x5, _x6) {
+        return _loadMetaProcess.apply(this, arguments);
+      }
+      return loadMetaProcess;
+    }()
+  }, {
+    key: "loadMeta",
+    value: function() {
+      var _loadMeta = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee5(cache, moovEnd, config) {
+        var res, responses, moov, mdat, moovStart, parsedMoov, segments, videoSegments, audioSegments, _args5 = arguments;
+        return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+          while (1)
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                res = _args5.length > 3 && _args5[3] !== void 0 ? _args5[3] : null;
+                responses = [];
+                this.logger.debug("[loadMeta start]");
+                if (res) {
+                  _context5.next = 7;
+                  break;
+                }
+                _context5.next = 6;
+                return this.loadData([0, moovEnd || this._config.moovEnd], cache, config);
+              case 6:
+                res = _context5.sent;
+              case 7:
+                if (res) {
+                  _context5.next = 9;
+                  break;
+                }
+                return _context5.abrupt("return");
+              case 9:
+                responses.push(res);
+                moov = MP4Parser.findBox(res.data, ["moov"])[0];
+                if (moov) {
+                  _context5.next = 25;
+                  break;
+                }
+                mdat = MP4Parser.findBox(res.data, ["mdat"])[0];
+                if (mdat) {
+                  _context5.next = 15;
+                  break;
+                }
+                throw new MediaError("cannot find moov or mdat box", res.data);
+              case 15:
+                moovStart = mdat.start + mdat.size;
+                _context5.next = 18;
+                return this.loadData([moovStart], cache, config);
+              case 18:
+                res = _context5.sent;
+                if (res) {
+                  _context5.next = 21;
+                  break;
+                }
+                return _context5.abrupt("return");
+              case 21:
+                responses.push(res);
+                moov = MP4Parser.findBox(res.data, ["moov"], moovStart)[0];
+                if (moov) {
+                  _context5.next = 25;
+                  break;
+                }
+                throw new MediaError("cannot find moov box", res.data);
+              case 25:
+                if (!(moov.size > moov.data.length)) {
+                  _context5.next = 33;
+                  break;
+                }
+                _context5.next = 28;
+                return this.loadData([res.data.length, moov.start + moov.size - 1], cache, config);
+              case 28:
+                res = _context5.sent;
+                if (res) {
+                  _context5.next = 31;
+                  break;
+                }
+                return _context5.abrupt("return");
+              case 31:
+                responses.push(res);
+                moov.data = concatUint8Array(moov.data, res.data);
+              case 33:
+                parsedMoov = MP4Parser.moov(moov);
+                if (parsedMoov) {
+                  _context5.next = 36;
+                  break;
+                }
+                throw new MediaError("cannot parse moov box", moov.data);
+              case 36:
+                segments = moovToSegments(parsedMoov, this._config.segmentDuration);
+                if (segments) {
+                  _context5.next = 39;
+                  break;
+                }
+                throw new MediaError("cannot parse segments", moov.data);
+              case 39:
+                this.meta = moovToMeta(parsedMoov);
+                videoSegments = segments.videoSegments, audioSegments = segments.audioSegments;
+                this.videoSegments = videoSegments;
+                this.audioSegments = audioSegments;
+                this.logger.debug("[load moov end!!!!!]");
+                return _context5.abrupt("return", {
+                  meta: this.meta,
+                  videoSegments,
+                  audioSegments,
+                  responses
+                });
+              case 45:
+              case "end":
+                return _context5.stop();
+            }
+        }, _callee5, this);
+      }));
+      function loadMeta(_x10, _x11, _x12) {
+        return _loadMeta.apply(this, arguments);
+      }
+      return loadMeta;
+    }()
+  }, {
+    key: "loadCacheMeta",
+    value: function loadCacheMeta(meta, segmentIndex) {
+      var moov = meta.moov;
+      var segments = moovToSegments(moov, this._config.segmentDuration);
+      var videoSegments = segments.videoSegments, audioSegments = segments.audioSegments;
+      this.videoSegments = videoSegments;
+      this.audioSegments = audioSegments;
+      this._currentSegmentIndex = segmentIndex;
+      this.meta = meta;
+    }
+  }, {
+    key: "getSegmentByTime",
+    value: function getSegmentByTime(time) {
+      var video;
+      var audio;
+      if (!this.videoSegments.length) {
+        audio = this.audioSegments.find(function(x) {
+          return x.startTime <= time && x.endTime > time;
+        });
+      } else {
+        video = this.videoSegments.find(function(x) {
+          return x.startTime <= time && x.endTime > time;
+        });
+        if (video) {
+          audio = this.audioSegments[video.index];
+        }
+      }
+      return {
+        video,
+        audio
+      };
+    }
+  }, {
+    key: "loadSegmentByTime",
+    value: function() {
+      var _loadSegmentByTime = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee6(time, cache) {
+        var changeCurrent, config, _this$getSegmentByTim, video, audio, _args6 = arguments;
+        return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+          while (1)
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                changeCurrent = _args6.length > 2 && _args6[2] !== void 0 ? _args6[2] : true;
+                config = _args6.length > 3 && _args6[3] !== void 0 ? _args6[3] : {};
+                if (this.isMetaLoaded) {
+                  _context6.next = 5;
+                  break;
+                }
+                _context6.next = 5;
+                return this.loadMeta(cache);
+              case 5:
+                _this$getSegmentByTim = this.getSegmentByTime(time), video = _this$getSegmentByTim.video, audio = _this$getSegmentByTim.audio;
+                return _context6.abrupt("return", this._loadSegment(video, audio, cache, changeCurrent, config));
+              case 7:
+              case "end":
+                return _context6.stop();
+            }
+        }, _callee6, this);
+      }));
+      function loadSegmentByTime(_x13, _x14) {
+        return _loadSegmentByTime.apply(this, arguments);
+      }
+      return loadSegmentByTime;
+    }()
+  }, {
+    key: "loadNextSegment",
+    value: function() {
+      var _loadNextSegment = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee7(cache) {
+        var changeCurrent, config, video, audio, _args7 = arguments;
+        return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+          while (1)
+            switch (_context7.prev = _context7.next) {
+              case 0:
+                changeCurrent = _args7.length > 1 && _args7[1] !== void 0 ? _args7[1] : true;
+                config = _args7.length > 2 && _args7[2] !== void 0 ? _args7[2] : {};
+                if (this.isMetaLoaded) {
+                  _context7.next = 5;
+                  break;
+                }
+                _context7.next = 5;
+                return this.loadMeta();
+              case 5:
+                video = this.videoSegments[this._currentSegmentIndex + 1];
+                audio = this.audioSegments[this._currentSegmentIndex + 1];
+                return _context7.abrupt("return", this._loadSegment(video, audio, cache, changeCurrent, config));
+              case 8:
+              case "end":
+                return _context7.stop();
+            }
+        }, _callee7, this);
+      }));
+      function loadNextSegment(_x15) {
+        return _loadNextSegment.apply(this, arguments);
+      }
+      return loadNextSegment;
+    }()
+  }, {
+    key: "preload",
+    value: function() {
+      var _preload = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee9(time) {
+        var _this3 = this;
+        var _this$getSegmentByTim2, video, audio, index, videos, audios, load;
+        return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+          while (1)
+            switch (_context9.prev = _context9.next) {
+              case 0:
+                if (this.isMetaLoaded) {
+                  _context9.next = 3;
+                  break;
+                }
+                _context9.next = 3;
+                return this.loadMeta(true);
+              case 3:
+                if (!(!time || time < 0)) {
+                  _context9.next = 5;
+                  break;
+                }
+                return _context9.abrupt("return");
+              case 5:
+                _this$getSegmentByTim2 = this.getSegmentByTime(time), video = _this$getSegmentByTim2.video, audio = _this$getSegmentByTim2.audio;
+                index = Math.max((video === null || video === void 0 ? void 0 : video.index) || 0, (audio === null || audio === void 0 ? void 0 : audio.index) || 0);
+                if (index) {
+                  _context9.next = 9;
+                  break;
+                }
+                return _context9.abrupt("return");
+              case 9:
+                videos = this.videoSegments.slice(0, index);
+                audios = this.audioSegments.slice(0, index);
+                load = /* @__PURE__ */ function() {
+                  var _ref4 = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee8(i) {
+                    return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+                      while (1)
+                        switch (_context8.prev = _context8.next) {
+                          case 0:
+                            if (!(i > index)) {
+                              _context8.next = 2;
+                              break;
+                            }
+                            return _context8.abrupt("return");
+                          case 2:
+                            _context8.next = 4;
+                            return _this3._loadSegment(videos[i], audios[i], true, false);
+                          case 4:
+                            _context8.next = 6;
+                            return load(i + 1);
+                          case 6:
+                          case "end":
+                            return _context8.stop();
+                        }
+                    }, _callee8);
+                  }));
+                  return function load2(_x17) {
+                    return _ref4.apply(this, arguments);
+                  };
+                }();
+                _context9.next = 14;
+                return load(0);
+              case 14:
+              case "end":
+                return _context9.stop();
+            }
+        }, _callee9, this);
+      }));
+      function preload(_x16) {
+        return _preload.apply(this, arguments);
+      }
+      return preload;
+    }()
+  }, {
+    key: "cancel",
+    value: function cancel() {
+      return this._loader.cancel();
+    }
+  }, {
+    key: "reset",
+    value: function() {
+      var _reset = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee10() {
+        var notCancelLoader, _args10 = arguments;
+        return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+          while (1)
+            switch (_context10.prev = _context10.next) {
+              case 0:
+                notCancelLoader = _args10.length > 0 && _args10[0] !== void 0 ? _args10[0] : false;
+                if (notCancelLoader) {
+                  _context10.next = 5;
+                  break;
+                }
+                this.logger.debug("[MP4loader reset func call loader.cancel]");
+                _context10.next = 5;
+                return this._loader.cancel();
+              case 5:
+                this.vid = this.url = "";
+                this.meta = {};
+                this.downloadInfo = [];
+                this.videoSegments = [];
+                this.audioSegments = [];
+                this._currentSegmentIndex = -1;
+                this._currentLoadingSegmentIndex = -1;
+              case 12:
+              case "end":
+                return _context10.stop();
+            }
+        }, _callee10, this);
+      }));
+      function reset() {
+        return _reset.apply(this, arguments);
+      }
+      return reset;
+    }()
+  }, {
+    key: "destroy",
+    value: function() {
+      var _destroy = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee11() {
+        return _regeneratorRuntime().wrap(function _callee11$(_context11) {
+          while (1)
+            switch (_context11.prev = _context11.next) {
+              case 0:
+                _context11.next = 2;
+                return this.reset();
+              case 2:
+                this.cache.clear();
+              case 3:
+              case "end":
+                return _context11.stop();
+            }
+        }, _callee11, this);
+      }));
+      function destroy() {
+        return _destroy.apply(this, arguments);
+      }
+      return destroy;
+    }()
+  }, {
+    key: "_loadSegment",
+    value: function() {
+      var _loadSegment2 = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee12(video, audio, cache, changeCurrent, config) {
+        var segIndex, res;
+        return _regeneratorRuntime().wrap(function _callee12$(_context12) {
+          while (1)
+            switch (_context12.prev = _context12.next) {
+              case 0:
+                if (!(!video && !audio)) {
+                  _context12.next = 2;
+                  break;
+                }
+                return _context12.abrupt("return");
+              case 2:
+                segIndex = (video === null || video === void 0 ? void 0 : video.index) || (audio === null || audio === void 0 ? void 0 : audio.index) || 0;
+                this._currentLoadingSegmentIndex = segIndex;
+                _context12.prev = 4;
+                _context12.next = 7;
+                return this.loadData([Math.min((video === null || video === void 0 ? void 0 : video.range[0]) || Infinity, (audio === null || audio === void 0 ? void 0 : audio.range[0]) || Infinity), Math.max((video === null || video === void 0 ? void 0 : video.range[1]) || 0, (audio === null || audio === void 0 ? void 0 : audio.range[1]) || 0)], cache, config);
+              case 7:
+                res = _context12.sent;
+              case 8:
+                _context12.prev = 8;
+                this._currentLoadingSegmentIndex = -1;
+                return _context12.finish(8);
+              case 11:
+                if (res) {
+                  _context12.next = 13;
+                  break;
+                }
+                return _context12.abrupt("return");
+              case 13:
+                if (changeCurrent) {
+                  this._currentSegmentIndex = segIndex;
+                }
+                res.video = video;
+                res.audio = audio;
+                return _context12.abrupt("return", res);
+              case 17:
+              case "end":
+                return _context12.stop();
+            }
+        }, _callee12, this, [[4, , 8, 11]]);
+      }));
+      function _loadSegment(_x18, _x19, _x20, _x21, _x22) {
+        return _loadSegment2.apply(this, arguments);
+      }
+      return _loadSegment;
+    }()
+  }, {
+    key: "loadData",
+    value: function() {
+      var _loadData = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee13(range, cache, config) {
+        var cacheKey, data, res, url;
+        return _regeneratorRuntime().wrap(function _callee13$(_context13) {
+          while (1)
+            switch (_context13.prev = _context13.next) {
+              case 0:
+                cacheKey = this._getCacheKey(range);
+                _context13.next = 3;
+                return this.cache.get(cacheKey);
+              case 3:
+                data = _context13.sent;
+                if (data) {
+                  _context13.next = 11;
+                  break;
+                }
+                url = config && config.url ? config.url : this.url;
+                _context13.next = 8;
+                return this._loader.load(url, _objectSpread2({
+                  range,
+                  vid: this.vid
+                }, config));
+              case 8:
+                res = _context13.sent;
+                _context13.next = 12;
+                break;
+              case 11:
+                res = {
+                  data,
+                  state: true,
+                  options: {
+                    fromCache: true,
+                    range,
+                    vid: this.vid
+                  }
+                };
+              case 12:
+                if (res) {
+                  _context13.next = 14;
+                  break;
+                }
+                return _context13.abrupt("return");
+              case 14:
+                if (!data) {
+                  res.data && this.downloadInfo.push({
+                    startTime: res.startTime,
+                    endTime: res.endTime,
+                    size: res.data.byteLength,
+                    range
+                  });
+                  if (this.downloadInfo && this.downloadInfo.length > this._config.maxDownloadInfoSize) {
+                    this.downloadInfo = this.downloadInfo.slice(-this._config.maxDownloadInfoSize);
+                  }
+                }
+                return _context13.abrupt("return", res);
+              case 17:
+              case "end":
+                return _context13.stop();
+            }
+        }, _callee13, this);
+      }));
+      function loadData(_x23, _x24, _x25) {
+        return _loadData.apply(this, arguments);
+      }
+      return loadData;
+    }()
+  }, {
+    key: "_getCacheKey",
+    value: function _getCacheKey(range) {
+      return (this.vid || this.url) + ":" + range;
+    }
+  }]);
+  return MP4Loader2;
+}(EventEmitter);
+export { MP4Loader };