xgplayer-mp4-loader 0.0.1

package/es/loader.js

@@ -0,0 +1,715 @@
+import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
+import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import 'core-js/modules/es.array.find.js';
+import 'core-js/modules/es.array.slice.js';
+import _regeneratorRuntime from '@babel/runtime/regenerator';
+import { concatUint8Array, NetLoader } 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, moovToMeta, moovToSegments } from './utils.js';
+
+var _excluded = ["vid", "moovEnd", "segmentDuration", "cache", "maxDownloadInfoSize"];
+var MP4Loader = /*#__PURE__*/function () {
+  function MP4Loader(config) {
+    _classCallCheck(this, MP4Loader);
+
+    _defineProperty(this, "vid", '');
+
+    _defineProperty(this, "url", '');
+
+    _defineProperty(this, "meta", {});
+
+    _defineProperty(this, "downloadInfo", []);
+
+    _defineProperty(this, "videoSegments", []);
+
+    _defineProperty(this, "audioSegments", []);
+
+    _defineProperty(this, "cache", null);
+
+    _defineProperty(this, "_currentSegmentIndex", -1);
+
+    _defineProperty(this, "_currentLoadingSegmentIndex", -1);
+
+    _defineProperty(this, "_transformError", function (error) {
+      error.type = 'network';
+      return error;
+    });
+
+    this._config = getConfig(config);
+
+    var _this$_config = this._config,
+        vid = _this$_config.vid;
+        _this$_config.moovEnd;
+        _this$_config.segmentDuration;
+        var cache = _this$_config.cache;
+        _this$_config.maxDownloadInfoSize;
+        var rest = _objectWithoutProperties(_this$_config, _excluded);
+
+    this.cache = cache || new Cache();
+    this.vid = vid || rest.url;
+    this.url = rest.url;
+    rest.transformError = this._transformError;
+    this._loader = new NetLoader(rest);
+  }
+
+  _createClass(MP4Loader, [{
+    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,
+            _args = arguments;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                vid = _args.length > 1 && _args[1] !== undefined ? _args[1] : url;
+                moovEnd = _args.length > 2 ? _args[2] : undefined;
+                _context.next = 4;
+                return this.reset();
+
+              case 4:
+                if (url) this.url = url;
+                if (vid) this.vid = vid;
+                if (moovEnd) this._config.moovEnd = moovEnd;
+
+              case 7:
+              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: "loadMeta",
+    value: function () {
+      var _loadMeta = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(cache, moovEnd) {
+        var responses, res, moov, mdat, moovStart, parsedMoov, segments, videoSegments, audioSegments;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                responses = [];
+                _context3.next = 3;
+                return this._loadData([0, moovEnd || this._config.moovEnd], cache);
+
+              case 3:
+                res = _context3.sent;
+
+                if (res) {
+                  _context3.next = 6;
+                  break;
+                }
+
+                return _context3.abrupt("return");
+
+              case 6:
+                responses.push(res);
+                moov = MP4Parser.findBox(res.data, ['moov'])[0];
+
+                if (moov) {
+                  _context3.next = 22;
+                  break;
+                }
+
+                mdat = MP4Parser.findBox(res.data, ['mdat'])[0];
+
+                if (mdat) {
+                  _context3.next = 12;
+                  break;
+                }
+
+                throw new MediaError('cannot find moov or mdat box', res.data);
+
+              case 12:
+                moovStart = mdat.start + mdat.size;
+                _context3.next = 15;
+                return this._loadData([moovStart], cache);
+
+              case 15:
+                res = _context3.sent;
+
+                if (res) {
+                  _context3.next = 18;
+                  break;
+                }
+
+                return _context3.abrupt("return");
+
+              case 18:
+                responses.push(res);
+                moov = MP4Parser.findBox(res.data, ['moov'], moovStart)[0];
+
+                if (moov) {
+                  _context3.next = 22;
+                  break;
+                }
+
+                throw new MediaError('cannot find moov box', res.data);
+
+              case 22:
+                if (!(moov.size > moov.data.length)) {
+                  _context3.next = 30;
+                  break;
+                }
+
+                _context3.next = 25;
+                return this._loadData([res.data.length, moov.start + moov.size - 1], cache);
+
+              case 25:
+                res = _context3.sent;
+
+                if (res) {
+                  _context3.next = 28;
+                  break;
+                }
+
+                return _context3.abrupt("return");
+
+              case 28:
+                responses.push(res);
+                moov.data = concatUint8Array(moov.data, res.data);
+
+              case 30:
+                parsedMoov = MP4Parser.moov(moov);
+
+                if (parsedMoov) {
+                  _context3.next = 33;
+                  break;
+                }
+
+                throw new MediaError('cannot parse moov box', moov.data);
+
+              case 33:
+                segments = moovToSegments(parsedMoov, this._config.segmentDuration);
+
+                if (segments) {
+                  _context3.next = 36;
+                  break;
+                }
+
+                throw new MediaError('cannot parse segments', moov.data);
+
+              case 36:
+                this.meta = moovToMeta(parsedMoov);
+                videoSegments = segments.videoSegments, audioSegments = segments.audioSegments;
+                this.videoSegments = videoSegments;
+                this.audioSegments = audioSegments;
+                return _context3.abrupt("return", {
+                  meta: this.meta,
+                  videoSegments: videoSegments,
+                  audioSegments: audioSegments,
+                  responses: responses
+                });
+
+              case 41:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function loadMeta(_x3, _x4) {
+        return _loadMeta.apply(this, arguments);
+      }
+
+      return loadMeta;
+    }()
+  }, {
+    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: video,
+        audio: audio
+      };
+    }
+  }, {
+    key: "loadSegmentByTime",
+    value: function () {
+      var _loadSegmentByTime = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(time, cache) {
+        var changeCurrent,
+            _this$getSegmentByTim,
+            video,
+            audio,
+            _args4 = arguments;
+
+        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                changeCurrent = _args4.length > 2 && _args4[2] !== undefined ? _args4[2] : true;
+
+                if (this.isMetaLoaded) {
+                  _context4.next = 4;
+                  break;
+                }
+
+                _context4.next = 4;
+                return this.loadMeta(cache);
+
+              case 4:
+                _this$getSegmentByTim = this.getSegmentByTime(time), video = _this$getSegmentByTim.video, audio = _this$getSegmentByTim.audio;
+                return _context4.abrupt("return", this._loadSegment(video, audio, cache, changeCurrent));
+
+              case 6:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+
+      function loadSegmentByTime(_x5, _x6) {
+        return _loadSegmentByTime.apply(this, arguments);
+      }
+
+      return loadSegmentByTime;
+    }()
+  }, {
+    key: "loadNextSegment",
+    value: function () {
+      var _loadNextSegment = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(cache) {
+        var changeCurrent,
+            video,
+            audio,
+            _args5 = arguments;
+        return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                changeCurrent = _args5.length > 1 && _args5[1] !== undefined ? _args5[1] : true;
+
+                if (this.isMetaLoaded) {
+                  _context5.next = 4;
+                  break;
+                }
+
+                _context5.next = 4;
+                return this.loadMeta();
+
+              case 4:
+                video = this.videoSegments[this._currentSegmentIndex + 1];
+                audio = this.audioSegments[this._currentSegmentIndex + 1];
+                return _context5.abrupt("return", this._loadSegment(video, audio, cache, changeCurrent));
+
+              case 7:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
+
+      function loadNextSegment(_x7) {
+        return _loadNextSegment.apply(this, arguments);
+      }
+
+      return loadNextSegment;
+    }()
+  }, {
+    key: "preload",
+    value: function () {
+      var _preload = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(time) {
+        var _this = this;
+
+        var _this$getSegmentByTim2, video, audio, index, videos, audios, load;
+
+        return _regeneratorRuntime.wrap(function _callee7$(_context7) {
+          while (1) {
+            switch (_context7.prev = _context7.next) {
+              case 0:
+                if (this.isMetaLoaded) {
+                  _context7.next = 3;
+                  break;
+                }
+
+                _context7.next = 3;
+                return this.loadMeta(true);
+
+              case 3:
+                if (!(!time || time < 0)) {
+                  _context7.next = 5;
+                  break;
+                }
+
+                return _context7.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) {
+                  _context7.next = 9;
+                  break;
+                }
+
+                return _context7.abrupt("return");
+
+              case 9:
+                videos = this.videoSegments.slice(0, index);
+                audios = this.audioSegments.slice(0, index);
+
+                load = /*#__PURE__*/function () {
+                  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(i) {
+                    return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+                      while (1) {
+                        switch (_context6.prev = _context6.next) {
+                          case 0:
+                            if (!(i > index)) {
+                              _context6.next = 2;
+                              break;
+                            }
+
+                            return _context6.abrupt("return");
+
+                          case 2:
+                            _context6.next = 4;
+                            return _this._loadSegment(videos[i], audios[i], true, false);
+
+                          case 4:
+                            _context6.next = 6;
+                            return load(i + 1);
+
+                          case 6:
+                          case "end":
+                            return _context6.stop();
+                        }
+                      }
+                    }, _callee6);
+                  }));
+
+                  return function load(_x9) {
+                    return _ref.apply(this, arguments);
+                  };
+                }();
+
+                _context7.next = 14;
+                return load(0);
+
+              case 14:
+              case "end":
+                return _context7.stop();
+            }
+          }
+        }, _callee7, this);
+      }));
+
+      function preload(_x8) {
+        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 _callee8() {
+        return _regeneratorRuntime.wrap(function _callee8$(_context8) {
+          while (1) {
+            switch (_context8.prev = _context8.next) {
+              case 0:
+                _context8.next = 2;
+                return this._loader.cancel();
+
+              case 2:
+                this.vid = this.url = '';
+                this.meta = {};
+                this.downloadInfo = [];
+                this.videoSegments = [];
+                this.audioSegments = [];
+                this._currentSegmentIndex = -1;
+                this._currentLoadingSegmentIndex = -1;
+
+              case 9:
+              case "end":
+                return _context8.stop();
+            }
+          }
+        }, _callee8, this);
+      }));
+
+      function reset() {
+        return _reset.apply(this, arguments);
+      }
+
+      return reset;
+    }()
+  }, {
+    key: "destroy",
+    value: function () {
+      var _destroy = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
+        return _regeneratorRuntime.wrap(function _callee9$(_context9) {
+          while (1) {
+            switch (_context9.prev = _context9.next) {
+              case 0:
+                _context9.next = 2;
+                return this.cancel();
+
+              case 2:
+                this.cache.clear();
+
+              case 3:
+              case "end":
+                return _context9.stop();
+            }
+          }
+        }, _callee9, this);
+      }));
+
+      function destroy() {
+        return _destroy.apply(this, arguments);
+      }
+
+      return destroy;
+    }()
+  }, {
+    key: "_loadSegment",
+    value: function () {
+      var _loadSegment2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee10(video, audio, cache, changeCurrent) {
+        var segIndex, res;
+        return _regeneratorRuntime.wrap(function _callee10$(_context10) {
+          while (1) {
+            switch (_context10.prev = _context10.next) {
+              case 0:
+                if (!(!video && !audio)) {
+                  _context10.next = 2;
+                  break;
+                }
+
+                return _context10.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;
+                _context10.prev = 4;
+                _context10.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);
+
+              case 7:
+                res = _context10.sent;
+
+              case 8:
+                _context10.prev = 8;
+                this._currentLoadingSegmentIndex = -1;
+                return _context10.finish(8);
+
+              case 11:
+                if (res) {
+                  _context10.next = 13;
+                  break;
+                }
+
+                return _context10.abrupt("return");
+
+              case 13:
+                if (changeCurrent) {
+                  this._currentSegmentIndex = segIndex;
+                }
+
+                res.video = video;
+                res.audio = audio;
+                return _context10.abrupt("return", res);
+
+              case 17:
+              case "end":
+                return _context10.stop();
+            }
+          }
+        }, _callee10, this, [[4,, 8, 11]]);
+      }));
+
+      function _loadSegment(_x10, _x11, _x12, _x13) {
+        return _loadSegment2.apply(this, arguments);
+      }
+
+      return _loadSegment;
+    }()
+  }, {
+    key: "_loadData",
+    value: function () {
+      var _loadData2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee11(range, cache) {
+        var cacheKey, data, res;
+        return _regeneratorRuntime.wrap(function _callee11$(_context11) {
+          while (1) {
+            switch (_context11.prev = _context11.next) {
+              case 0:
+                cacheKey = this._getCacheKey(range);
+                _context11.next = 3;
+                return this.cache.get(cacheKey);
+
+              case 3:
+                data = _context11.sent;
+
+                if (data) {
+                  _context11.next = 10;
+                  break;
+                }
+
+                _context11.next = 7;
+                return this._loader.load(this.url, {
+                  range: range
+                });
+
+              case 7:
+                res = _context11.sent;
+                _context11.next = 11;
+                break;
+
+              case 10:
+                res = {
+                  data: data,
+                  fromCache: true
+                };
+
+              case 11:
+                if (res) {
+                  _context11.next = 13;
+                  break;
+                }
+
+                return _context11.abrupt("return");
+
+              case 13:
+                if (!data) {
+                  this.downloadInfo.push({
+                    startTime: res.startTime,
+                    endTime: res.endTime,
+                    size: res.data.byteLength,
+                    range: range
+                  });
+
+                  if (this._addDownloadInfo > this._config.maxDownloadInfoSize) {
+                    this._downloadInfos = this.downloadInfo.slice(-this._config.maxDownloadInfoSize);
+                  }
+                }
+
+                if (!data && cache) {
+                  this.cache.set(cacheKey, res.data);
+                }
+
+                res.range = range;
+                return _context11.abrupt("return", res);
+
+              case 17:
+              case "end":
+                return _context11.stop();
+            }
+          }
+        }, _callee11, this);
+      }));
+
+      function _loadData(_x14, _x15) {
+        return _loadData2.apply(this, arguments);
+      }
+
+      return _loadData;
+    }()
+  }, {
+    key: "_getCacheKey",
+    value: function _getCacheKey(range) {
+      return (this.vid || this.url) + ':' + range;
+    }
+  }]);
+
+  return MP4Loader;
+}();
+
+export { MP4Loader };