pu428f3pz
/
NewEduCoderBuild
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'dev_local_v9_brain_cloud_competitions'
${ noResults }
NewEduCoderBuild/22761.151579b3.async.js

11016 lines
354 KiB
Raw Permalink Blame History

(self["webpackChunk"] = self["webpackChunk"] || []).push([[22761],{
/***/ 22761:
/*!*******************************************************************!*\
!*** ./node_modules/_flv.js@1.5.0@flv.js/src/flv.js + 38 modules ***!
\*******************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
"use strict";
// EXPORTS
__webpack_require__.d(__webpack_exports__, {
Z: function() { return /* binding */ flv; }
});
// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.23.6@@babel/runtime/helpers/typeof.js
var helpers_typeof = __webpack_require__(31468);
var typeof_default = /*#__PURE__*/__webpack_require__.n(helpers_typeof);
// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.23.6@@babel/runtime/helpers/classCallCheck.js
var classCallCheck = __webpack_require__(82100);
var classCallCheck_default = /*#__PURE__*/__webpack_require__.n(classCallCheck);
// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.23.6@@babel/runtime/helpers/createClass.js
var createClass = __webpack_require__(29186);
var createClass_default = /*#__PURE__*/__webpack_require__.n(createClass);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/utils/polyfill.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var Polyfill = /*#__PURE__*/function () {
function Polyfill() {
classCallCheck_default()(this, Polyfill);
}
createClass_default()(Polyfill, null, [{
key: "install",
value: function install() {
// ES6 Object.setPrototypeOf
Object.setPrototypeOf = Object.setPrototypeOf || function (obj, proto) {
obj.__proto__ = proto;
return obj;
};
// ES6 Object.assign
Object.assign = Object.assign || function (target) {
if (target === undefined || target === null) {
throw new TypeError('Cannot convert undefined or null to object');
}
var output = Object(target);
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
if (source !== undefined && source !== null) {
for (var key in source) {
if (source.hasOwnProperty(key)) {
output[key] = source[key];
}
}
}
}
return output;
};
// ES6 Promise (missing support in IE11)
if (typeof self.Promise !== 'function') {
(__webpack_require__(/*! es6-promise */ 3867).polyfill)();
}
}
}]);
return Polyfill;
}();
Polyfill.install();
/* harmony default export */ var polyfill = (Polyfill);
// EXTERNAL MODULE: ./node_modules/_events@3.3.0@events/events.js
var events = __webpack_require__(86204);
var events_default = /*#__PURE__*/__webpack_require__.n(events);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/utils/logger.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var logger_Log = /*#__PURE__*/function () {
function Log() {
classCallCheck_default()(this, Log);
}
createClass_default()(Log, null, [{
key: "e",
value: function e(tag, msg) {
if (!tag || Log.FORCE_GLOBAL_TAG) tag = Log.GLOBAL_TAG;
var str = "[".concat(tag, "] > ").concat(msg);
if (Log.ENABLE_CALLBACK) {
Log.emitter.emit('log', 'error', str);
}
if (!Log.ENABLE_ERROR) {
return;
}
if (console.error) {
console.error(str);
} else if (console.warn) {
console.warn(str);
} else {
console.log(str);
}
}
}, {
key: "i",
value: function i(tag, msg) {
if (!tag || Log.FORCE_GLOBAL_TAG) tag = Log.GLOBAL_TAG;
var str = "[".concat(tag, "] > ").concat(msg);
if (Log.ENABLE_CALLBACK) {
Log.emitter.emit('log', 'info', str);
}
if (!Log.ENABLE_INFO) {
return;
}
if (console.info) {
console.info(str);
} else {
console.log(str);
}
}
}, {
key: "w",
value: function w(tag, msg) {
if (!tag || Log.FORCE_GLOBAL_TAG) tag = Log.GLOBAL_TAG;
var str = "[".concat(tag, "] > ").concat(msg);
if (Log.ENABLE_CALLBACK) {
Log.emitter.emit('log', 'warn', str);
}
if (!Log.ENABLE_WARN) {
return;
}
if (console.warn) {
console.warn(str);
} else {
console.log(str);
}
}
}, {
key: "d",
value: function d(tag, msg) {
if (!tag || Log.FORCE_GLOBAL_TAG) tag = Log.GLOBAL_TAG;
var str = "[".concat(tag, "] > ").concat(msg);
if (Log.ENABLE_CALLBACK) {
Log.emitter.emit('log', 'debug', str);
}
if (!Log.ENABLE_DEBUG) {
return;
}
if (console.debug) {
console.debug(str);
} else {
console.log(str);
}
}
}, {
key: "v",
value: function v(tag, msg) {
if (!tag || Log.FORCE_GLOBAL_TAG) tag = Log.GLOBAL_TAG;
var str = "[".concat(tag, "] > ").concat(msg);
if (Log.ENABLE_CALLBACK) {
Log.emitter.emit('log', 'verbose', str);
}
if (!Log.ENABLE_VERBOSE) {
return;
}
console.log(str);
}
}]);
return Log;
}();
logger_Log.GLOBAL_TAG = 'flv.js';
logger_Log.FORCE_GLOBAL_TAG = false;
logger_Log.ENABLE_ERROR = true;
logger_Log.ENABLE_INFO = true;
logger_Log.ENABLE_WARN = true;
logger_Log.ENABLE_DEBUG = true;
logger_Log.ENABLE_VERBOSE = true;
logger_Log.ENABLE_CALLBACK = false;
logger_Log.emitter = new (events_default())();
/* harmony default export */ var logger = (logger_Log);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/io/speed-sampler.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// Utility class to calculate realtime network I/O speed
var SpeedSampler = /*#__PURE__*/function () {
function SpeedSampler() {
classCallCheck_default()(this, SpeedSampler);
// milliseconds
this._firstCheckpoint = 0;
this._lastCheckpoint = 0;
this._intervalBytes = 0;
this._totalBytes = 0;
this._lastSecondBytes = 0;
// compatibility detection
if (self.performance && self.performance.now) {
this._now = self.performance.now.bind(self.performance);
} else {
this._now = Date.now;
}
}
createClass_default()(SpeedSampler, [{
key: "reset",
value: function reset() {
this._firstCheckpoint = this._lastCheckpoint = 0;
this._totalBytes = this._intervalBytes = 0;
this._lastSecondBytes = 0;
}
}, {
key: "addBytes",
value: function addBytes(bytes) {
if (this._firstCheckpoint === 0) {
this._firstCheckpoint = this._now();
this._lastCheckpoint = this._firstCheckpoint;
this._intervalBytes += bytes;
this._totalBytes += bytes;
} else if (this._now() - this._lastCheckpoint < 1000) {
this._intervalBytes += bytes;
this._totalBytes += bytes;
} else {
// duration >= 1000
this._lastSecondBytes = this._intervalBytes;
this._intervalBytes = bytes;
this._totalBytes += bytes;
this._lastCheckpoint = this._now();
}
}
}, {
key: "currentKBps",
get: function get() {
this.addBytes(0);
var durationSeconds = (this._now() - this._lastCheckpoint) / 1000;
if (durationSeconds == 0) durationSeconds = 1;
return this._intervalBytes / durationSeconds / 1024;
}
}, {
key: "lastSecondKBps",
get: function get() {
this.addBytes(0);
if (this._lastSecondBytes !== 0) {
return this._lastSecondBytes / 1024;
} else {
// lastSecondBytes === 0
if (this._now() - this._lastCheckpoint >= 500) {
// if time interval since last checkpoint has exceeded 500ms
// the speed is nearly accurate
return this.currentKBps;
} else {
// We don't know
return 0;
}
}
}
}, {
key: "averageKBps",
get: function get() {
var durationSeconds = (this._now() - this._firstCheckpoint) / 1000;
return this._totalBytes / durationSeconds / 1024;
}
}]);
return SpeedSampler;
}();
/* harmony default export */ var speed_sampler = (SpeedSampler);
// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.23.6@@babel/runtime/helpers/inherits.js
var inherits = __webpack_require__(80619);
var inherits_default = /*#__PURE__*/__webpack_require__.n(inherits);
// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.23.6@@babel/runtime/helpers/createSuper.js
var createSuper = __webpack_require__(47074);
var createSuper_default = /*#__PURE__*/__webpack_require__.n(createSuper);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/utils/exception.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var exception_RuntimeException = /*#__PURE__*/function () {
function RuntimeException(message) {
classCallCheck_default()(this, RuntimeException);
this._message = message;
}
createClass_default()(RuntimeException, [{
key: "name",
get: function get() {
return 'RuntimeException';
}
}, {
key: "message",
get: function get() {
return this._message;
}
}, {
key: "toString",
value: function toString() {
return this.name + ': ' + this.message;
}
}]);
return RuntimeException;
}();
var IllegalStateException = /*#__PURE__*/function (_RuntimeException) {
inherits_default()(IllegalStateException, _RuntimeException);
var _super = createSuper_default()(IllegalStateException);
function IllegalStateException(message) {
classCallCheck_default()(this, IllegalStateException);
return _super.call(this, message);
}
createClass_default()(IllegalStateException, [{
key: "name",
get: function get() {
return 'IllegalStateException';
}
}]);
return IllegalStateException;
}(exception_RuntimeException);
var InvalidArgumentException = /*#__PURE__*/function (_RuntimeException2) {
inherits_default()(InvalidArgumentException, _RuntimeException2);
var _super2 = createSuper_default()(InvalidArgumentException);
function InvalidArgumentException(message) {
classCallCheck_default()(this, InvalidArgumentException);
return _super2.call(this, message);
}
createClass_default()(InvalidArgumentException, [{
key: "name",
get: function get() {
return 'InvalidArgumentException';
}
}]);
return InvalidArgumentException;
}(exception_RuntimeException);
var NotImplementedException = /*#__PURE__*/function (_RuntimeException3) {
inherits_default()(NotImplementedException, _RuntimeException3);
var _super3 = createSuper_default()(NotImplementedException);
function NotImplementedException(message) {
classCallCheck_default()(this, NotImplementedException);
return _super3.call(this, message);
}
createClass_default()(NotImplementedException, [{
key: "name",
get: function get() {
return 'NotImplementedException';
}
}]);
return NotImplementedException;
}(exception_RuntimeException);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/io/loader.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var loader_LoaderStatus = {
kIdle: 0,
kConnecting: 1,
kBuffering: 2,
kError: 3,
kComplete: 4
};
var loader_LoaderErrors = {
OK: 'OK',
EXCEPTION: 'Exception',
HTTP_STATUS_CODE_INVALID: 'HttpStatusCodeInvalid',
CONNECTING_TIMEOUT: 'ConnectingTimeout',
EARLY_EOF: 'EarlyEof',
UNRECOVERABLE_EARLY_EOF: 'UnrecoverableEarlyEof'
};
/* Loader has callbacks which have following prototypes:
* function onContentLengthKnown(contentLength: number): void
* function onURLRedirect(url: string): void
* function onDataArrival(chunk: ArrayBuffer, byteStart: number, receivedLength: number): void
* function onError(errorType: number, errorInfo: {code: number, msg: string}): void
* function onComplete(rangeFrom: number, rangeTo: number): void
*/
var loader_BaseLoader = /*#__PURE__*/function () {
function BaseLoader(typeName) {
classCallCheck_default()(this, BaseLoader);
this._type = typeName || 'undefined';
this._status = loader_LoaderStatus.kIdle;
this._needStash = false;
// callbacks
this._onContentLengthKnown = null;
this._onURLRedirect = null;
this._onDataArrival = null;
this._onError = null;
this._onComplete = null;
}
createClass_default()(BaseLoader, [{
key: "destroy",
value: function destroy() {
this._status = loader_LoaderStatus.kIdle;
this._onContentLengthKnown = null;
this._onURLRedirect = null;
this._onDataArrival = null;
this._onError = null;
this._onComplete = null;
}
}, {
key: "isWorking",
value: function isWorking() {
return this._status === loader_LoaderStatus.kConnecting || this._status === loader_LoaderStatus.kBuffering;
}
}, {
key: "type",
get: function get() {
return this._type;
}
}, {
key: "status",
get: function get() {
return this._status;
}
}, {
key: "needStashBuffer",
get: function get() {
return this._needStash;
}
}, {
key: "onContentLengthKnown",
get: function get() {
return this._onContentLengthKnown;
},
set: function set(callback) {
this._onContentLengthKnown = callback;
}
}, {
key: "onURLRedirect",
get: function get() {
return this._onURLRedirect;
},
set: function set(callback) {
this._onURLRedirect = callback;
}
}, {
key: "onDataArrival",
get: function get() {
return this._onDataArrival;
},
set: function set(callback) {
this._onDataArrival = callback;
}
}, {
key: "onError",
get: function get() {
return this._onError;
},
set: function set(callback) {
this._onError = callback;
}
}, {
key: "onComplete",
get: function get() {
return this._onComplete;
},
set: function set(callback) {
this._onComplete = callback;
}
// pure virtual
}, {
key: "open",
value: function open(dataSource, range) {
throw new NotImplementedException('Unimplemented abstract function!');
}
}, {
key: "abort",
value: function abort() {
throw new NotImplementedException('Unimplemented abstract function!');
}
}]);
return BaseLoader;
}();
// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.23.6@@babel/runtime/helpers/get.js
var get = __webpack_require__(4811);
var get_default = /*#__PURE__*/__webpack_require__.n(get);
// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.23.6@@babel/runtime/helpers/getPrototypeOf.js
var getPrototypeOf = __webpack_require__(34577);
var getPrototypeOf_default = /*#__PURE__*/__webpack_require__.n(getPrototypeOf);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/utils/browser.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var Browser = {};
function detect() {
// modified from jquery-browser-plugin
var ua = self.navigator.userAgent.toLowerCase();
var match = /(edge)\/([\w.]+)/.exec(ua) || /(opr)[\/]([\w.]+)/.exec(ua) || /(chrome)[ \/]([\w.]+)/.exec(ua) || /(iemobile)[\/]([\w.]+)/.exec(ua) || /(version)(applewebkit)[ \/]([\w.]+).*(safari)[ \/]([\w.]+)/.exec(ua) || /(webkit)[ \/]([\w.]+).*(version)[ \/]([\w.]+).*(safari)[ \/]([\w.]+)/.exec(ua) || /(webkit)[ \/]([\w.]+)/.exec(ua) || /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) || /(msie) ([\w.]+)/.exec(ua) || ua.indexOf('trident') >= 0 && /(rv)(?::| )([\w.]+)/.exec(ua) || ua.indexOf('compatible') < 0 && /(firefox)[ \/]([\w.]+)/.exec(ua) || [];
var platform_match = /(ipad)/.exec(ua) || /(ipod)/.exec(ua) || /(windows phone)/.exec(ua) || /(iphone)/.exec(ua) || /(kindle)/.exec(ua) || /(android)/.exec(ua) || /(windows)/.exec(ua) || /(mac)/.exec(ua) || /(linux)/.exec(ua) || /(cros)/.exec(ua) || [];
var matched = {
browser: match[5] || match[3] || match[1] || '',
version: match[2] || match[4] || '0',
majorVersion: match[4] || match[2] || '0',
platform: platform_match[0] || ''
};
var browser = {};
if (matched.browser) {
browser[matched.browser] = true;
var versionArray = matched.majorVersion.split('.');
browser.version = {
major: parseInt(matched.majorVersion, 10),
string: matched.version
};
if (versionArray.length > 1) {
browser.version.minor = parseInt(versionArray[1], 10);
}
if (versionArray.length > 2) {
browser.version.build = parseInt(versionArray[2], 10);
}
}
if (matched.platform) {
browser[matched.platform] = true;
}
if (browser.chrome || browser.opr || browser.safari) {
browser.webkit = true;
}
// MSIE. IE11 has 'rv' identifer
if (browser.rv || browser.iemobile) {
if (browser.rv) {
delete browser.rv;
}
var msie = 'msie';
matched.browser = msie;
browser[msie] = true;
}
// Microsoft Edge
if (browser.edge) {
delete browser.edge;
var msedge = 'msedge';
matched.browser = msedge;
browser[msedge] = true;
}
// Opera 15+
if (browser.opr) {
var opera = 'opera';
matched.browser = opera;
browser[opera] = true;
}
// Stock android browsers are marked as Safari
if (browser.safari && browser.android) {
var android = 'android';
matched.browser = android;
browser[android] = true;
}
browser.name = matched.browser;
browser.platform = matched.platform;
for (var key in Browser) {
if (Browser.hasOwnProperty(key)) {
delete Browser[key];
}
}
Object.assign(Browser, browser);
}
detect();
/* harmony default export */ var browser = (Browser);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/io/fetch-stream-loader.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* fetch + stream IO loader. Currently working on chrome 43+.
* fetch provides a better alternative http API to XMLHttpRequest
*
* fetch spec https://fetch.spec.whatwg.org/
* stream spec https://streams.spec.whatwg.org/
*/
var FetchStreamLoader = /*#__PURE__*/function (_BaseLoader) {
inherits_default()(FetchStreamLoader, _BaseLoader);
var _super = createSuper_default()(FetchStreamLoader);
function FetchStreamLoader(seekHandler, config) {
var _this;
classCallCheck_default()(this, FetchStreamLoader);
_this = _super.call(this, 'fetch-stream-loader');
_this.TAG = 'FetchStreamLoader';
_this._seekHandler = seekHandler;
_this._config = config;
_this._needStash = true;
_this._requestAbort = false;
_this._contentLength = null;
_this._receivedLength = 0;
return _this;
}
createClass_default()(FetchStreamLoader, [{
key: "destroy",
value: function destroy() {
if (this.isWorking()) {
this.abort();
}
get_default()(getPrototypeOf_default()(FetchStreamLoader.prototype), "destroy", this).call(this);
}
}, {
key: "open",
value: function open(dataSource, range) {
var _this2 = this;
this._dataSource = dataSource;
this._range = range;
var sourceURL = dataSource.url;
if (this._config.reuseRedirectedURL && dataSource.redirectedURL != undefined) {
sourceURL = dataSource.redirectedURL;
}
var seekConfig = this._seekHandler.getConfig(sourceURL, range);
var headers = new self.Headers();
if (typeof_default()(seekConfig.headers) === 'object') {
var configHeaders = seekConfig.headers;
for (var key in configHeaders) {
if (configHeaders.hasOwnProperty(key)) {
headers.append(key, configHeaders[key]);
}
}
}
var params = {
method: 'GET',
headers: headers,
mode: 'cors',
cache: 'default',
// The default policy of Fetch API in the whatwg standard
// Safari incorrectly indicates 'no-referrer' as default policy, fuck it
referrerPolicy: 'no-referrer-when-downgrade'
};
// add additional headers
if (typeof_default()(this._config.headers) === 'object') {
for (var _key in this._config.headers) {
headers.append(_key, this._config.headers[_key]);
}
}
// cors is enabled by default
if (dataSource.cors === false) {
// no-cors means 'disregard cors policy', which can only be used in ServiceWorker
params.mode = 'same-origin';
}
// withCredentials is disabled by default
if (dataSource.withCredentials) {
params.credentials = 'include';
}
// referrerPolicy from config
if (dataSource.referrerPolicy) {
params.referrerPolicy = dataSource.referrerPolicy;
}
this._status = loader_LoaderStatus.kConnecting;
self.fetch(seekConfig.url, params).then(function (res) {
if (_this2._requestAbort) {
_this2._requestAbort = false;
_this2._status = loader_LoaderStatus.kIdle;
return;
}
if (res.ok && res.status >= 200 && res.status <= 299) {
if (res.url !== seekConfig.url) {
if (_this2._onURLRedirect) {
var redirectedURL = _this2._seekHandler.removeURLParameters(res.url);
_this2._onURLRedirect(redirectedURL);
}
}
var lengthHeader = res.headers.get('Content-Length');
if (lengthHeader != null) {
_this2._contentLength = parseInt(lengthHeader);
if (_this2._contentLength !== 0) {
if (_this2._onContentLengthKnown) {
_this2._onContentLengthKnown(_this2._contentLength);
}
}
}
return _this2._pump.call(_this2, res.body.getReader());
} else {
_this2._status = loader_LoaderStatus.kError;
if (_this2._onError) {
_this2._onError(loader_LoaderErrors.HTTP_STATUS_CODE_INVALID, {
code: res.status,
msg: res.statusText
});
} else {
throw new exception_RuntimeException('FetchStreamLoader: Http code invalid, ' + res.status + ' ' + res.statusText);
}
}
})["catch"](function (e) {
_this2._status = loader_LoaderStatus.kError;
if (_this2._onError) {
_this2._onError(loader_LoaderErrors.EXCEPTION, {
code: -1,
msg: e.message
});
} else {
throw e;
}
});
}
}, {
key: "abort",
value: function abort() {
this._requestAbort = true;
}
}, {
key: "_pump",
value: function _pump(reader) {
var _this3 = this;
// ReadableStreamReader
return reader.read().then(function (result) {
if (result.done) {
// First check received length
if (_this3._contentLength !== null && _this3._receivedLength < _this3._contentLength) {
// Report Early-EOF
_this3._status = loader_LoaderStatus.kError;
var type = loader_LoaderErrors.EARLY_EOF;
var info = {
code: -1,
msg: 'Fetch stream meet Early-EOF'
};
if (_this3._onError) {
_this3._onError(type, info);
} else {
throw new exception_RuntimeException(info.msg);
}
} else {
// OK. Download complete
_this3._status = loader_LoaderStatus.kComplete;
if (_this3._onComplete) {
_this3._onComplete(_this3._range.from, _this3._range.from + _this3._receivedLength - 1);
}
}
} else {
if (_this3._requestAbort === true) {
_this3._requestAbort = false;
_this3._status = loader_LoaderStatus.kComplete;
return reader.cancel();
}
_this3._status = loader_LoaderStatus.kBuffering;
var chunk = result.value.buffer;
var byteStart = _this3._range.from + _this3._receivedLength;
_this3._receivedLength += chunk.byteLength;
if (_this3._onDataArrival) {
_this3._onDataArrival(chunk, byteStart, _this3._receivedLength);
}
_this3._pump(reader);
}
})["catch"](function (e) {
if (e.code === 11 && browser.msedge) {
// InvalidStateError on Microsoft Edge
// Workaround: Edge may throw InvalidStateError after ReadableStreamReader.cancel() call
// Ignore the unknown exception.
// Related issue: https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/11265202/
return;
}
_this3._status = loader_LoaderStatus.kError;
var type = 0;
var info = null;
if ((e.code === 19 || e.message === 'network error') && (
// NETWORK_ERR
_this3._contentLength === null || _this3._contentLength !== null && _this3._receivedLength < _this3._contentLength)) {
type = loader_LoaderErrors.EARLY_EOF;
info = {
code: e.code,
msg: 'Fetch stream meet Early-EOF'
};
} else {
type = loader_LoaderErrors.EXCEPTION;
info = {
code: e.code,
msg: e.message
};
}
if (_this3._onError) {
_this3._onError(type, info);
} else {
throw new exception_RuntimeException(info.msg);
}
});
}
}], [{
key: "isSupported",
value: function isSupported() {
try {
// fetch + stream is broken on Microsoft Edge. Disable before build 15048.
// see https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/8196907/
// Fixed in Jan 10, 2017. Build 15048+ removed from blacklist.
var isWorkWellEdge = browser.msedge && browser.version.minor >= 15048;
var browserNotBlacklisted = browser.msedge ? isWorkWellEdge : true;
return self.fetch && self.ReadableStream && browserNotBlacklisted;
} catch (e) {
return false;
}
}
}]);
return FetchStreamLoader;
}(loader_BaseLoader);
/* harmony default export */ var fetch_stream_loader = (FetchStreamLoader);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/io/xhr-moz-chunked-loader.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// For FireFox browser which supports `xhr.responseType = 'moz-chunked-arraybuffer'`
var MozChunkedLoader = /*#__PURE__*/function (_BaseLoader) {
inherits_default()(MozChunkedLoader, _BaseLoader);
var _super = createSuper_default()(MozChunkedLoader);
function MozChunkedLoader(seekHandler, config) {
var _this;
classCallCheck_default()(this, MozChunkedLoader);
_this = _super.call(this, 'xhr-moz-chunked-loader');
_this.TAG = 'MozChunkedLoader';
_this._seekHandler = seekHandler;
_this._config = config;
_this._needStash = true;
_this._xhr = null;
_this._requestAbort = false;
_this._contentLength = null;
_this._receivedLength = 0;
return _this;
}
createClass_default()(MozChunkedLoader, [{
key: "destroy",
value: function destroy() {
if (this.isWorking()) {
this.abort();
}
if (this._xhr) {
this._xhr.onreadystatechange = null;
this._xhr.onprogress = null;
this._xhr.onloadend = null;
this._xhr.onerror = null;
this._xhr = null;
}
get_default()(getPrototypeOf_default()(MozChunkedLoader.prototype), "destroy", this).call(this);
}
}, {
key: "open",
value: function open(dataSource, range) {
this._dataSource = dataSource;
this._range = range;
var sourceURL = dataSource.url;
if (this._config.reuseRedirectedURL && dataSource.redirectedURL != undefined) {
sourceURL = dataSource.redirectedURL;
}
var seekConfig = this._seekHandler.getConfig(sourceURL, range);
this._requestURL = seekConfig.url;
var xhr = this._xhr = new XMLHttpRequest();
xhr.open('GET', seekConfig.url, true);
xhr.responseType = 'moz-chunked-arraybuffer';
xhr.onreadystatechange = this._onReadyStateChange.bind(this);
xhr.onprogress = this._onProgress.bind(this);
xhr.onloadend = this._onLoadEnd.bind(this);
xhr.onerror = this._onXhrError.bind(this);
// cors is auto detected and enabled by xhr
// withCredentials is disabled by default
if (dataSource.withCredentials) {
xhr.withCredentials = true;
}
if (typeof_default()(seekConfig.headers) === 'object') {
var headers = seekConfig.headers;
for (var key in headers) {
if (headers.hasOwnProperty(key)) {
xhr.setRequestHeader(key, headers[key]);
}
}
}
// add additional headers
if (typeof_default()(this._config.headers) === 'object') {
var _headers = this._config.headers;
for (var _key in _headers) {
if (_headers.hasOwnProperty(_key)) {
xhr.setRequestHeader(_key, _headers[_key]);
}
}
}
this._status = loader_LoaderStatus.kConnecting;
xhr.send();
}
}, {
key: "abort",
value: function abort() {
this._requestAbort = true;
if (this._xhr) {
this._xhr.abort();
}
this._status = loader_LoaderStatus.kComplete;
}
}, {
key: "_onReadyStateChange",
value: function _onReadyStateChange(e) {
var xhr = e.target;
if (xhr.readyState === 2) {
// HEADERS_RECEIVED
if (xhr.responseURL != undefined && xhr.responseURL !== this._requestURL) {
if (this._onURLRedirect) {
var redirectedURL = this._seekHandler.removeURLParameters(xhr.responseURL);
this._onURLRedirect(redirectedURL);
}
}
if (xhr.status !== 0 && (xhr.status < 200 || xhr.status > 299)) {
this._status = loader_LoaderStatus.kError;
if (this._onError) {
this._onError(loader_LoaderErrors.HTTP_STATUS_CODE_INVALID, {
code: xhr.status,
msg: xhr.statusText
});
} else {
throw new exception_RuntimeException('MozChunkedLoader: Http code invalid, ' + xhr.status + ' ' + xhr.statusText);
}
} else {
this._status = loader_LoaderStatus.kBuffering;
}
}
}
}, {
key: "_onProgress",
value: function _onProgress(e) {
if (this._status === loader_LoaderStatus.kError) {
// Ignore error response
return;
}
if (this._contentLength === null) {
if (e.total !== null && e.total !== 0) {
this._contentLength = e.total;
if (this._onContentLengthKnown) {
this._onContentLengthKnown(this._contentLength);
}
}
}
var chunk = e.target.response;
var byteStart = this._range.from + this._receivedLength;
this._receivedLength += chunk.byteLength;
if (this._onDataArrival) {
this._onDataArrival(chunk, byteStart, this._receivedLength);
}
}
}, {
key: "_onLoadEnd",
value: function _onLoadEnd(e) {
if (this._requestAbort === true) {
this._requestAbort = false;
return;
} else if (this._status === loader_LoaderStatus.kError) {
return;
}
this._status = loader_LoaderStatus.kComplete;
if (this._onComplete) {
this._onComplete(this._range.from, this._range.from + this._receivedLength - 1);
}
}
}, {
key: "_onXhrError",
value: function _onXhrError(e) {
this._status = loader_LoaderStatus.kError;
var type = 0;
var info = null;
if (this._contentLength && e.loaded < this._contentLength) {
type = loader_LoaderErrors.EARLY_EOF;
info = {
code: -1,
msg: 'Moz-Chunked stream meet Early-Eof'
};
} else {
type = loader_LoaderErrors.EXCEPTION;
info = {
code: -1,
msg: e.constructor.name + ' ' + e.type
};
}
if (this._onError) {
this._onError(type, info);
} else {
throw new exception_RuntimeException(info.msg);
}
}
}], [{
key: "isSupported",
value: function isSupported() {
try {
var xhr = new XMLHttpRequest();
// Firefox 37- requires .open() to be called before setting responseType
xhr.open('GET', 'https://example.com', true);
xhr.responseType = 'moz-chunked-arraybuffer';
return xhr.responseType === 'moz-chunked-arraybuffer';
} catch (e) {
logger.w('MozChunkedLoader', e.message);
return false;
}
}
}]);
return MozChunkedLoader;
}(loader_BaseLoader);
/* harmony default export */ var xhr_moz_chunked_loader = (MozChunkedLoader);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/io/xhr-msstream-loader.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* Notice: ms-stream may cause IE/Edge browser crash if seek too frequently!!!
* The browser may crash in wininet.dll. Disable for now.
*
* For IE11/Edge browser by microsoft which supports `xhr.responseType = 'ms-stream'`
* Notice that ms-stream API sucks. The buffer is always expanding along with downloading.
*
* We need to abort the xhr if buffer size exceeded limit size (e.g. 16 MiB), then do reconnect.
* in order to release previous ArrayBuffer to avoid memory leak
*
* Otherwise, the ArrayBuffer will increase to a terrible size that equals final file size.
*/
var MSStreamLoader = /*#__PURE__*/(/* unused pure expression or super */ null && (function (_BaseLoader) {
_inherits(MSStreamLoader, _BaseLoader);
var _super = _createSuper(MSStreamLoader);
function MSStreamLoader(seekHandler, config) {
var _this;
_classCallCheck(this, MSStreamLoader);
_this = _super.call(this, 'xhr-msstream-loader');
_this.TAG = 'MSStreamLoader';
_this._seekHandler = seekHandler;
_this._config = config;
_this._needStash = true;
_this._xhr = null;
_this._reader = null; // MSStreamReader
_this._totalRange = null;
_this._currentRange = null;
_this._currentRequestURL = null;
_this._currentRedirectedURL = null;
_this._contentLength = null;
_this._receivedLength = 0;
_this._bufferLimit = 16 * 1024 * 1024; // 16MB
_this._lastTimeBufferSize = 0;
_this._isReconnecting = false;
return _this;
}
_createClass(MSStreamLoader, [{
key: "destroy",
value: function destroy() {
if (this.isWorking()) {
this.abort();
}
if (this._reader) {
this._reader.onprogress = null;
this._reader.onload = null;
this._reader.onerror = null;
this._reader = null;
}
if (this._xhr) {
this._xhr.onreadystatechange = null;
this._xhr = null;
}
_get(_getPrototypeOf(MSStreamLoader.prototype), "destroy", this).call(this);
}
}, {
key: "open",
value: function open(dataSource, range) {
this._internalOpen(dataSource, range, false);
}
}, {
key: "_internalOpen",
value: function _internalOpen(dataSource, range, isSubrange) {
this._dataSource = dataSource;
if (!isSubrange) {
this._totalRange = range;
} else {
this._currentRange = range;
}
var sourceURL = dataSource.url;
if (this._config.reuseRedirectedURL) {
if (this._currentRedirectedURL != undefined) {
sourceURL = this._currentRedirectedURL;
} else if (dataSource.redirectedURL != undefined) {
sourceURL = dataSource.redirectedURL;
}
}
var seekConfig = this._seekHandler.getConfig(sourceURL, range);
this._currentRequestURL = seekConfig.url;
var reader = this._reader = new self.MSStreamReader();
reader.onprogress = this._msrOnProgress.bind(this);
reader.onload = this._msrOnLoad.bind(this);
reader.onerror = this._msrOnError.bind(this);
var xhr = this._xhr = new XMLHttpRequest();
xhr.open('GET', seekConfig.url, true);
xhr.responseType = 'ms-stream';
xhr.onreadystatechange = this._xhrOnReadyStateChange.bind(this);
xhr.onerror = this._xhrOnError.bind(this);
if (dataSource.withCredentials) {
xhr.withCredentials = true;
}
if (_typeof(seekConfig.headers) === 'object') {
var headers = seekConfig.headers;
for (var key in headers) {
if (headers.hasOwnProperty(key)) {
xhr.setRequestHeader(key, headers[key]);
}
}
}
// add additional headers
if (_typeof(this._config.headers) === 'object') {
var _headers = this._config.headers;
for (var _key in _headers) {
if (_headers.hasOwnProperty(_key)) {
xhr.setRequestHeader(_key, _headers[_key]);
}
}
}
if (this._isReconnecting) {
this._isReconnecting = false;
} else {
this._status = LoaderStatus.kConnecting;
}
xhr.send();
}
}, {
key: "abort",
value: function abort() {
this._internalAbort();
this._status = LoaderStatus.kComplete;
}
}, {
key: "_internalAbort",
value: function _internalAbort() {
if (this._reader) {
if (this._reader.readyState === 1) {
// LOADING
this._reader.abort();
}
this._reader.onprogress = null;
this._reader.onload = null;
this._reader.onerror = null;
this._reader = null;
}
if (this._xhr) {
this._xhr.abort();
this._xhr.onreadystatechange = null;
this._xhr = null;
}
}
}, {
key: "_xhrOnReadyStateChange",
value: function _xhrOnReadyStateChange(e) {
var xhr = e.target;
if (xhr.readyState === 2) {
// HEADERS_RECEIVED
if (xhr.status >= 200 && xhr.status <= 299) {
this._status = LoaderStatus.kBuffering;
if (xhr.responseURL != undefined) {
var redirectedURL = this._seekHandler.removeURLParameters(xhr.responseURL);
if (xhr.responseURL !== this._currentRequestURL && redirectedURL !== this._currentRedirectedURL) {
this._currentRedirectedURL = redirectedURL;
if (this._onURLRedirect) {
this._onURLRedirect(redirectedURL);
}
}
}
var lengthHeader = xhr.getResponseHeader('Content-Length');
if (lengthHeader != null && this._contentLength == null) {
var length = parseInt(lengthHeader);
if (length > 0) {
this._contentLength = length;
if (this._onContentLengthKnown) {
this._onContentLengthKnown(this._contentLength);
}
}
}
} else {
this._status = LoaderStatus.kError;
if (this._onError) {
this._onError(LoaderErrors.HTTP_STATUS_CODE_INVALID, {
code: xhr.status,
msg: xhr.statusText
});
} else {
throw new RuntimeException('MSStreamLoader: Http code invalid, ' + xhr.status + ' ' + xhr.statusText);
}
}
} else if (xhr.readyState === 3) {
// LOADING
if (xhr.status >= 200 && xhr.status <= 299) {
this._status = LoaderStatus.kBuffering;
var msstream = xhr.response;
this._reader.readAsArrayBuffer(msstream);
}
}
}
}, {
key: "_xhrOnError",
value: function _xhrOnError(e) {
this._status = LoaderStatus.kError;
var type = LoaderErrors.EXCEPTION;
var info = {
code: -1,
msg: e.constructor.name + ' ' + e.type
};
if (this._onError) {
this._onError(type, info);
} else {
throw new RuntimeException(info.msg);
}
}
}, {
key: "_msrOnProgress",
value: function _msrOnProgress(e) {
var reader = e.target;
var bigbuffer = reader.result;
if (bigbuffer == null) {
// result may be null, workaround for buggy M$
this._doReconnectIfNeeded();
return;
}
var slice = bigbuffer.slice(this._lastTimeBufferSize);
this._lastTimeBufferSize = bigbuffer.byteLength;
var byteStart = this._totalRange.from + this._receivedLength;
this._receivedLength += slice.byteLength;
if (this._onDataArrival) {
this._onDataArrival(slice, byteStart, this._receivedLength);
}
if (bigbuffer.byteLength >= this._bufferLimit) {
Log.v(this.TAG, "MSStream buffer exceeded max size near ".concat(byteStart + slice.byteLength, ", reconnecting..."));
this._doReconnectIfNeeded();
}
}
}, {
key: "_doReconnectIfNeeded",
value: function _doReconnectIfNeeded() {
if (this._contentLength == null || this._receivedLength < this._contentLength) {
this._isReconnecting = true;
this._lastTimeBufferSize = 0;
this._internalAbort();
var range = {
from: this._totalRange.from + this._receivedLength,
to: -1
};
this._internalOpen(this._dataSource, range, true);
}
}
}, {
key: "_msrOnLoad",
value: function _msrOnLoad(e) {
// actually it is onComplete event
this._status = LoaderStatus.kComplete;
if (this._onComplete) {
this._onComplete(this._totalRange.from, this._totalRange.from + this._receivedLength - 1);
}
}
}, {
key: "_msrOnError",
value: function _msrOnError(e) {
this._status = LoaderStatus.kError;
var type = 0;
var info = null;
if (this._contentLength && this._receivedLength < this._contentLength) {
type = LoaderErrors.EARLY_EOF;
info = {
code: -1,
msg: 'MSStream meet Early-Eof'
};
} else {
type = LoaderErrors.EARLY_EOF;
info = {
code: -1,
msg: e.constructor.name + ' ' + e.type
};
}
if (this._onError) {
this._onError(type, info);
} else {
throw new RuntimeException(info.msg);
}
}
}], [{
key: "isSupported",
value: function isSupported() {
try {
if (typeof self.MSStream === 'undefined' || typeof self.MSStreamReader === 'undefined') {
return false;
}
var xhr = new XMLHttpRequest();
xhr.open('GET', 'https://example.com', true);
xhr.responseType = 'ms-stream';
return xhr.responseType === 'ms-stream';
} catch (e) {
Log.w('MSStreamLoader', e.message);
return false;
}
}
}]);
return MSStreamLoader;
}(BaseLoader)));
/* harmony default export */ var xhr_msstream_loader = ((/* unused pure expression or super */ null && (MSStreamLoader)));
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/io/xhr-range-loader.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// Universal IO Loader, implemented by adding Range header in xhr's request header
var RangeLoader = /*#__PURE__*/function (_BaseLoader) {
inherits_default()(RangeLoader, _BaseLoader);
var _super = createSuper_default()(RangeLoader);
function RangeLoader(seekHandler, config) {
var _this;
classCallCheck_default()(this, RangeLoader);
_this = _super.call(this, 'xhr-range-loader');
_this.TAG = 'RangeLoader';
_this._seekHandler = seekHandler;
_this._config = config;
_this._needStash = false;
_this._chunkSizeKBList = [128, 256, 384, 512, 768, 1024, 1536, 2048, 3072, 4096, 5120, 6144, 7168, 8192];
_this._currentChunkSizeKB = 384;
_this._currentSpeedNormalized = 0;
_this._zeroSpeedChunkCount = 0;
_this._xhr = null;
_this._speedSampler = new speed_sampler();
_this._requestAbort = false;
_this._waitForTotalLength = false;
_this._totalLengthReceived = false;
_this._currentRequestURL = null;
_this._currentRedirectedURL = null;
_this._currentRequestRange = null;
_this._totalLength = null; // size of the entire file
_this._contentLength = null; // Content-Length of entire request range
_this._receivedLength = 0; // total received bytes
_this._lastTimeLoaded = 0; // received bytes of current request sub-range
return _this;
}
createClass_default()(RangeLoader, [{
key: "destroy",
value: function destroy() {
if (this.isWorking()) {
this.abort();
}
if (this._xhr) {
this._xhr.onreadystatechange = null;
this._xhr.onprogress = null;
this._xhr.onload = null;
this._xhr.onerror = null;
this._xhr = null;
}
get_default()(getPrototypeOf_default()(RangeLoader.prototype), "destroy", this).call(this);
}
}, {
key: "currentSpeed",
get: function get() {
return this._speedSampler.lastSecondKBps;
}
}, {
key: "open",
value: function open(dataSource, range) {
this._dataSource = dataSource;
this._range = range;
this._status = loader_LoaderStatus.kConnecting;
var useRefTotalLength = false;
if (this._dataSource.filesize != undefined && this._dataSource.filesize !== 0) {
useRefTotalLength = true;
this._totalLength = this._dataSource.filesize;
}
if (!this._totalLengthReceived && !useRefTotalLength) {
// We need total filesize
this._waitForTotalLength = true;
this._internalOpen(this._dataSource, {
from: 0,
to: -1
});
} else {
// We have filesize, start loading
this._openSubRange();
}
}
}, {
key: "_openSubRange",
value: function _openSubRange() {
var chunkSize = this._currentChunkSizeKB * 1024;
var from = this._range.from + this._receivedLength;
var to = from + chunkSize;
if (this._contentLength != null) {
if (to - this._range.from >= this._contentLength) {
to = this._range.from + this._contentLength - 1;
}
}
this._currentRequestRange = {
from: from,
to: to
};
this._internalOpen(this._dataSource, this._currentRequestRange);
}
}, {
key: "_internalOpen",
value: function _internalOpen(dataSource, range) {
this._lastTimeLoaded = 0;
var sourceURL = dataSource.url;
if (this._config.reuseRedirectedURL) {
if (this._currentRedirectedURL != undefined) {
sourceURL = this._currentRedirectedURL;
} else if (dataSource.redirectedURL != undefined) {
sourceURL = dataSource.redirectedURL;
}
}
var seekConfig = this._seekHandler.getConfig(sourceURL, range);
this._currentRequestURL = seekConfig.url;
var xhr = this._xhr = new XMLHttpRequest();
xhr.open('GET', seekConfig.url, true);
xhr.responseType = 'arraybuffer';
xhr.onreadystatechange = this._onReadyStateChange.bind(this);
xhr.onprogress = this._onProgress.bind(this);
xhr.onload = this._onLoad.bind(this);
xhr.onerror = this._onXhrError.bind(this);
if (dataSource.withCredentials) {
xhr.withCredentials = true;
}
if (typeof_default()(seekConfig.headers) === 'object') {
var headers = seekConfig.headers;
for (var key in headers) {
if (headers.hasOwnProperty(key)) {
xhr.setRequestHeader(key, headers[key]);
}
}
}
// add additional headers
if (typeof_default()(this._config.headers) === 'object') {
var _headers = this._config.headers;
for (var _key in _headers) {
if (_headers.hasOwnProperty(_key)) {
xhr.setRequestHeader(_key, _headers[_key]);
}
}
}
xhr.send();
}
}, {
key: "abort",
value: function abort() {
this._requestAbort = true;
this._internalAbort();
this._status = loader_LoaderStatus.kComplete;
}
}, {
key: "_internalAbort",
value: function _internalAbort() {
if (this._xhr) {
this._xhr.onreadystatechange = null;
this._xhr.onprogress = null;
this._xhr.onload = null;
this._xhr.onerror = null;
this._xhr.abort();
this._xhr = null;
}
}
}, {
key: "_onReadyStateChange",
value: function _onReadyStateChange(e) {
var xhr = e.target;
if (xhr.readyState === 2) {
// HEADERS_RECEIVED
if (xhr.responseURL != undefined) {
// if the browser support this property
var redirectedURL = this._seekHandler.removeURLParameters(xhr.responseURL);
if (xhr.responseURL !== this._currentRequestURL && redirectedURL !== this._currentRedirectedURL) {
this._currentRedirectedURL = redirectedURL;
if (this._onURLRedirect) {
this._onURLRedirect(redirectedURL);
}
}
}
if (xhr.status >= 200 && xhr.status <= 299) {
if (this._waitForTotalLength) {
return;
}
this._status = loader_LoaderStatus.kBuffering;
} else {
this._status = loader_LoaderStatus.kError;
if (this._onError) {
this._onError(loader_LoaderErrors.HTTP_STATUS_CODE_INVALID, {
code: xhr.status,
msg: xhr.statusText
});
} else {
throw new exception_RuntimeException('RangeLoader: Http code invalid, ' + xhr.status + ' ' + xhr.statusText);
}
}
}
}
}, {
key: "_onProgress",
value: function _onProgress(e) {
if (this._status === loader_LoaderStatus.kError) {
// Ignore error response
return;
}
if (this._contentLength === null) {
var openNextRange = false;
if (this._waitForTotalLength) {
this._waitForTotalLength = false;
this._totalLengthReceived = true;
openNextRange = true;
var total = e.total;
this._internalAbort();
if (total != null & total !== 0) {
this._totalLength = total;
}
}
// calculate currrent request range's contentLength
if (this._range.to === -1) {
this._contentLength = this._totalLength - this._range.from;
} else {
// to !== -1
this._contentLength = this._range.to - this._range.from + 1;
}
if (openNextRange) {
this._openSubRange();
return;
}
if (this._onContentLengthKnown) {
this._onContentLengthKnown(this._contentLength);
}
}
var delta = e.loaded - this._lastTimeLoaded;
this._lastTimeLoaded = e.loaded;
this._speedSampler.addBytes(delta);
}
}, {
key: "_normalizeSpeed",
value: function _normalizeSpeed(input) {
var list = this._chunkSizeKBList;
var last = list.length - 1;
var mid = 0;
var lbound = 0;
var ubound = last;
if (input < list[0]) {
return list[0];
}
while (lbound <= ubound) {
mid = lbound + Math.floor((ubound - lbound) / 2);
if (mid === last || input >= list[mid] && input < list[mid + 1]) {
return list[mid];
} else if (list[mid] < input) {
lbound = mid + 1;
} else {
ubound = mid - 1;
}
}
}
}, {
key: "_onLoad",
value: function _onLoad(e) {
if (this._status === loader_LoaderStatus.kError) {
// Ignore error response
return;
}
if (this._waitForTotalLength) {
this._waitForTotalLength = false;
return;
}
this._lastTimeLoaded = 0;
var KBps = this._speedSampler.lastSecondKBps;
if (KBps === 0) {
this._zeroSpeedChunkCount++;
if (this._zeroSpeedChunkCount >= 3) {
// Try get currentKBps after 3 chunks
KBps = this._speedSampler.currentKBps;
}
}
if (KBps !== 0) {
var normalized = this._normalizeSpeed(KBps);
if (this._currentSpeedNormalized !== normalized) {
this._currentSpeedNormalized = normalized;
this._currentChunkSizeKB = normalized;
}
}
var chunk = e.target.response;
var byteStart = this._range.from + this._receivedLength;
this._receivedLength += chunk.byteLength;
var reportComplete = false;
if (this._contentLength != null && this._receivedLength < this._contentLength) {
// continue load next chunk
this._openSubRange();
} else {
reportComplete = true;
}
// dispatch received chunk
if (this._onDataArrival) {
this._onDataArrival(chunk, byteStart, this._receivedLength);
}
if (reportComplete) {
this._status = loader_LoaderStatus.kComplete;
if (this._onComplete) {
this._onComplete(this._range.from, this._range.from + this._receivedLength - 1);
}
}
}
}, {
key: "_onXhrError",
value: function _onXhrError(e) {
this._status = loader_LoaderStatus.kError;
var type = 0;
var info = null;
if (this._contentLength && this._receivedLength > 0 && this._receivedLength < this._contentLength) {
type = loader_LoaderErrors.EARLY_EOF;
info = {
code: -1,
msg: 'RangeLoader meet Early-Eof'
};
} else {
type = loader_LoaderErrors.EXCEPTION;
info = {
code: -1,
msg: e.constructor.name + ' ' + e.type
};
}
if (this._onError) {
this._onError(type, info);
} else {
throw new exception_RuntimeException(info.msg);
}
}
}], [{
key: "isSupported",
value: function isSupported() {
try {
var xhr = new XMLHttpRequest();
xhr.open('GET', 'https://example.com', true);
xhr.responseType = 'arraybuffer';
return xhr.responseType === 'arraybuffer';
} catch (e) {
logger.w('RangeLoader', e.message);
return false;
}
}
}]);
return RangeLoader;
}(loader_BaseLoader);
/* harmony default export */ var xhr_range_loader = (RangeLoader);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/io/websocket-loader.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// For FLV over WebSocket live stream
var WebSocketLoader = /*#__PURE__*/function (_BaseLoader) {
inherits_default()(WebSocketLoader, _BaseLoader);
var _super = createSuper_default()(WebSocketLoader);
function WebSocketLoader() {
var _this;
classCallCheck_default()(this, WebSocketLoader);
_this = _super.call(this, 'websocket-loader');
_this.TAG = 'WebSocketLoader';
_this._needStash = true;
_this._ws = null;
_this._requestAbort = false;
_this._receivedLength = 0;
return _this;
}
createClass_default()(WebSocketLoader, [{
key: "destroy",
value: function destroy() {
if (this._ws) {
this.abort();
}
get_default()(getPrototypeOf_default()(WebSocketLoader.prototype), "destroy", this).call(this);
}
}, {
key: "open",
value: function open(dataSource) {
try {
var ws = this._ws = new self.WebSocket(dataSource.url);
ws.binaryType = 'arraybuffer';
ws.onopen = this._onWebSocketOpen.bind(this);
ws.onclose = this._onWebSocketClose.bind(this);
ws.onmessage = this._onWebSocketMessage.bind(this);
ws.onerror = this._onWebSocketError.bind(this);
this._status = loader_LoaderStatus.kConnecting;
} catch (e) {
this._status = loader_LoaderStatus.kError;
var info = {
code: e.code,
msg: e.message
};
if (this._onError) {
this._onError(loader_LoaderErrors.EXCEPTION, info);
} else {
throw new exception_RuntimeException(info.msg);
}
}
}
}, {
key: "abort",
value: function abort() {
var ws = this._ws;
if (ws && (ws.readyState === 0 || ws.readyState === 1)) {
// CONNECTING || OPEN
this._requestAbort = true;
ws.close();
}
this._ws = null;
this._status = loader_LoaderStatus.kComplete;
}
}, {
key: "_onWebSocketOpen",
value: function _onWebSocketOpen(e) {
this._status = loader_LoaderStatus.kBuffering;
}
}, {
key: "_onWebSocketClose",
value: function _onWebSocketClose(e) {
if (this._requestAbort === true) {
this._requestAbort = false;
return;
}
this._status = loader_LoaderStatus.kComplete;
if (this._onComplete) {
this._onComplete(0, this._receivedLength - 1);
}
}
}, {
key: "_onWebSocketMessage",
value: function _onWebSocketMessage(e) {
var _this2 = this;
if (e.data instanceof ArrayBuffer) {
this._dispatchArrayBuffer(e.data);
} else if (e.data instanceof Blob) {
var reader = new FileReader();
reader.onload = function () {
_this2._dispatchArrayBuffer(reader.result);
};
reader.readAsArrayBuffer(e.data);
} else {
this._status = loader_LoaderStatus.kError;
var info = {
code: -1,
msg: 'Unsupported WebSocket message type: ' + e.data.constructor.name
};
if (this._onError) {
this._onError(loader_LoaderErrors.EXCEPTION, info);
} else {
throw new exception_RuntimeException(info.msg);
}
}
}
}, {
key: "_dispatchArrayBuffer",
value: function _dispatchArrayBuffer(arraybuffer) {
var chunk = arraybuffer;
var byteStart = this._receivedLength;
this._receivedLength += chunk.byteLength;
if (this._onDataArrival) {
this._onDataArrival(chunk, byteStart, this._receivedLength);
}
}
}, {
key: "_onWebSocketError",
value: function _onWebSocketError(e) {
this._status = loader_LoaderStatus.kError;
var info = {
code: e.code,
msg: e.message
};
if (this._onError) {
this._onError(loader_LoaderErrors.EXCEPTION, info);
} else {
throw new exception_RuntimeException(info.msg);
}
}
}], [{
key: "isSupported",
value: function isSupported() {
try {
return typeof self.WebSocket !== 'undefined';
} catch (e) {
return false;
}
}
}]);
return WebSocketLoader;
}(loader_BaseLoader);
/* harmony default export */ var websocket_loader = (WebSocketLoader);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/io/range-seek-handler.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var RangeSeekHandler = /*#__PURE__*/function () {
function RangeSeekHandler(zeroStart) {
classCallCheck_default()(this, RangeSeekHandler);
this._zeroStart = zeroStart || false;
}
createClass_default()(RangeSeekHandler, [{
key: "getConfig",
value: function getConfig(url, range) {
var headers = {};
if (range.from !== 0 || range.to !== -1) {
var param;
if (range.to !== -1) {
param = "bytes=".concat(range.from.toString(), "-").concat(range.to.toString());
} else {
param = "bytes=".concat(range.from.toString(), "-");
}
headers['Range'] = param;
} else if (this._zeroStart) {
headers['Range'] = 'bytes=0-';
}
return {
url: url,
headers: headers
};
}
}, {
key: "removeURLParameters",
value: function removeURLParameters(seekedURL) {
return seekedURL;
}
}]);
return RangeSeekHandler;
}();
/* harmony default export */ var range_seek_handler = (RangeSeekHandler);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/io/param-seek-handler.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var ParamSeekHandler = /*#__PURE__*/function () {
function ParamSeekHandler(paramStart, paramEnd) {
classCallCheck_default()(this, ParamSeekHandler);
this._startName = paramStart;
this._endName = paramEnd;
}
createClass_default()(ParamSeekHandler, [{
key: "getConfig",
value: function getConfig(baseUrl, range) {
var url = baseUrl;
if (range.from !== 0 || range.to !== -1) {
var needAnd = true;
if (url.indexOf('?') === -1) {
url += '?';
needAnd = false;
}
if (needAnd) {
url += '&';
}
url += "".concat(this._startName, "=").concat(range.from.toString());
if (range.to !== -1) {
url += "&".concat(this._endName, "=").concat(range.to.toString());
}
}
return {
url: url,
headers: {}
};
}
}, {
key: "removeURLParameters",
value: function removeURLParameters(seekedURL) {
var baseURL = seekedURL.split('?')[0];
var params = undefined;
var queryIndex = seekedURL.indexOf('?');
if (queryIndex !== -1) {
params = seekedURL.substring(queryIndex + 1);
}
var resultParams = '';
if (params != undefined && params.length > 0) {
var pairs = params.split('&');
for (var i = 0; i < pairs.length; i++) {
var pair = pairs[i].split('=');
var requireAnd = i > 0;
if (pair[0] !== this._startName && pair[0] !== this._endName) {
if (requireAnd) {
resultParams += '&';
}
resultParams += pairs[i];
}
}
}
return resultParams.length === 0 ? baseURL : baseURL + '?' + resultParams;
}
}]);
return ParamSeekHandler;
}();
/* harmony default export */ var param_seek_handler = (ParamSeekHandler);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/io/io-controller.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* DataSource: {
* url: string,
* filesize: number,
* cors: boolean,
* withCredentials: boolean
* }
*
*/
// Manage IO Loaders
var IOController = /*#__PURE__*/function () {
function IOController(dataSource, config, extraData) {
classCallCheck_default()(this, IOController);
this.TAG = 'IOController';
this._config = config;
this._extraData = extraData;
this._stashInitialSize = 1024 * 384; // default initial size: 384KB
if (config.stashInitialSize != undefined && config.stashInitialSize > 0) {
// apply from config
this._stashInitialSize = config.stashInitialSize;
}
this._stashUsed = 0;
this._stashSize = this._stashInitialSize;
this._bufferSize = 1024 * 1024 * 3; // initial size: 3MB
this._stashBuffer = new ArrayBuffer(this._bufferSize);
this._stashByteStart = 0;
this._enableStash = true;
if (config.enableStashBuffer === false) {
this._enableStash = false;
}
this._loader = null;
this._loaderClass = null;
this._seekHandler = null;
this._dataSource = dataSource;
this._isWebSocketURL = /wss?:\/\/(.+?)/.test(dataSource.url);
this._refTotalLength = dataSource.filesize ? dataSource.filesize : null;
this._totalLength = this._refTotalLength;
this._fullRequestFlag = false;
this._currentRange = null;
this._redirectedURL = null;
this._speedNormalized = 0;
this._speedSampler = new speed_sampler();
this._speedNormalizeList = [64, 128, 256, 384, 512, 768, 1024, 1536, 2048, 3072, 4096];
this._isEarlyEofReconnecting = false;
this._paused = false;
this._resumeFrom = 0;
this._onDataArrival = null;
this._onSeeked = null;
this._onError = null;
this._onComplete = null;
this._onRedirect = null;
this._onRecoveredEarlyEof = null;
this._selectSeekHandler();
this._selectLoader();
this._createLoader();
}
createClass_default()(IOController, [{
key: "destroy",
value: function destroy() {
if (this._loader.isWorking()) {
this._loader.abort();
}
this._loader.destroy();
this._loader = null;
this._loaderClass = null;
this._dataSource = null;
this._stashBuffer = null;
this._stashUsed = this._stashSize = this._bufferSize = this._stashByteStart = 0;
this._currentRange = null;
this._speedSampler = null;
this._isEarlyEofReconnecting = false;
this._onDataArrival = null;
this._onSeeked = null;
this._onError = null;
this._onComplete = null;
this._onRedirect = null;
this._onRecoveredEarlyEof = null;
this._extraData = null;
}
}, {
key: "isWorking",
value: function isWorking() {
return this._loader && this._loader.isWorking() && !this._paused;
}
}, {
key: "isPaused",
value: function isPaused() {
return this._paused;
}
}, {
key: "status",
get: function get() {
return this._loader.status;
}
}, {
key: "extraData",
get: function get() {
return this._extraData;
},
set: function set(data) {
this._extraData = data;
}
// prototype: function onDataArrival(chunks: ArrayBuffer, byteStart: number): number
}, {
key: "onDataArrival",
get: function get() {
return this._onDataArrival;
},
set: function set(callback) {
this._onDataArrival = callback;
}
}, {
key: "onSeeked",
get: function get() {
return this._onSeeked;
},
set: function set(callback) {
this._onSeeked = callback;
}
// prototype: function onError(type: number, info: {code: number, msg: string}): void
}, {
key: "onError",
get: function get() {
return this._onError;
},
set: function set(callback) {
this._onError = callback;
}
}, {
key: "onComplete",
get: function get() {
return this._onComplete;
},
set: function set(callback) {
this._onComplete = callback;
}
}, {
key: "onRedirect",
get: function get() {
return this._onRedirect;
},
set: function set(callback) {
this._onRedirect = callback;
}
}, {
key: "onRecoveredEarlyEof",
get: function get() {
return this._onRecoveredEarlyEof;
},
set: function set(callback) {
this._onRecoveredEarlyEof = callback;
}
}, {
key: "currentURL",
get: function get() {
return this._dataSource.url;
}
}, {
key: "hasRedirect",
get: function get() {
return this._redirectedURL != null || this._dataSource.redirectedURL != undefined;
}
}, {
key: "currentRedirectedURL",
get: function get() {
return this._redirectedURL || this._dataSource.redirectedURL;
}
// in KB/s
}, {
key: "currentSpeed",
get: function get() {
if (this._loaderClass === xhr_range_loader) {
// SpeedSampler is inaccuracy if loader is RangeLoader
return this._loader.currentSpeed;
}
return this._speedSampler.lastSecondKBps;
}
}, {
key: "loaderType",
get: function get() {
return this._loader.type;
}
}, {
key: "_selectSeekHandler",
value: function _selectSeekHandler() {
var config = this._config;
if (config.seekType === 'range') {
this._seekHandler = new range_seek_handler(this._config.rangeLoadZeroStart);
} else if (config.seekType === 'param') {
var paramStart = config.seekParamStart || 'bstart';
var paramEnd = config.seekParamEnd || 'bend';
this._seekHandler = new param_seek_handler(paramStart, paramEnd);
} else if (config.seekType === 'custom') {
if (typeof config.customSeekHandler !== 'function') {
throw new InvalidArgumentException('Custom seekType specified in config but invalid customSeekHandler!');
}
this._seekHandler = new config.customSeekHandler();
} else {
throw new InvalidArgumentException("Invalid seekType in config: ".concat(config.seekType));
}
}
}, {
key: "_selectLoader",
value: function _selectLoader() {
if (this._config.customLoader != null) {
this._loaderClass = this._config.customLoader;
} else if (this._isWebSocketURL) {
this._loaderClass = websocket_loader;
} else if (fetch_stream_loader.isSupported()) {
this._loaderClass = fetch_stream_loader;
} else if (xhr_moz_chunked_loader.isSupported()) {
this._loaderClass = xhr_moz_chunked_loader;
} else if (xhr_range_loader.isSupported()) {
this._loaderClass = xhr_range_loader;
} else {
throw new exception_RuntimeException('Your browser doesn\'t support xhr with arraybuffer responseType!');
}
}
}, {
key: "_createLoader",
value: function _createLoader() {
this._loader = new this._loaderClass(this._seekHandler, this._config);
if (this._loader.needStashBuffer === false) {
this._enableStash = false;
}
this._loader.onContentLengthKnown = this._onContentLengthKnown.bind(this);
this._loader.onURLRedirect = this._onURLRedirect.bind(this);
this._loader.onDataArrival = this._onLoaderChunkArrival.bind(this);
this._loader.onComplete = this._onLoaderComplete.bind(this);
this._loader.onError = this._onLoaderError.bind(this);
}
}, {
key: "open",
value: function open(optionalFrom) {
this._currentRange = {
from: 0,
to: -1
};
if (optionalFrom) {
this._currentRange.from = optionalFrom;
}
this._speedSampler.reset();
if (!optionalFrom) {
this._fullRequestFlag = true;
}
this._loader.open(this._dataSource, Object.assign({}, this._currentRange));
}
}, {
key: "abort",
value: function abort() {
this._loader.abort();
if (this._paused) {
this._paused = false;
this._resumeFrom = 0;
}
}
}, {
key: "pause",
value: function pause() {
if (this.isWorking()) {
this._loader.abort();
if (this._stashUsed !== 0) {
this._resumeFrom = this._stashByteStart;
this._currentRange.to = this._stashByteStart - 1;
} else {
this._resumeFrom = this._currentRange.to + 1;
}
this._stashUsed = 0;
this._stashByteStart = 0;
this._paused = true;
}
}
}, {
key: "resume",
value: function resume() {
if (this._paused) {
this._paused = false;
var bytes = this._resumeFrom;
this._resumeFrom = 0;
this._internalSeek(bytes, true);
}
}
}, {
key: "seek",
value: function seek(bytes) {
this._paused = false;
this._stashUsed = 0;
this._stashByteStart = 0;
this._internalSeek(bytes, true);
}
/**
* When seeking request is from media seeking, unconsumed stash data should be dropped
* However, stash data shouldn't be dropped if seeking requested from http reconnection
*
* @dropUnconsumed: Ignore and discard all unconsumed data in stash buffer
*/
}, {
key: "_internalSeek",
value: function _internalSeek(bytes, dropUnconsumed) {
if (this._loader.isWorking()) {
this._loader.abort();
}
// dispatch & flush stash buffer before seek
this._flushStashBuffer(dropUnconsumed);
this._loader.destroy();
this._loader = null;
var requestRange = {
from: bytes,
to: -1
};
this._currentRange = {
from: requestRange.from,
to: -1
};
this._speedSampler.reset();
this._stashSize = this._stashInitialSize;
this._createLoader();
this._loader.open(this._dataSource, requestRange);
if (this._onSeeked) {
this._onSeeked();
}
}
}, {
key: "updateUrl",
value: function updateUrl(url) {
if (!url || typeof url !== 'string' || url.length === 0) {
throw new InvalidArgumentException('Url must be a non-empty string!');
}
this._dataSource.url = url;
// TODO: replace with new url
}
}, {
key: "_expandBuffer",
value: function _expandBuffer(expectedBytes) {
var bufferNewSize = this._stashSize;
while (bufferNewSize + 1024 * 1024 * 1 < expectedBytes) {
bufferNewSize *= 2;
}
bufferNewSize += 1024 * 1024 * 1; // bufferSize = stashSize + 1MB
if (bufferNewSize === this._bufferSize) {
return;
}
var newBuffer = new ArrayBuffer(bufferNewSize);
if (this._stashUsed > 0) {
// copy existing data into new buffer
var stashOldArray = new Uint8Array(this._stashBuffer, 0, this._stashUsed);
var stashNewArray = new Uint8Array(newBuffer, 0, bufferNewSize);
stashNewArray.set(stashOldArray, 0);
}
this._stashBuffer = newBuffer;
this._bufferSize = bufferNewSize;
}
}, {
key: "_normalizeSpeed",
value: function _normalizeSpeed(input) {
var list = this._speedNormalizeList;
var last = list.length - 1;
var mid = 0;
var lbound = 0;
var ubound = last;
if (input < list[0]) {
return list[0];
}
// binary search
while (lbound <= ubound) {
mid = lbound + Math.floor((ubound - lbound) / 2);
if (mid === last || input >= list[mid] && input < list[mid + 1]) {
return list[mid];
} else if (list[mid] < input) {
lbound = mid + 1;
} else {
ubound = mid - 1;
}
}
}
}, {
key: "_adjustStashSize",
value: function _adjustStashSize(normalized) {
var stashSizeKB = 0;
if (this._config.isLive) {
// live stream: always use single normalized speed for size of stashSizeKB
stashSizeKB = normalized;
} else {
if (normalized < 512) {
stashSizeKB = normalized;
} else if (normalized >= 512 && normalized <= 1024) {
stashSizeKB = Math.floor(normalized * 1.5);
} else {
stashSizeKB = normalized * 2;
}
}
if (stashSizeKB > 8192) {
stashSizeKB = 8192;
}
var bufferSize = stashSizeKB * 1024 + 1024 * 1024 * 1; // stashSize + 1MB
if (this._bufferSize < bufferSize) {
this._expandBuffer(bufferSize);
}
this._stashSize = stashSizeKB * 1024;
}
}, {
key: "_dispatchChunks",
value: function _dispatchChunks(chunks, byteStart) {
this._currentRange.to = byteStart + chunks.byteLength - 1;
return this._onDataArrival(chunks, byteStart);
}
}, {
key: "_onURLRedirect",
value: function _onURLRedirect(redirectedURL) {
this._redirectedURL = redirectedURL;
if (this._onRedirect) {
this._onRedirect(redirectedURL);
}
}
}, {
key: "_onContentLengthKnown",
value: function _onContentLengthKnown(contentLength) {
if (contentLength && this._fullRequestFlag) {
this._totalLength = contentLength;
this._fullRequestFlag = false;
}
}
}, {
key: "_onLoaderChunkArrival",
value: function _onLoaderChunkArrival(chunk, byteStart, receivedLength) {
if (!this._onDataArrival) {
throw new IllegalStateException('IOController: No existing consumer (onDataArrival) callback!');
}
if (this._paused) {
return;
}
if (this._isEarlyEofReconnecting) {
// Auto-reconnect for EarlyEof succeed, notify to upper-layer by callback
this._isEarlyEofReconnecting = false;
if (this._onRecoveredEarlyEof) {
this._onRecoveredEarlyEof();
}
}
this._speedSampler.addBytes(chunk.byteLength);
// adjust stash buffer size according to network speed dynamically
var KBps = this._speedSampler.lastSecondKBps;
if (KBps !== 0) {
var normalized = this._normalizeSpeed(KBps);
if (this._speedNormalized !== normalized) {
this._speedNormalized = normalized;
this._adjustStashSize(normalized);
}
}
if (!this._enableStash) {
// disable stash
if (this._stashUsed === 0) {
// dispatch chunk directly to consumer;
// check ret value (consumed bytes) and stash unconsumed to stashBuffer
var consumed = this._dispatchChunks(chunk, byteStart);
if (consumed < chunk.byteLength) {
// unconsumed data remain.
var remain = chunk.byteLength - consumed;
if (remain > this._bufferSize) {
this._expandBuffer(remain);
}
var stashArray = new Uint8Array(this._stashBuffer, 0, this._bufferSize);
stashArray.set(new Uint8Array(chunk, consumed), 0);
this._stashUsed += remain;
this._stashByteStart = byteStart + consumed;
}
} else {
// else: Merge chunk into stashBuffer, and dispatch stashBuffer to consumer.
if (this._stashUsed + chunk.byteLength > this._bufferSize) {
this._expandBuffer(this._stashUsed + chunk.byteLength);
}
var _stashArray = new Uint8Array(this._stashBuffer, 0, this._bufferSize);
_stashArray.set(new Uint8Array(chunk), this._stashUsed);
this._stashUsed += chunk.byteLength;
var _consumed = this._dispatchChunks(this._stashBuffer.slice(0, this._stashUsed), this._stashByteStart);
if (_consumed < this._stashUsed && _consumed > 0) {
// unconsumed data remain
var remainArray = new Uint8Array(this._stashBuffer, _consumed);
_stashArray.set(remainArray, 0);
}
this._stashUsed -= _consumed;
this._stashByteStart += _consumed;
}
} else {
// enable stash
if (this._stashUsed === 0 && this._stashByteStart === 0) {
// seeked? or init chunk?
// This is the first chunk after seek action
this._stashByteStart = byteStart;
}
if (this._stashUsed + chunk.byteLength <= this._stashSize) {
// just stash
var _stashArray2 = new Uint8Array(this._stashBuffer, 0, this._stashSize);
_stashArray2.set(new Uint8Array(chunk), this._stashUsed);
this._stashUsed += chunk.byteLength;
} else {
// stashUsed + chunkSize > stashSize, size limit exceeded
var _stashArray3 = new Uint8Array(this._stashBuffer, 0, this._bufferSize);
if (this._stashUsed > 0) {
// There're stash datas in buffer
// dispatch the whole stashBuffer, and stash remain data
// then append chunk to stashBuffer (stash)
var buffer = this._stashBuffer.slice(0, this._stashUsed);
var _consumed2 = this._dispatchChunks(buffer, this._stashByteStart);
if (_consumed2 < buffer.byteLength) {
if (_consumed2 > 0) {
var _remainArray = new Uint8Array(buffer, _consumed2);
_stashArray3.set(_remainArray, 0);
this._stashUsed = _remainArray.byteLength;
this._stashByteStart += _consumed2;
}
} else {
this._stashUsed = 0;
this._stashByteStart += _consumed2;
}
if (this._stashUsed + chunk.byteLength > this._bufferSize) {
this._expandBuffer(this._stashUsed + chunk.byteLength);
_stashArray3 = new Uint8Array(this._stashBuffer, 0, this._bufferSize);
}
_stashArray3.set(new Uint8Array(chunk), this._stashUsed);
this._stashUsed += chunk.byteLength;
} else {
// stash buffer empty, but chunkSize > stashSize (oh, holy shit)
// dispatch chunk directly and stash remain data
var _consumed3 = this._dispatchChunks(chunk, byteStart);
if (_consumed3 < chunk.byteLength) {
var _remain = chunk.byteLength - _consumed3;
if (_remain > this._bufferSize) {
this._expandBuffer(_remain);
_stashArray3 = new Uint8Array(this._stashBuffer, 0, this._bufferSize);
}
_stashArray3.set(new Uint8Array(chunk, _consumed3), 0);
this._stashUsed += _remain;
this._stashByteStart = byteStart + _consumed3;
}
}
}
}
}
}, {
key: "_flushStashBuffer",
value: function _flushStashBuffer(dropUnconsumed) {
if (this._stashUsed > 0) {
var buffer = this._stashBuffer.slice(0, this._stashUsed);
var consumed = this._dispatchChunks(buffer, this._stashByteStart);
var remain = buffer.byteLength - consumed;
if (consumed < buffer.byteLength) {
if (dropUnconsumed) {
logger.w(this.TAG, "".concat(remain, " bytes unconsumed data remain when flush buffer, dropped"));
} else {
if (consumed > 0) {
var stashArray = new Uint8Array(this._stashBuffer, 0, this._bufferSize);
var remainArray = new Uint8Array(buffer, consumed);
stashArray.set(remainArray, 0);
this._stashUsed = remainArray.byteLength;
this._stashByteStart += consumed;
}
return 0;
}
}
this._stashUsed = 0;
this._stashByteStart = 0;
return remain;
}
return 0;
}
}, {
key: "_onLoaderComplete",
value: function _onLoaderComplete(from, to) {
// Force-flush stash buffer, and drop unconsumed data
this._flushStashBuffer(true);
if (this._onComplete) {
this._onComplete(this._extraData);
}
}
}, {
key: "_onLoaderError",
value: function _onLoaderError(type, data) {
logger.e(this.TAG, "Loader error, code = ".concat(data.code, ", msg = ").concat(data.msg));
this._flushStashBuffer(false);
if (this._isEarlyEofReconnecting) {
// Auto-reconnect for EarlyEof failed, throw UnrecoverableEarlyEof error to upper-layer
this._isEarlyEofReconnecting = false;
type = loader_LoaderErrors.UNRECOVERABLE_EARLY_EOF;
}
switch (type) {
case loader_LoaderErrors.EARLY_EOF:
{
if (!this._config.isLive) {
// Do internal http reconnect if not live stream
if (this._totalLength) {
var nextFrom = this._currentRange.to + 1;
if (nextFrom < this._totalLength) {
logger.w(this.TAG, 'Connection lost, trying reconnect...');
this._isEarlyEofReconnecting = true;
this._internalSeek(nextFrom, false);
}
return;
}
// else: We don't know totalLength, throw UnrecoverableEarlyEof
}
// live stream: throw UnrecoverableEarlyEof error to upper-layer
type = loader_LoaderErrors.UNRECOVERABLE_EARLY_EOF;
break;
}
case loader_LoaderErrors.UNRECOVERABLE_EARLY_EOF:
case loader_LoaderErrors.CONNECTING_TIMEOUT:
case loader_LoaderErrors.HTTP_STATUS_CODE_INVALID:
case loader_LoaderErrors.EXCEPTION:
break;
}
if (this._onError) {
this._onError(type, data);
} else {
throw new exception_RuntimeException('IOException: ' + data.msg);
}
}
}]);
return IOController;
}();
/* harmony default export */ var io_controller = (IOController);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/config.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var defaultConfig = {
enableWorker: false,
enableStashBuffer: true,
stashInitialSize: undefined,
isLive: false,
lazyLoad: true,
lazyLoadMaxDuration: 3 * 60,
lazyLoadRecoverDuration: 30,
deferLoadAfterSourceOpen: true,
// autoCleanupSourceBuffer: default as false, leave unspecified
autoCleanupMaxBackwardDuration: 3 * 60,
autoCleanupMinBackwardDuration: 2 * 60,
statisticsInfoReportInterval: 600,
fixAudioTimestampGap: true,
accurateSeek: false,
seekType: 'range',
// [range, param, custom]
seekParamStart: 'bstart',
seekParamEnd: 'bend',
rangeLoadZeroStart: false,
customSeekHandler: undefined,
reuseRedirectedURL: false,
// referrerPolicy: leave as unspecified
headers: undefined,
customLoader: undefined
};
function createDefaultConfig() {
return Object.assign({}, defaultConfig);
}
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/core/features.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var Features = /*#__PURE__*/function () {
function Features() {
classCallCheck_default()(this, Features);
}
createClass_default()(Features, null, [{
key: "supportMSEH264Playback",
value: function supportMSEH264Playback() {
return window.MediaSource && window.MediaSource.isTypeSupported('video/mp4; codecs="avc1.42E01E,mp4a.40.2"');
}
}, {
key: "supportNetworkStreamIO",
value: function supportNetworkStreamIO() {
var ioctl = new io_controller({}, createDefaultConfig());
var loaderType = ioctl.loaderType;
ioctl.destroy();
return loaderType == 'fetch-stream-loader' || loaderType == 'xhr-moz-chunked-loader';
}
}, {
key: "getNetworkLoaderTypeName",
value: function getNetworkLoaderTypeName() {
var ioctl = new io_controller({}, createDefaultConfig());
var loaderType = ioctl.loaderType;
ioctl.destroy();
return loaderType;
}
}, {
key: "supportNativeMediaPlayback",
value: function supportNativeMediaPlayback(mimeType) {
if (Features.videoElement == undefined) {
Features.videoElement = window.document.createElement('video');
}
var canPlay = Features.videoElement.canPlayType(mimeType);
return canPlay === 'probably' || canPlay == 'maybe';
}
}, {
key: "getFeatureList",
value: function getFeatureList() {
var features = {
mseFlvPlayback: false,
mseLiveFlvPlayback: false,
networkStreamIO: false,
networkLoaderName: '',
nativeMP4H264Playback: false,
nativeWebmVP8Playback: false,
nativeWebmVP9Playback: false
};
features.mseFlvPlayback = Features.supportMSEH264Playback();
features.networkStreamIO = Features.supportNetworkStreamIO();
features.networkLoaderName = Features.getNetworkLoaderTypeName();
features.mseLiveFlvPlayback = features.mseFlvPlayback && features.networkStreamIO;
features.nativeMP4H264Playback = Features.supportNativeMediaPlayback('video/mp4; codecs="avc1.42001E, mp4a.40.2"');
features.nativeWebmVP8Playback = Features.supportNativeMediaPlayback('video/webm; codecs="vp8.0, vorbis"');
features.nativeWebmVP9Playback = Features.supportNativeMediaPlayback('video/webm; codecs="vp9"');
return features;
}
}]);
return Features;
}();
/* harmony default export */ var features = (Features);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/player/player-events.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var PlayerEvents = {
ERROR: 'error',
LOADING_COMPLETE: 'loading_complete',
RECOVERED_EARLY_EOF: 'recovered_early_eof',
MEDIA_INFO: 'media_info',
METADATA_ARRIVED: 'metadata_arrived',
SCRIPTDATA_ARRIVED: 'scriptdata_arrived',
STATISTICS_INFO: 'statistics_info'
};
/* harmony default export */ var player_events = (PlayerEvents);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/utils/logging-control.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var LoggingControl = /*#__PURE__*/function () {
function LoggingControl() {
classCallCheck_default()(this, LoggingControl);
}
createClass_default()(LoggingControl, null, [{
key: "forceGlobalTag",
get: function get() {
return logger.FORCE_GLOBAL_TAG;
},
set: function set(enable) {
logger.FORCE_GLOBAL_TAG = enable;
LoggingControl._notifyChange();
}
}, {
key: "globalTag",
get: function get() {
return logger.GLOBAL_TAG;
},
set: function set(tag) {
logger.GLOBAL_TAG = tag;
LoggingControl._notifyChange();
}
}, {
key: "enableAll",
get: function get() {
return logger.ENABLE_VERBOSE && logger.ENABLE_DEBUG && logger.ENABLE_INFO && logger.ENABLE_WARN && logger.ENABLE_ERROR;
},
set: function set(enable) {
logger.ENABLE_VERBOSE = enable;
logger.ENABLE_DEBUG = enable;
logger.ENABLE_INFO = enable;
logger.ENABLE_WARN = enable;
logger.ENABLE_ERROR = enable;
LoggingControl._notifyChange();
}
}, {
key: "enableDebug",
get: function get() {
return logger.ENABLE_DEBUG;
},
set: function set(enable) {
logger.ENABLE_DEBUG = enable;
LoggingControl._notifyChange();
}
}, {
key: "enableVerbose",
get: function get() {
return logger.ENABLE_VERBOSE;
},
set: function set(enable) {
logger.ENABLE_VERBOSE = enable;
LoggingControl._notifyChange();
}
}, {
key: "enableInfo",
get: function get() {
return logger.ENABLE_INFO;
},
set: function set(enable) {
logger.ENABLE_INFO = enable;
LoggingControl._notifyChange();
}
}, {
key: "enableWarn",
get: function get() {
return logger.ENABLE_WARN;
},
set: function set(enable) {
logger.ENABLE_WARN = enable;
LoggingControl._notifyChange();
}
}, {
key: "enableError",
get: function get() {
return logger.ENABLE_ERROR;
},
set: function set(enable) {
logger.ENABLE_ERROR = enable;
LoggingControl._notifyChange();
}
}, {
key: "getConfig",
value: function getConfig() {
return {
globalTag: logger.GLOBAL_TAG,
forceGlobalTag: logger.FORCE_GLOBAL_TAG,
enableVerbose: logger.ENABLE_VERBOSE,
enableDebug: logger.ENABLE_DEBUG,
enableInfo: logger.ENABLE_INFO,
enableWarn: logger.ENABLE_WARN,
enableError: logger.ENABLE_ERROR,
enableCallback: logger.ENABLE_CALLBACK
};
}
}, {
key: "applyConfig",
value: function applyConfig(config) {
logger.GLOBAL_TAG = config.globalTag;
logger.FORCE_GLOBAL_TAG = config.forceGlobalTag;
logger.ENABLE_VERBOSE = config.enableVerbose;
logger.ENABLE_DEBUG = config.enableDebug;
logger.ENABLE_INFO = config.enableInfo;
logger.ENABLE_WARN = config.enableWarn;
logger.ENABLE_ERROR = config.enableError;
logger.ENABLE_CALLBACK = config.enableCallback;
}
}, {
key: "_notifyChange",
value: function _notifyChange() {
var emitter = LoggingControl.emitter;
if (emitter.listenerCount('change') > 0) {
var config = LoggingControl.getConfig();
emitter.emit('change', config);
}
}
}, {
key: "registerListener",
value: function registerListener(listener) {
LoggingControl.emitter.addListener('change', listener);
}
}, {
key: "removeListener",
value: function removeListener(listener) {
LoggingControl.emitter.removeListener('change', listener);
}
}, {
key: "addLogListener",
value: function addLogListener(listener) {
logger.emitter.addListener('log', listener);
if (logger.emitter.listenerCount('log') > 0) {
logger.ENABLE_CALLBACK = true;
LoggingControl._notifyChange();
}
}
}, {
key: "removeLogListener",
value: function removeLogListener(listener) {
logger.emitter.removeListener('log', listener);
if (logger.emitter.listenerCount('log') === 0) {
logger.ENABLE_CALLBACK = false;
LoggingControl._notifyChange();
}
}
}]);
return LoggingControl;
}();
LoggingControl.emitter = new (events_default())();
/* harmony default export */ var logging_control = (LoggingControl);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/core/media-info.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var MediaInfo = /*#__PURE__*/function () {
function MediaInfo() {
classCallCheck_default()(this, MediaInfo);
this.mimeType = null;
this.duration = null;
this.hasAudio = null;
this.hasVideo = null;
this.audioCodec = null;
this.videoCodec = null;
this.audioDataRate = null;
this.videoDataRate = null;
this.audioSampleRate = null;
this.audioChannelCount = null;
this.width = null;
this.height = null;
this.fps = null;
this.profile = null;
this.level = null;
this.refFrames = null;
this.chromaFormat = null;
this.sarNum = null;
this.sarDen = null;
this.metadata = null;
this.segments = null; // MediaInfo[]
this.segmentCount = null;
this.hasKeyframesIndex = null;
this.keyframesIndex = null;
}
createClass_default()(MediaInfo, [{
key: "isComplete",
value: function isComplete() {
var audioInfoComplete = this.hasAudio === false || this.hasAudio === true && this.audioCodec != null && this.audioSampleRate != null && this.audioChannelCount != null;
var videoInfoComplete = this.hasVideo === false || this.hasVideo === true && this.videoCodec != null && this.width != null && this.height != null && this.fps != null && this.profile != null && this.level != null && this.refFrames != null && this.chromaFormat != null && this.sarNum != null && this.sarDen != null;
// keyframesIndex may not be present
return this.mimeType != null && this.duration != null && this.metadata != null && this.hasKeyframesIndex != null && audioInfoComplete && videoInfoComplete;
}
}, {
key: "isSeekable",
value: function isSeekable() {
return this.hasKeyframesIndex === true;
}
}, {
key: "getNearestKeyframe",
value: function getNearestKeyframe(milliseconds) {
if (this.keyframesIndex == null) {
return null;
}
var table = this.keyframesIndex;
var keyframeIdx = this._search(table.times, milliseconds);
return {
index: keyframeIdx,
milliseconds: table.times[keyframeIdx],
fileposition: table.filepositions[keyframeIdx]
};
}
}, {
key: "_search",
value: function _search(list, value) {
var idx = 0;
var last = list.length - 1;
var mid = 0;
var lbound = 0;
var ubound = last;
if (value < list[0]) {
idx = 0;
lbound = ubound + 1; // skip search
}
while (lbound <= ubound) {
mid = lbound + Math.floor((ubound - lbound) / 2);
if (mid === last || value >= list[mid] && value < list[mid + 1]) {
idx = mid;
break;
} else if (list[mid] < value) {
lbound = mid + 1;
} else {
ubound = mid - 1;
}
}
return idx;
}
}]);
return MediaInfo;
}();
/* harmony default export */ var media_info = (MediaInfo);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/utils/utf8-conv.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* This file is derived from C++ project libWinTF8 (https://github.com/m13253/libWinTF8)
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
function checkContinuation(uint8array, start, checkLength) {
var array = uint8array;
if (start + checkLength < array.length) {
while (checkLength--) {
if ((array[++start] & 0xC0) !== 0x80) return false;
}
return true;
} else {
return false;
}
}
function decodeUTF8(uint8array) {
var out = [];
var input = uint8array;
var i = 0;
var length = uint8array.length;
while (i < length) {
if (input[i] < 0x80) {
out.push(String.fromCharCode(input[i]));
++i;
continue;
} else if (input[i] < 0xC0) {
// fallthrough
} else if (input[i] < 0xE0) {
if (checkContinuation(input, i, 1)) {
var ucs4 = (input[i] & 0x1F) << 6 | input[i + 1] & 0x3F;
if (ucs4 >= 0x80) {
out.push(String.fromCharCode(ucs4 & 0xFFFF));
i += 2;
continue;
}
}
} else if (input[i] < 0xF0) {
if (checkContinuation(input, i, 2)) {
var _ucs = (input[i] & 0xF) << 12 | (input[i + 1] & 0x3F) << 6 | input[i + 2] & 0x3F;
if (_ucs >= 0x800 && (_ucs & 0xF800) !== 0xD800) {
out.push(String.fromCharCode(_ucs & 0xFFFF));
i += 3;
continue;
}
}
} else if (input[i] < 0xF8) {
if (checkContinuation(input, i, 3)) {
var _ucs2 = (input[i] & 0x7) << 18 | (input[i + 1] & 0x3F) << 12 | (input[i + 2] & 0x3F) << 6 | input[i + 3] & 0x3F;
if (_ucs2 > 0x10000 && _ucs2 < 0x110000) {
_ucs2 -= 0x10000;
out.push(String.fromCharCode(_ucs2 >>> 10 | 0xD800));
out.push(String.fromCharCode(_ucs2 & 0x3FF | 0xDC00));
i += 4;
continue;
}
}
}
out.push(String.fromCharCode(0xFFFD));
++i;
}
return out.join('');
}
/* harmony default export */ var utf8_conv = (decodeUTF8);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/demux/amf-parser.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var le = function () {
var buf = new ArrayBuffer(2);
new DataView(buf).setInt16(0, 256, true); // little-endian write
return new Int16Array(buf)[0] === 256; // platform-spec read, if equal then LE
}();
var AMF = /*#__PURE__*/function () {
function AMF() {
classCallCheck_default()(this, AMF);
}
createClass_default()(AMF, null, [{
key: "parseScriptData",
value: function parseScriptData(arrayBuffer, dataOffset, dataSize) {
var data = {};
try {
var name = AMF.parseValue(arrayBuffer, dataOffset, dataSize);
var value = AMF.parseValue(arrayBuffer, dataOffset + name.size, dataSize - name.size);
data[name.data] = value.data;
} catch (e) {
logger.e('AMF', e.toString());
}
return data;
}
}, {
key: "parseObject",
value: function parseObject(arrayBuffer, dataOffset, dataSize) {
if (dataSize < 3) {
throw new IllegalStateException('Data not enough when parse ScriptDataObject');
}
var name = AMF.parseString(arrayBuffer, dataOffset, dataSize);
var value = AMF.parseValue(arrayBuffer, dataOffset + name.size, dataSize - name.size);
var isObjectEnd = value.objectEnd;
return {
data: {
name: name.data,
value: value.data
},
size: name.size + value.size,
objectEnd: isObjectEnd
};
}
}, {
key: "parseVariable",
value: function parseVariable(arrayBuffer, dataOffset, dataSize) {
return AMF.parseObject(arrayBuffer, dataOffset, dataSize);
}
}, {
key: "parseString",
value: function parseString(arrayBuffer, dataOffset, dataSize) {
if (dataSize < 2) {
throw new IllegalStateException('Data not enough when parse String');
}
var v = new DataView(arrayBuffer, dataOffset, dataSize);
var length = v.getUint16(0, !le);
var str;
if (length > 0) {
str = utf8_conv(new Uint8Array(arrayBuffer, dataOffset + 2, length));
} else {
str = '';
}
return {
data: str,
size: 2 + length
};
}
}, {
key: "parseLongString",
value: function parseLongString(arrayBuffer, dataOffset, dataSize) {
if (dataSize < 4) {
throw new IllegalStateException('Data not enough when parse LongString');
}
var v = new DataView(arrayBuffer, dataOffset, dataSize);
var length = v.getUint32(0, !le);
var str;
if (length > 0) {
str = utf8_conv(new Uint8Array(arrayBuffer, dataOffset + 4, length));
} else {
str = '';
}
return {
data: str,
size: 4 + length
};
}
}, {
key: "parseDate",
value: function parseDate(arrayBuffer, dataOffset, dataSize) {
if (dataSize < 10) {
throw new IllegalStateException('Data size invalid when parse Date');
}
var v = new DataView(arrayBuffer, dataOffset, dataSize);
var timestamp = v.getFloat64(0, !le);
var localTimeOffset = v.getInt16(8, !le);
timestamp += localTimeOffset * 60 * 1000; // get UTC time
return {
data: new Date(timestamp),
size: 8 + 2
};
}
}, {
key: "parseValue",
value: function parseValue(arrayBuffer, dataOffset, dataSize) {
if (dataSize < 1) {
throw new IllegalStateException('Data not enough when parse Value');
}
var v = new DataView(arrayBuffer, dataOffset, dataSize);
var offset = 1;
var type = v.getUint8(0);
var value;
var objectEnd = false;
try {
switch (type) {
case 0:
// Number(Double) type
value = v.getFloat64(1, !le);
offset += 8;
break;
case 1:
{
// Boolean type
var b = v.getUint8(1);
value = b ? true : false;
offset += 1;
break;
}
case 2:
{
// String type
var amfstr = AMF.parseString(arrayBuffer, dataOffset + 1, dataSize - 1);
value = amfstr.data;
offset += amfstr.size;
break;
}
case 3:
{
// Object(s) type
value = {};
var terminal = 0; // workaround for malformed Objects which has missing ScriptDataObjectEnd
if ((v.getUint32(dataSize - 4, !le) & 0x00FFFFFF) === 9) {
terminal = 3;
}
while (offset < dataSize - 4) {
// 4 === type(UI8) + ScriptDataObjectEnd(UI24)
var amfobj = AMF.parseObject(arrayBuffer, dataOffset + offset, dataSize - offset - terminal);
if (amfobj.objectEnd) break;
value[amfobj.data.name] = amfobj.data.value;
offset += amfobj.size;
}
if (offset <= dataSize - 3) {
var marker = v.getUint32(offset - 1, !le) & 0x00FFFFFF;
if (marker === 9) {
offset += 3;
}
}
break;
}
case 8:
{
// ECMA array type (Mixed array)
value = {};
offset += 4; // ECMAArrayLength(UI32)
var _terminal = 0; // workaround for malformed MixedArrays which has missing ScriptDataObjectEnd
if ((v.getUint32(dataSize - 4, !le) & 0x00FFFFFF) === 9) {
_terminal = 3;
}
while (offset < dataSize - 8) {
// 8 === type(UI8) + ECMAArrayLength(UI32) + ScriptDataVariableEnd(UI24)
var amfvar = AMF.parseVariable(arrayBuffer, dataOffset + offset, dataSize - offset - _terminal);
if (amfvar.objectEnd) break;
value[amfvar.data.name] = amfvar.data.value;
offset += amfvar.size;
}
if (offset <= dataSize - 3) {
var _marker = v.getUint32(offset - 1, !le) & 0x00FFFFFF;
if (_marker === 9) {
offset += 3;
}
}
break;
}
case 9:
// ScriptDataObjectEnd
value = undefined;
offset = 1;
objectEnd = true;
break;
case 10:
{
// Strict array type
// ScriptDataValue[n]. NOTE: according to video_file_format_spec_v10_1.pdf
value = [];
var strictArrayLength = v.getUint32(1, !le);
offset += 4;
for (var i = 0; i < strictArrayLength; i++) {
var val = AMF.parseValue(arrayBuffer, dataOffset + offset, dataSize - offset);
value.push(val.data);
offset += val.size;
}
break;
}
case 11:
{
// Date type
var date = AMF.parseDate(arrayBuffer, dataOffset + 1, dataSize - 1);
value = date.data;
offset += date.size;
break;
}
case 12:
{
// Long string type
var amfLongStr = AMF.parseString(arrayBuffer, dataOffset + 1, dataSize - 1);
value = amfLongStr.data;
offset += amfLongStr.size;
break;
}
default:
// ignore and skip
offset = dataSize;
logger.w('AMF', 'Unsupported AMF value type ' + type);
}
} catch (e) {
logger.e('AMF', e.toString());
}
return {
data: value,
size: offset,
objectEnd: objectEnd
};
}
}]);
return AMF;
}();
/* harmony default export */ var amf_parser = (AMF);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/demux/exp-golomb.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// Exponential-Golomb buffer decoder
var ExpGolomb = /*#__PURE__*/function () {
function ExpGolomb(uint8array) {
classCallCheck_default()(this, ExpGolomb);
this.TAG = 'ExpGolomb';
this._buffer = uint8array;
this._buffer_index = 0;
this._total_bytes = uint8array.byteLength;
this._total_bits = uint8array.byteLength * 8;
this._current_word = 0;
this._current_word_bits_left = 0;
}
createClass_default()(ExpGolomb, [{
key: "destroy",
value: function destroy() {
this._buffer = null;
}
}, {
key: "_fillCurrentWord",
value: function _fillCurrentWord() {
var buffer_bytes_left = this._total_bytes - this._buffer_index;
if (buffer_bytes_left <= 0) throw new IllegalStateException('ExpGolomb: _fillCurrentWord() but no bytes available');
var bytes_read = Math.min(4, buffer_bytes_left);
var word = new Uint8Array(4);
word.set(this._buffer.subarray(this._buffer_index, this._buffer_index + bytes_read));
this._current_word = new DataView(word.buffer).getUint32(0, false);
this._buffer_index += bytes_read;
this._current_word_bits_left = bytes_read * 8;
}
}, {
key: "readBits",
value: function readBits(bits) {
if (bits > 32) throw new InvalidArgumentException('ExpGolomb: readBits() bits exceeded max 32bits!');
if (bits <= this._current_word_bits_left) {
var _result = this._current_word >>> 32 - bits;
this._current_word <<= bits;
this._current_word_bits_left -= bits;
return _result;
}
var result = this._current_word_bits_left ? this._current_word : 0;
result = result >>> 32 - this._current_word_bits_left;
var bits_need_left = bits - this._current_word_bits_left;
this._fillCurrentWord();
var bits_read_next = Math.min(bits_need_left, this._current_word_bits_left);
var result2 = this._current_word >>> 32 - bits_read_next;
this._current_word <<= bits_read_next;
this._current_word_bits_left -= bits_read_next;
result = result << bits_read_next | result2;
return result;
}
}, {
key: "readBool",
value: function readBool() {
return this.readBits(1) === 1;
}
}, {
key: "readByte",
value: function readByte() {
return this.readBits(8);
}
}, {
key: "_skipLeadingZero",
value: function _skipLeadingZero() {
var zero_count;
for (zero_count = 0; zero_count < this._current_word_bits_left; zero_count++) {
if (0 !== (this._current_word & 0x80000000 >>> zero_count)) {
this._current_word <<= zero_count;
this._current_word_bits_left -= zero_count;
return zero_count;
}
}
this._fillCurrentWord();
return zero_count + this._skipLeadingZero();
}
}, {
key: "readUEG",
value: function readUEG() {
// unsigned exponential golomb
var leading_zeros = this._skipLeadingZero();
return this.readBits(leading_zeros + 1) - 1;
}
}, {
key: "readSEG",
value: function readSEG() {
// signed exponential golomb
var value = this.readUEG();
if (value & 0x01) {
return value + 1 >>> 1;
} else {
return -1 * (value >>> 1);
}
}
}]);
return ExpGolomb;
}();
/* harmony default export */ var exp_golomb = (ExpGolomb);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/demux/sps-parser.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var SPSParser = /*#__PURE__*/function () {
function SPSParser() {
classCallCheck_default()(this, SPSParser);
}
createClass_default()(SPSParser, null, [{
key: "_ebsp2rbsp",
value: function _ebsp2rbsp(uint8array) {
var src = uint8array;
var src_length = src.byteLength;
var dst = new Uint8Array(src_length);
var dst_idx = 0;
for (var i = 0; i < src_length; i++) {
if (i >= 2) {
// Unescape: Skip 0x03 after 00 00
if (src[i] === 0x03 && src[i - 1] === 0x00 && src[i - 2] === 0x00) {
continue;
}
}
dst[dst_idx] = src[i];
dst_idx++;
}
return new Uint8Array(dst.buffer, 0, dst_idx);
}
}, {
key: "parseSPS",
value: function parseSPS(uint8array) {
var rbsp = SPSParser._ebsp2rbsp(uint8array);
var gb = new exp_golomb(rbsp);
gb.readByte();
var profile_idc = gb.readByte(); // profile_idc
gb.readByte(); // constraint_set_flags[5] + reserved_zero[3]
var level_idc = gb.readByte(); // level_idc
gb.readUEG(); // seq_parameter_set_id
var profile_string = SPSParser.getProfileString(profile_idc);
var level_string = SPSParser.getLevelString(level_idc);
var chroma_format_idc = 1;
var chroma_format = 420;
var chroma_format_table = [0, 420, 422, 444];
var bit_depth = 8;
if (profile_idc === 100 || profile_idc === 110 || profile_idc === 122 || profile_idc === 244 || profile_idc === 44 || profile_idc === 83 || profile_idc === 86 || profile_idc === 118 || profile_idc === 128 || profile_idc === 138 || profile_idc === 144) {
chroma_format_idc = gb.readUEG();
if (chroma_format_idc === 3) {
gb.readBits(1); // separate_colour_plane_flag
}
if (chroma_format_idc <= 3) {
chroma_format = chroma_format_table[chroma_format_idc];
}
bit_depth = gb.readUEG() + 8; // bit_depth_luma_minus8
gb.readUEG(); // bit_depth_chroma_minus8
gb.readBits(1); // qpprime_y_zero_transform_bypass_flag
if (gb.readBool()) {
// seq_scaling_matrix_present_flag
var scaling_list_count = chroma_format_idc !== 3 ? 8 : 12;
for (var i = 0; i < scaling_list_count; i++) {
if (gb.readBool()) {
// seq_scaling_list_present_flag
if (i < 6) {
SPSParser._skipScalingList(gb, 16);
} else {
SPSParser._skipScalingList(gb, 64);
}
}
}
}
}
gb.readUEG(); // log2_max_frame_num_minus4
var pic_order_cnt_type = gb.readUEG();
if (pic_order_cnt_type === 0) {
gb.readUEG(); // log2_max_pic_order_cnt_lsb_minus_4
} else if (pic_order_cnt_type === 1) {
gb.readBits(1); // delta_pic_order_always_zero_flag
gb.readSEG(); // offset_for_non_ref_pic
gb.readSEG(); // offset_for_top_to_bottom_field
var num_ref_frames_in_pic_order_cnt_cycle = gb.readUEG();
for (var _i = 0; _i < num_ref_frames_in_pic_order_cnt_cycle; _i++) {
gb.readSEG(); // offset_for_ref_frame
}
}
var ref_frames = gb.readUEG(); // max_num_ref_frames
gb.readBits(1); // gaps_in_frame_num_value_allowed_flag
var pic_width_in_mbs_minus1 = gb.readUEG();
var pic_height_in_map_units_minus1 = gb.readUEG();
var frame_mbs_only_flag = gb.readBits(1);
if (frame_mbs_only_flag === 0) {
gb.readBits(1); // mb_adaptive_frame_field_flag
}
gb.readBits(1); // direct_8x8_inference_flag
var frame_crop_left_offset = 0;
var frame_crop_right_offset = 0;
var frame_crop_top_offset = 0;
var frame_crop_bottom_offset = 0;
var frame_cropping_flag = gb.readBool();
if (frame_cropping_flag) {
frame_crop_left_offset = gb.readUEG();
frame_crop_right_offset = gb.readUEG();
frame_crop_top_offset = gb.readUEG();
frame_crop_bottom_offset = gb.readUEG();
}
var sar_width = 1,
sar_height = 1;
var fps = 0,
fps_fixed = true,
fps_num = 0,
fps_den = 0;
var vui_parameters_present_flag = gb.readBool();
if (vui_parameters_present_flag) {
if (gb.readBool()) {
// aspect_ratio_info_present_flag
var aspect_ratio_idc = gb.readByte();
var sar_w_table = [1, 12, 10, 16, 40, 24, 20, 32, 80, 18, 15, 64, 160, 4, 3, 2];
var sar_h_table = [1, 11, 11, 11, 33, 11, 11, 11, 33, 11, 11, 33, 99, 3, 2, 1];
if (aspect_ratio_idc > 0 && aspect_ratio_idc < 16) {
sar_width = sar_w_table[aspect_ratio_idc - 1];
sar_height = sar_h_table[aspect_ratio_idc - 1];
} else if (aspect_ratio_idc === 255) {
sar_width = gb.readByte() << 8 | gb.readByte();
sar_height = gb.readByte() << 8 | gb.readByte();
}
}
if (gb.readBool()) {
// overscan_info_present_flag
gb.readBool(); // overscan_appropriate_flag
}
if (gb.readBool()) {
// video_signal_type_present_flag
gb.readBits(4); // video_format & video_full_range_flag
if (gb.readBool()) {
// colour_description_present_flag
gb.readBits(24); // colour_primaries & transfer_characteristics & matrix_coefficients
}
}
if (gb.readBool()) {
// chroma_loc_info_present_flag
gb.readUEG(); // chroma_sample_loc_type_top_field
gb.readUEG(); // chroma_sample_loc_type_bottom_field
}
if (gb.readBool()) {
// timing_info_present_flag
var num_units_in_tick = gb.readBits(32);
var time_scale = gb.readBits(32);
fps_fixed = gb.readBool(); // fixed_frame_rate_flag
fps_num = time_scale;
fps_den = num_units_in_tick * 2;
fps = fps_num / fps_den;
}
}
var sarScale = 1;
if (sar_width !== 1 || sar_height !== 1) {
sarScale = sar_width / sar_height;
}
var crop_unit_x = 0,
crop_unit_y = 0;
if (chroma_format_idc === 0) {
crop_unit_x = 1;
crop_unit_y = 2 - frame_mbs_only_flag;
} else {
var sub_wc = chroma_format_idc === 3 ? 1 : 2;
var sub_hc = chroma_format_idc === 1 ? 2 : 1;
crop_unit_x = sub_wc;
crop_unit_y = sub_hc * (2 - frame_mbs_only_flag);
}
var codec_width = (pic_width_in_mbs_minus1 + 1) * 16;
var codec_height = (2 - frame_mbs_only_flag) * ((pic_height_in_map_units_minus1 + 1) * 16);
codec_width -= (frame_crop_left_offset + frame_crop_right_offset) * crop_unit_x;
codec_height -= (frame_crop_top_offset + frame_crop_bottom_offset) * crop_unit_y;
var present_width = Math.ceil(codec_width * sarScale);
gb.destroy();
gb = null;
return {
profile_string: profile_string,
// baseline, high, high10, ...
level_string: level_string,
// 3, 3.1, 4, 4.1, 5, 5.1, ...
bit_depth: bit_depth,
// 8bit, 10bit, ...
ref_frames: ref_frames,
chroma_format: chroma_format,
// 4:2:0, 4:2:2, ...
chroma_format_string: SPSParser.getChromaFormatString(chroma_format),
frame_rate: {
fixed: fps_fixed,
fps: fps,
fps_den: fps_den,
fps_num: fps_num
},
sar_ratio: {
width: sar_width,
height: sar_height
},
codec_size: {
width: codec_width,
height: codec_height
},
present_size: {
width: present_width,
height: codec_height
}
};
}
}, {
key: "_skipScalingList",
value: function _skipScalingList(gb, count) {
var last_scale = 8,
next_scale = 8;
var delta_scale = 0;
for (var i = 0; i < count; i++) {
if (next_scale !== 0) {
delta_scale = gb.readSEG();
next_scale = (last_scale + delta_scale + 256) % 256;
}
last_scale = next_scale === 0 ? last_scale : next_scale;
}
}
}, {
key: "getProfileString",
value: function getProfileString(profile_idc) {
switch (profile_idc) {
case 66:
return 'Baseline';
case 77:
return 'Main';
case 88:
return 'Extended';
case 100:
return 'High';
case 110:
return 'High10';
case 122:
return 'High422';
case 244:
return 'High444';
default:
return 'Unknown';
}
}
}, {
key: "getLevelString",
value: function getLevelString(level_idc) {
return (level_idc / 10).toFixed(1);
}
}, {
key: "getChromaFormatString",
value: function getChromaFormatString(chroma) {
switch (chroma) {
case 420:
return '4:2:0';
case 422:
return '4:2:2';
case 444:
return '4:4:4';
default:
return 'Unknown';
}
}
}]);
return SPSParser;
}();
/* harmony default export */ var sps_parser = (SPSParser);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/demux/demux-errors.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var DemuxErrors = {
OK: 'OK',
FORMAT_ERROR: 'FormatError',
FORMAT_UNSUPPORTED: 'FormatUnsupported',
CODEC_UNSUPPORTED: 'CodecUnsupported'
};
/* harmony default export */ var demux_errors = (DemuxErrors);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/demux/flv-demuxer.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
function Swap16(src) {
return src >>> 8 & 0xFF | (src & 0xFF) << 8;
}
function Swap32(src) {
return (src & 0xFF000000) >>> 24 | (src & 0x00FF0000) >>> 8 | (src & 0x0000FF00) << 8 | (src & 0x000000FF) << 24;
}
function ReadBig32(array, index) {
return array[index] << 24 | array[index + 1] << 16 | array[index + 2] << 8 | array[index + 3];
}
var FLVDemuxer = /*#__PURE__*/function () {
function FLVDemuxer(probeData, config) {
classCallCheck_default()(this, FLVDemuxer);
this.TAG = 'FLVDemuxer';
this._config = config;
this._onError = null;
this._onMediaInfo = null;
this._onMetaDataArrived = null;
this._onScriptDataArrived = null;
this._onTrackMetadata = null;
this._onDataAvailable = null;
this._dataOffset = probeData.dataOffset;
this._firstParse = true;
this._dispatch = false;
this._hasAudio = probeData.hasAudioTrack;
this._hasVideo = probeData.hasVideoTrack;
this._hasAudioFlagOverrided = false;
this._hasVideoFlagOverrided = false;
this._audioInitialMetadataDispatched = false;
this._videoInitialMetadataDispatched = false;
this._mediaInfo = new media_info();
this._mediaInfo.hasAudio = this._hasAudio;
this._mediaInfo.hasVideo = this._hasVideo;
this._metadata = null;
this._audioMetadata = null;
this._videoMetadata = null;
this._naluLengthSize = 4;
this._timestampBase = 0; // int32, in milliseconds
this._timescale = 1000;
this._duration = 0; // int32, in milliseconds
this._durationOverrided = false;
this._referenceFrameRate = {
fixed: true,
fps: 23.976,
fps_num: 23976,
fps_den: 1000
};
this._flvSoundRateTable = [5500, 11025, 22050, 44100, 48000];
this._mpegSamplingRates = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
this._mpegAudioV10SampleRateTable = [44100, 48000, 32000, 0];
this._mpegAudioV20SampleRateTable = [22050, 24000, 16000, 0];
this._mpegAudioV25SampleRateTable = [11025, 12000, 8000, 0];
this._mpegAudioL1BitRateTable = [0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, -1];
this._mpegAudioL2BitRateTable = [0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, -1];
this._mpegAudioL3BitRateTable = [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, -1];
this._videoTrack = {
type: 'video',
id: 1,
sequenceNumber: 0,
samples: [],
length: 0
};
this._audioTrack = {
type: 'audio',
id: 2,
sequenceNumber: 0,
samples: [],
length: 0
};
this._littleEndian = function () {
var buf = new ArrayBuffer(2);
new DataView(buf).setInt16(0, 256, true); // little-endian write
return new Int16Array(buf)[0] === 256; // platform-spec read, if equal then LE
}();
}
createClass_default()(FLVDemuxer, [{
key: "destroy",
value: function destroy() {
this._mediaInfo = null;
this._metadata = null;
this._audioMetadata = null;
this._videoMetadata = null;
this._videoTrack = null;
this._audioTrack = null;
this._onError = null;
this._onMediaInfo = null;
this._onMetaDataArrived = null;
this._onScriptDataArrived = null;
this._onTrackMetadata = null;
this._onDataAvailable = null;
}
}, {
key: "bindDataSource",
value: function bindDataSource(loader) {
loader.onDataArrival = this.parseChunks.bind(this);
return this;
}
// prototype: function(type: string, metadata: any): void
}, {
key: "onTrackMetadata",
get: function get() {
return this._onTrackMetadata;
},
set: function set(callback) {
this._onTrackMetadata = callback;
}
// prototype: function(mediaInfo: MediaInfo): void
}, {
key: "onMediaInfo",
get: function get() {
return this._onMediaInfo;
},
set: function set(callback) {
this._onMediaInfo = callback;
}
}, {
key: "onMetaDataArrived",
get: function get() {
return this._onMetaDataArrived;
},
set: function set(callback) {
this._onMetaDataArrived = callback;
}
}, {
key: "onScriptDataArrived",
get: function get() {
return this._onScriptDataArrived;
},
set: function set(callback) {
this._onScriptDataArrived = callback;
}
// prototype: function(type: number, info: string): void
}, {
key: "onError",
get: function get() {
return this._onError;
},
set: function set(callback) {
this._onError = callback;
}
// prototype: function(videoTrack: any, audioTrack: any): void
}, {
key: "onDataAvailable",
get: function get() {
return this._onDataAvailable;
},
set: function set(callback) {
this._onDataAvailable = callback;
}
// timestamp base for output samples, must be in milliseconds
}, {
key: "timestampBase",
get: function get() {
return this._timestampBase;
},
set: function set(base) {
this._timestampBase = base;
}
}, {
key: "overridedDuration",
get: function get() {
return this._duration;
}
// Force-override media duration. Must be in milliseconds, int32
,
set: function set(duration) {
this._durationOverrided = true;
this._duration = duration;
this._mediaInfo.duration = duration;
}
// Force-override audio track present flag, boolean
}, {
key: "overridedHasAudio",
set: function set(hasAudio) {
this._hasAudioFlagOverrided = true;
this._hasAudio = hasAudio;
this._mediaInfo.hasAudio = hasAudio;
}
// Force-override video track present flag, boolean
}, {
key: "overridedHasVideo",
set: function set(hasVideo) {
this._hasVideoFlagOverrided = true;
this._hasVideo = hasVideo;
this._mediaInfo.hasVideo = hasVideo;
}
}, {
key: "resetMediaInfo",
value: function resetMediaInfo() {
this._mediaInfo = new media_info();
}
}, {
key: "_isInitialMetadataDispatched",
value: function _isInitialMetadataDispatched() {
if (this._hasAudio && this._hasVideo) {
// both audio & video
return this._audioInitialMetadataDispatched && this._videoInitialMetadataDispatched;
}
if (this._hasAudio && !this._hasVideo) {
// audio only
return this._audioInitialMetadataDispatched;
}
if (!this._hasAudio && this._hasVideo) {
// video only
return this._videoInitialMetadataDispatched;
}
return false;
}
// function parseChunks(chunk: ArrayBuffer, byteStart: number): number;
}, {
key: "parseChunks",
value: function parseChunks(chunk, byteStart) {
if (!this._onError || !this._onMediaInfo || !this._onTrackMetadata || !this._onDataAvailable) {
throw new IllegalStateException('Flv: onError & onMediaInfo & onTrackMetadata & onDataAvailable callback must be specified');
}
var offset = 0;
var le = this._littleEndian;
if (byteStart === 0) {
// buffer with FLV header
if (chunk.byteLength > 13) {
var probeData = FLVDemuxer.probe(chunk);
offset = probeData.dataOffset;
} else {
return 0;
}
}
if (this._firstParse) {
// handle PreviousTagSize0 before Tag1
this._firstParse = false;
if (byteStart + offset !== this._dataOffset) {
logger.w(this.TAG, 'First time parsing but chunk byteStart invalid!');
}
var v = new DataView(chunk, offset);
var prevTagSize0 = v.getUint32(0, !le);
if (prevTagSize0 !== 0) {
logger.w(this.TAG, 'PrevTagSize0 !== 0 !!!');
}
offset += 4;
}
while (offset < chunk.byteLength) {
this._dispatch = true;
var _v = new DataView(chunk, offset);
if (offset + 11 + 4 > chunk.byteLength) {
// data not enough for parsing an flv tag
break;
}
var tagType = _v.getUint8(0);
var dataSize = _v.getUint32(0, !le) & 0x00FFFFFF;
if (offset + 11 + dataSize + 4 > chunk.byteLength) {
// data not enough for parsing actual data body
break;
}
if (tagType !== 8 && tagType !== 9 && tagType !== 18) {
logger.w(this.TAG, "Unsupported tag type ".concat(tagType, ", skipped"));
// consume the whole tag (skip it)
offset += 11 + dataSize + 4;
continue;
}
var ts2 = _v.getUint8(4);
var ts1 = _v.getUint8(5);
var ts0 = _v.getUint8(6);
var ts3 = _v.getUint8(7);
var timestamp = ts0 | ts1 << 8 | ts2 << 16 | ts3 << 24;
var streamId = _v.getUint32(7, !le) & 0x00FFFFFF;
if (streamId !== 0) {
logger.w(this.TAG, 'Meet tag which has StreamID != 0!');
}
var dataOffset = offset + 11;
switch (tagType) {
case 8:
// Audio
this._parseAudioData(chunk, dataOffset, dataSize, timestamp);
break;
case 9:
// Video
this._parseVideoData(chunk, dataOffset, dataSize, timestamp, byteStart + offset);
break;
case 18:
// ScriptDataObject
this._parseScriptData(chunk, dataOffset, dataSize);
break;
}
var prevTagSize = _v.getUint32(11 + dataSize, !le);
if (prevTagSize !== 11 + dataSize) {
logger.w(this.TAG, "Invalid PrevTagSize ".concat(prevTagSize));
}
offset += 11 + dataSize + 4; // tagBody + dataSize + prevTagSize
}
// dispatch parsed frames to consumer (typically, the remuxer)
if (this._isInitialMetadataDispatched()) {
if (this._dispatch && (this._audioTrack.length || this._videoTrack.length)) {
this._onDataAvailable(this._audioTrack, this._videoTrack);
}
}
return offset; // consumed bytes, just equals latest offset index
}
}, {
key: "_parseScriptData",
value: function _parseScriptData(arrayBuffer, dataOffset, dataSize) {
var scriptData = amf_parser.parseScriptData(arrayBuffer, dataOffset, dataSize);
if (scriptData.hasOwnProperty('onMetaData')) {
if (scriptData.onMetaData == null || typeof_default()(scriptData.onMetaData) !== 'object') {
logger.w(this.TAG, 'Invalid onMetaData structure!');
return;
}
if (this._metadata) {
logger.w(this.TAG, 'Found another onMetaData tag!');
}
this._metadata = scriptData;
var onMetaData = this._metadata.onMetaData;
if (this._onMetaDataArrived) {
this._onMetaDataArrived(Object.assign({}, onMetaData));
}
if (typeof onMetaData.hasAudio === 'boolean') {
// hasAudio
if (this._hasAudioFlagOverrided === false) {
this._hasAudio = onMetaData.hasAudio;
this._mediaInfo.hasAudio = this._hasAudio;
}
}
if (typeof onMetaData.hasVideo === 'boolean') {
// hasVideo
if (this._hasVideoFlagOverrided === false) {
this._hasVideo = onMetaData.hasVideo;
this._mediaInfo.hasVideo = this._hasVideo;
}
}
if (typeof onMetaData.audiodatarate === 'number') {
// audiodatarate
this._mediaInfo.audioDataRate = onMetaData.audiodatarate;
}
if (typeof onMetaData.videodatarate === 'number') {
// videodatarate
this._mediaInfo.videoDataRate = onMetaData.videodatarate;
}
if (typeof onMetaData.width === 'number') {
// width
this._mediaInfo.width = onMetaData.width;
}
if (typeof onMetaData.height === 'number') {
// height
this._mediaInfo.height = onMetaData.height;
}
if (typeof onMetaData.duration === 'number') {
// duration
if (!this._durationOverrided) {
var duration = Math.floor(onMetaData.duration * this._timescale);
this._duration = duration;
this._mediaInfo.duration = duration;
}
} else {
this._mediaInfo.duration = 0;
}
if (typeof onMetaData.framerate === 'number') {
// framerate
var fps_num = Math.floor(onMetaData.framerate * 1000);
if (fps_num > 0) {
var fps = fps_num / 1000;
this._referenceFrameRate.fixed = true;
this._referenceFrameRate.fps = fps;
this._referenceFrameRate.fps_num = fps_num;
this._referenceFrameRate.fps_den = 1000;
this._mediaInfo.fps = fps;
}
}
if (typeof_default()(onMetaData.keyframes) === 'object') {
// keyframes
this._mediaInfo.hasKeyframesIndex = true;
var keyframes = onMetaData.keyframes;
this._mediaInfo.keyframesIndex = this._parseKeyframesIndex(keyframes);
onMetaData.keyframes = null; // keyframes has been extracted, remove it
} else {
this._mediaInfo.hasKeyframesIndex = false;
}
this._dispatch = false;
this._mediaInfo.metadata = onMetaData;
logger.v(this.TAG, 'Parsed onMetaData');
if (this._mediaInfo.isComplete()) {
this._onMediaInfo(this._mediaInfo);
}
}
if (Object.keys(scriptData).length > 0) {
if (this._onScriptDataArrived) {
this._onScriptDataArrived(Object.assign({}, scriptData));
}
}
}
}, {
key: "_parseKeyframesIndex",
value: function _parseKeyframesIndex(keyframes) {
var times = [];
var filepositions = [];
// ignore first keyframe which is actually AVC Sequence Header (AVCDecoderConfigurationRecord)
for (var i = 1; i < keyframes.times.length; i++) {
var time = this._timestampBase + Math.floor(keyframes.times[i] * 1000);
times.push(time);
filepositions.push(keyframes.filepositions[i]);
}
return {
times: times,
filepositions: filepositions
};
}
}, {
key: "_parseAudioData",
value: function _parseAudioData(arrayBuffer, dataOffset, dataSize, tagTimestamp) {
if (dataSize <= 1) {
logger.w(this.TAG, 'Flv: Invalid audio packet, missing SoundData payload!');
return;
}
if (this._hasAudioFlagOverrided === true && this._hasAudio === false) {
// If hasAudio: false indicated explicitly in MediaDataSource,
// Ignore all the audio packets
return;
}
var le = this._littleEndian;
var v = new DataView(arrayBuffer, dataOffset, dataSize);
var soundSpec = v.getUint8(0);
var soundFormat = soundSpec >>> 4;
if (soundFormat !== 2 && soundFormat !== 10) {
// MP3 or AAC
this._onError(demux_errors.CODEC_UNSUPPORTED, 'Flv: Unsupported audio codec idx: ' + soundFormat);
return;
}
var soundRate = 0;
var soundRateIndex = (soundSpec & 12) >>> 2;
if (soundRateIndex >= 0 && soundRateIndex <= 4) {
soundRate = this._flvSoundRateTable[soundRateIndex];
} else {
this._onError(demux_errors.FORMAT_ERROR, 'Flv: Invalid audio sample rate idx: ' + soundRateIndex);
return;
}
var soundSize = (soundSpec & 2) >>> 1; // unused
var soundType = soundSpec & 1;
var meta = this._audioMetadata;
var track = this._audioTrack;
if (!meta) {
if (this._hasAudio === false && this._hasAudioFlagOverrided === false) {
this._hasAudio = true;
this._mediaInfo.hasAudio = true;
}
// initial metadata
meta = this._audioMetadata = {};
meta.type = 'audio';
meta.id = track.id;
meta.timescale = this._timescale;
meta.duration = this._duration;
meta.audioSampleRate = soundRate;
meta.channelCount = soundType === 0 ? 1 : 2;
}
if (soundFormat === 10) {
// AAC
var aacData = this._parseAACAudioData(arrayBuffer, dataOffset + 1, dataSize - 1);
if (aacData == undefined) {
return;
}
if (aacData.packetType === 0) {
// AAC sequence header (AudioSpecificConfig)
if (meta.config) {
logger.w(this.TAG, 'Found another AudioSpecificConfig!');
}
var misc = aacData.data;
meta.audioSampleRate = misc.samplingRate;
meta.channelCount = misc.channelCount;
meta.codec = misc.codec;
meta.originalCodec = misc.originalCodec;
meta.config = misc.config;
// The decode result of an aac sample is 1024 PCM samples
meta.refSampleDuration = 1024 / meta.audioSampleRate * meta.timescale;
logger.v(this.TAG, 'Parsed AudioSpecificConfig');
if (this._isInitialMetadataDispatched()) {
// Non-initial metadata, force dispatch (or flush) parsed frames to remuxer
if (this._dispatch && (this._audioTrack.length || this._videoTrack.length)) {
this._onDataAvailable(this._audioTrack, this._videoTrack);
}
} else {
this._audioInitialMetadataDispatched = true;
}
// then notify new metadata
this._dispatch = false;
this._onTrackMetadata('audio', meta);
var mi = this._mediaInfo;
mi.audioCodec = meta.originalCodec;
mi.audioSampleRate = meta.audioSampleRate;
mi.audioChannelCount = meta.channelCount;
if (mi.hasVideo) {
if (mi.videoCodec != null) {
mi.mimeType = 'video/x-flv; codecs="' + mi.videoCodec + ',' + mi.audioCodec + '"';
}
} else {
mi.mimeType = 'video/x-flv; codecs="' + mi.audioCodec + '"';
}
if (mi.isComplete()) {
this._onMediaInfo(mi);
}
} else if (aacData.packetType === 1) {
// AAC raw frame data
var dts = this._timestampBase + tagTimestamp;
var aacSample = {
unit: aacData.data,
length: aacData.data.byteLength,
dts: dts,
pts: dts
};
track.samples.push(aacSample);
track.length += aacData.data.length;
} else {
logger.e(this.TAG, "Flv: Unsupported AAC data type ".concat(aacData.packetType));
}
} else if (soundFormat === 2) {
// MP3
if (!meta.codec) {
// We need metadata for mp3 audio track, extract info from frame header
var _misc = this._parseMP3AudioData(arrayBuffer, dataOffset + 1, dataSize - 1, true);
if (_misc == undefined) {
return;
}
meta.audioSampleRate = _misc.samplingRate;
meta.channelCount = _misc.channelCount;
meta.codec = _misc.codec;
meta.originalCodec = _misc.originalCodec;
// The decode result of an mp3 sample is 1152 PCM samples
meta.refSampleDuration = 1152 / meta.audioSampleRate * meta.timescale;
logger.v(this.TAG, 'Parsed MPEG Audio Frame Header');
this._audioInitialMetadataDispatched = true;
this._onTrackMetadata('audio', meta);
var _mi = this._mediaInfo;
_mi.audioCodec = meta.codec;
_mi.audioSampleRate = meta.audioSampleRate;
_mi.audioChannelCount = meta.channelCount;
_mi.audioDataRate = _misc.bitRate;
if (_mi.hasVideo) {
if (_mi.videoCodec != null) {
_mi.mimeType = 'video/x-flv; codecs="' + _mi.videoCodec + ',' + _mi.audioCodec + '"';
}
} else {
_mi.mimeType = 'video/x-flv; codecs="' + _mi.audioCodec + '"';
}
if (_mi.isComplete()) {
this._onMediaInfo(_mi);
}
}
// This packet is always a valid audio packet, extract it
var data = this._parseMP3AudioData(arrayBuffer, dataOffset + 1, dataSize - 1, false);
if (data == undefined) {
return;
}
var _dts = this._timestampBase + tagTimestamp;
var mp3Sample = {
unit: data,
length: data.byteLength,
dts: _dts,
pts: _dts
};
track.samples.push(mp3Sample);
track.length += data.length;
}
}
}, {
key: "_parseAACAudioData",
value: function _parseAACAudioData(arrayBuffer, dataOffset, dataSize) {
if (dataSize <= 1) {
logger.w(this.TAG, 'Flv: Invalid AAC packet, missing AACPacketType or/and Data!');
return;
}
var result = {};
var array = new Uint8Array(arrayBuffer, dataOffset, dataSize);
result.packetType = array[0];
if (array[0] === 0) {
result.data = this._parseAACAudioSpecificConfig(arrayBuffer, dataOffset + 1, dataSize - 1);
} else {
result.data = array.subarray(1);
}
return result;
}
}, {
key: "_parseAACAudioSpecificConfig",
value: function _parseAACAudioSpecificConfig(arrayBuffer, dataOffset, dataSize) {
var array = new Uint8Array(arrayBuffer, dataOffset, dataSize);
var config = null;
/* Audio Object Type:
0: Null
1: AAC Main
2: AAC LC
3: AAC SSR (Scalable Sample Rate)
4: AAC LTP (Long Term Prediction)
5: HE-AAC / SBR (Spectral Band Replication)
6: AAC Scalable
*/
var audioObjectType = 0;
var originalAudioObjectType = 0;
var audioExtensionObjectType = null;
var samplingIndex = 0;
var extensionSamplingIndex = null;
// 5 bits
audioObjectType = originalAudioObjectType = array[0] >>> 3;
// 4 bits
samplingIndex = (array[0] & 0x07) << 1 | array[1] >>> 7;
if (samplingIndex < 0 || samplingIndex >= this._mpegSamplingRates.length) {
this._onError(demux_errors.FORMAT_ERROR, 'Flv: AAC invalid sampling frequency index!');
return;
}
var samplingFrequence = this._mpegSamplingRates[samplingIndex];
// 4 bits
var channelConfig = (array[1] & 0x78) >>> 3;
if (channelConfig < 0 || channelConfig >= 8) {
this._onError(demux_errors.FORMAT_ERROR, 'Flv: AAC invalid channel configuration');
return;
}
if (audioObjectType === 5) {
// HE-AAC?
// 4 bits
extensionSamplingIndex = (array[1] & 0x07) << 1 | array[2] >>> 7;
// 5 bits
audioExtensionObjectType = (array[2] & 0x7C) >>> 2;
}
// workarounds for various browsers
var userAgent = self.navigator.userAgent.toLowerCase();
if (userAgent.indexOf('firefox') !== -1) {
// firefox: use SBR (HE-AAC) if freq less than 24kHz
if (samplingIndex >= 6) {
audioObjectType = 5;
config = new Array(4);
extensionSamplingIndex = samplingIndex - 3;
} else {
// use LC-AAC
audioObjectType = 2;
config = new Array(2);
extensionSamplingIndex = samplingIndex;
}
} else if (userAgent.indexOf('android') !== -1) {
// android: always use LC-AAC
audioObjectType = 2;
config = new Array(2);
extensionSamplingIndex = samplingIndex;
} else {
// for other browsers, e.g. chrome...
// Always use HE-AAC to make it easier to switch aac codec profile
audioObjectType = 5;
extensionSamplingIndex = samplingIndex;
config = new Array(4);
if (samplingIndex >= 6) {
extensionSamplingIndex = samplingIndex - 3;
} else if (channelConfig === 1) {
// Mono channel
audioObjectType = 2;
config = new Array(2);
extensionSamplingIndex = samplingIndex;
}
}
config[0] = audioObjectType << 3;
config[0] |= (samplingIndex & 0x0F) >>> 1;
config[1] = (samplingIndex & 0x0F) << 7;
config[1] |= (channelConfig & 0x0F) << 3;
if (audioObjectType === 5) {
config[1] |= (extensionSamplingIndex & 0x0F) >>> 1;
config[2] = (extensionSamplingIndex & 0x01) << 7;
// extended audio object type: force to 2 (LC-AAC)
config[2] |= 2 << 2;
config[3] = 0;
}
return {
config: config,
samplingRate: samplingFrequence,
channelCount: channelConfig,
codec: 'mp4a.40.' + audioObjectType,
originalCodec: 'mp4a.40.' + originalAudioObjectType
};
}
}, {
key: "_parseMP3AudioData",
value: function _parseMP3AudioData(arrayBuffer, dataOffset, dataSize, requestHeader) {
if (dataSize < 4) {
logger.w(this.TAG, 'Flv: Invalid MP3 packet, header missing!');
return;
}
var le = this._littleEndian;
var array = new Uint8Array(arrayBuffer, dataOffset, dataSize);
var result = null;
if (requestHeader) {
if (array[0] !== 0xFF) {
return;
}
var ver = array[1] >>> 3 & 0x03;
var layer = (array[1] & 0x06) >> 1;
var bitrate_index = (array[2] & 0xF0) >>> 4;
var sampling_freq_index = (array[2] & 0x0C) >>> 2;
var channel_mode = array[3] >>> 6 & 0x03;
var channel_count = channel_mode !== 3 ? 2 : 1;
var sample_rate = 0;
var bit_rate = 0;
var object_type = 34; // Layer-3, listed in MPEG-4 Audio Object Types
var codec = 'mp3';
switch (ver) {
case 0:
// MPEG 2.5
sample_rate = this._mpegAudioV25SampleRateTable[sampling_freq_index];
break;
case 2:
// MPEG 2
sample_rate = this._mpegAudioV20SampleRateTable[sampling_freq_index];
break;
case 3:
// MPEG 1
sample_rate = this._mpegAudioV10SampleRateTable[sampling_freq_index];
break;
}
switch (layer) {
case 1:
// Layer 3
object_type = 34;
if (bitrate_index < this._mpegAudioL3BitRateTable.length) {
bit_rate = this._mpegAudioL3BitRateTable[bitrate_index];
}
break;
case 2:
// Layer 2
object_type = 33;
if (bitrate_index < this._mpegAudioL2BitRateTable.length) {
bit_rate = this._mpegAudioL2BitRateTable[bitrate_index];
}
break;
case 3:
// Layer 1
object_type = 32;
if (bitrate_index < this._mpegAudioL1BitRateTable.length) {
bit_rate = this._mpegAudioL1BitRateTable[bitrate_index];
}
break;
}
result = {
bitRate: bit_rate,
samplingRate: sample_rate,
channelCount: channel_count,
codec: codec,
originalCodec: codec
};
} else {
result = array;
}
return result;
}
}, {
key: "_parseVideoData",
value: function _parseVideoData(arrayBuffer, dataOffset, dataSize, tagTimestamp, tagPosition) {
if (dataSize <= 1) {
logger.w(this.TAG, 'Flv: Invalid video packet, missing VideoData payload!');
return;
}
if (this._hasVideoFlagOverrided === true && this._hasVideo === false) {
// If hasVideo: false indicated explicitly in MediaDataSource,
// Ignore all the video packets
return;
}
var spec = new Uint8Array(arrayBuffer, dataOffset, dataSize)[0];
var frameType = (spec & 240) >>> 4;
var codecId = spec & 15;
if (codecId !== 7) {
this._onError(demux_errors.CODEC_UNSUPPORTED, "Flv: Unsupported codec in video frame: ".concat(codecId));
return;
}
this._parseAVCVideoPacket(arrayBuffer, dataOffset + 1, dataSize - 1, tagTimestamp, tagPosition, frameType);
}
}, {
key: "_parseAVCVideoPacket",
value: function _parseAVCVideoPacket(arrayBuffer, dataOffset, dataSize, tagTimestamp, tagPosition, frameType) {
if (dataSize < 4) {
logger.w(this.TAG, 'Flv: Invalid AVC packet, missing AVCPacketType or/and CompositionTime');
return;
}
var le = this._littleEndian;
var v = new DataView(arrayBuffer, dataOffset, dataSize);
var packetType = v.getUint8(0);
var cts_unsigned = v.getUint32(0, !le) & 0x00FFFFFF;
var cts = cts_unsigned << 8 >> 8; // convert to 24-bit signed int
if (packetType === 0) {
// AVCDecoderConfigurationRecord
this._parseAVCDecoderConfigurationRecord(arrayBuffer, dataOffset + 4, dataSize - 4);
} else if (packetType === 1) {
// One or more Nalus
this._parseAVCVideoData(arrayBuffer, dataOffset + 4, dataSize - 4, tagTimestamp, tagPosition, frameType, cts);
} else if (packetType === 2) {
// empty, AVC end of sequence
} else {
this._onError(demux_errors.FORMAT_ERROR, "Flv: Invalid video packet type ".concat(packetType));
return;
}
}
}, {
key: "_parseAVCDecoderConfigurationRecord",
value: function _parseAVCDecoderConfigurationRecord(arrayBuffer, dataOffset, dataSize) {
if (dataSize < 7) {
logger.w(this.TAG, 'Flv: Invalid AVCDecoderConfigurationRecord, lack of data!');
return;
}
var meta = this._videoMetadata;
var track = this._videoTrack;
var le = this._littleEndian;
var v = new DataView(arrayBuffer, dataOffset, dataSize);
if (!meta) {
if (this._hasVideo === false && this._hasVideoFlagOverrided === false) {
this._hasVideo = true;
this._mediaInfo.hasVideo = true;
}
meta = this._videoMetadata = {};
meta.type = 'video';
meta.id = track.id;
meta.timescale = this._timescale;
meta.duration = this._duration;
} else {
if (typeof meta.avcc !== 'undefined') {
logger.w(this.TAG, 'Found another AVCDecoderConfigurationRecord!');
}
}
var version = v.getUint8(0); // configurationVersion
var avcProfile = v.getUint8(1); // avcProfileIndication
var profileCompatibility = v.getUint8(2); // profile_compatibility
var avcLevel = v.getUint8(3); // AVCLevelIndication
if (version !== 1 || avcProfile === 0) {
this._onError(demux_errors.FORMAT_ERROR, 'Flv: Invalid AVCDecoderConfigurationRecord');
return;
}
this._naluLengthSize = (v.getUint8(4) & 3) + 1; // lengthSizeMinusOne
if (this._naluLengthSize !== 3 && this._naluLengthSize !== 4) {
// holy shit!!!
this._onError(demux_errors.FORMAT_ERROR, "Flv: Strange NaluLengthSizeMinusOne: ".concat(this._naluLengthSize - 1));
return;
}
var spsCount = v.getUint8(5) & 31; // numOfSequenceParameterSets
if (spsCount === 0) {
this._onError(demux_errors.FORMAT_ERROR, 'Flv: Invalid AVCDecoderConfigurationRecord: No SPS');
return;
} else if (spsCount > 1) {
logger.w(this.TAG, "Flv: Strange AVCDecoderConfigurationRecord: SPS Count = ".concat(spsCount));
}
var offset = 6;
for (var i = 0; i < spsCount; i++) {
var len = v.getUint16(offset, !le); // sequenceParameterSetLength
offset += 2;
if (len === 0) {
continue;
}
// Notice: Nalu without startcode header (00 00 00 01)
var sps = new Uint8Array(arrayBuffer, dataOffset + offset, len);
offset += len;
var config = sps_parser.parseSPS(sps);
if (i !== 0) {
// ignore other sps's config
continue;
}
meta.codecWidth = config.codec_size.width;
meta.codecHeight = config.codec_size.height;
meta.presentWidth = config.present_size.width;
meta.presentHeight = config.present_size.height;
meta.profile = config.profile_string;
meta.level = config.level_string;
meta.bitDepth = config.bit_depth;
meta.chromaFormat = config.chroma_format;
meta.sarRatio = config.sar_ratio;
meta.frameRate = config.frame_rate;
if (config.frame_rate.fixed === false || config.frame_rate.fps_num === 0 || config.frame_rate.fps_den === 0) {
meta.frameRate = this._referenceFrameRate;
}
var fps_den = meta.frameRate.fps_den;
var fps_num = meta.frameRate.fps_num;
meta.refSampleDuration = meta.timescale * (fps_den / fps_num);
var codecArray = sps.subarray(1, 4);
var codecString = 'avc1.';
for (var j = 0; j < 3; j++) {
var h = codecArray[j].toString(16);
if (h.length < 2) {
h = '0' + h;
}
codecString += h;
}
meta.codec = codecString;
var mi = this._mediaInfo;
mi.width = meta.codecWidth;
mi.height = meta.codecHeight;
mi.fps = meta.frameRate.fps;
mi.profile = meta.profile;
mi.level = meta.level;
mi.refFrames = config.ref_frames;
mi.chromaFormat = config.chroma_format_string;
mi.sarNum = meta.sarRatio.width;
mi.sarDen = meta.sarRatio.height;
mi.videoCodec = codecString;
if (mi.hasAudio) {
if (mi.audioCodec != null) {
mi.mimeType = 'video/x-flv; codecs="' + mi.videoCodec + ',' + mi.audioCodec + '"';
}
} else {
mi.mimeType = 'video/x-flv; codecs="' + mi.videoCodec + '"';
}
if (mi.isComplete()) {
this._onMediaInfo(mi);
}
}
var ppsCount = v.getUint8(offset); // numOfPictureParameterSets
if (ppsCount === 0) {
this._onError(demux_errors.FORMAT_ERROR, 'Flv: Invalid AVCDecoderConfigurationRecord: No PPS');
return;
} else if (ppsCount > 1) {
logger.w(this.TAG, "Flv: Strange AVCDecoderConfigurationRecord: PPS Count = ".concat(ppsCount));
}
offset++;
for (var _i = 0; _i < ppsCount; _i++) {
var _len = v.getUint16(offset, !le); // pictureParameterSetLength
offset += 2;
if (_len === 0) {
continue;
}
// pps is useless for extracting video information
offset += _len;
}
meta.avcc = new Uint8Array(dataSize);
meta.avcc.set(new Uint8Array(arrayBuffer, dataOffset, dataSize), 0);
logger.v(this.TAG, 'Parsed AVCDecoderConfigurationRecord');
if (this._isInitialMetadataDispatched()) {
// flush parsed frames
if (this._dispatch && (this._audioTrack.length || this._videoTrack.length)) {
this._onDataAvailable(this._audioTrack, this._videoTrack);
}
} else {
this._videoInitialMetadataDispatched = true;
}
// notify new metadata
this._dispatch = false;
this._onTrackMetadata('video', meta);
}
}, {
key: "_parseAVCVideoData",
value: function _parseAVCVideoData(arrayBuffer, dataOffset, dataSize, tagTimestamp, tagPosition, frameType, cts) {
var le = this._littleEndian;
var v = new DataView(arrayBuffer, dataOffset, dataSize);
var units = [],
length = 0;
var offset = 0;
var lengthSize = this._naluLengthSize;
var dts = this._timestampBase + tagTimestamp;
var keyframe = frameType === 1; // from FLV Frame Type constants
while (offset < dataSize) {
if (offset + 4 >= dataSize) {
logger.w(this.TAG, "Malformed Nalu near timestamp ".concat(dts, ", offset = ").concat(offset, ", dataSize = ").concat(dataSize));
break; // data not enough for next Nalu
}
// Nalu with length-header (AVC1)
var naluSize = v.getUint32(offset, !le); // Big-Endian read
if (lengthSize === 3) {
naluSize >>>= 8;
}
if (naluSize > dataSize - lengthSize) {
logger.w(this.TAG, "Malformed Nalus near timestamp ".concat(dts, ", NaluSize > DataSize!"));
return;
}
var unitType = v.getUint8(offset + lengthSize) & 0x1F;
if (unitType === 5) {
// IDR
keyframe = true;
}
var data = new Uint8Array(arrayBuffer, dataOffset + offset, lengthSize + naluSize);
var unit = {
type: unitType,
data: data
};
units.push(unit);
length += data.byteLength;
offset += lengthSize + naluSize;
}
if (units.length) {
var track = this._videoTrack;
var avcSample = {
units: units,
length: length,
isKeyframe: keyframe,
dts: dts,
cts: cts,
pts: dts + cts
};
if (keyframe) {
avcSample.fileposition = tagPosition;
}
track.samples.push(avcSample);
track.length += length;
}
}
}], [{
key: "probe",
value: function probe(buffer) {
var data = new Uint8Array(buffer);
var mismatch = {
match: false
};
if (data[0] !== 0x46 || data[1] !== 0x4C || data[2] !== 0x56 || data[3] !== 0x01) {
return mismatch;
}
var hasAudio = (data[4] & 4) >>> 2 !== 0;
var hasVideo = (data[4] & 1) !== 0;
var offset = ReadBig32(data, 5);
if (offset < 9) {
return mismatch;
}
return {
match: true,
consumed: offset,
dataOffset: offset,
hasAudioTrack: hasAudio,
hasVideoTrack: hasVideo
};
}
}]);
return FLVDemuxer;
}();
/* harmony default export */ var flv_demuxer = (FLVDemuxer);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/remux/mp4-generator.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* This file is derived from dailymotion's hls.js library (hls.js/src/remux/mp4-generator.js)
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// MP4 boxes generator for ISO BMFF (ISO Base Media File Format, defined in ISO/IEC 14496-12)
var MP4 = /*#__PURE__*/function () {
function MP4() {
classCallCheck_default()(this, MP4);
}
createClass_default()(MP4, null, [{
key: "init",
value: function init() {
MP4.types = {
avc1: [],
avcC: [],
btrt: [],
dinf: [],
dref: [],
esds: [],
ftyp: [],
hdlr: [],
mdat: [],
mdhd: [],
mdia: [],
mfhd: [],
minf: [],
moof: [],
moov: [],
mp4a: [],
mvex: [],
mvhd: [],
sdtp: [],
stbl: [],
stco: [],
stsc: [],
stsd: [],
stsz: [],
stts: [],
tfdt: [],
tfhd: [],
traf: [],
trak: [],
trun: [],
trex: [],
tkhd: [],
vmhd: [],
smhd: [],
'.mp3': []
};
for (var name in MP4.types) {
if (MP4.types.hasOwnProperty(name)) {
MP4.types[name] = [name.charCodeAt(0), name.charCodeAt(1), name.charCodeAt(2), name.charCodeAt(3)];
}
}
var constants = MP4.constants = {};
constants.FTYP = new Uint8Array([0x69, 0x73, 0x6F, 0x6D,
// major_brand: isom
0x0, 0x0, 0x0, 0x1,
// minor_version: 0x01
0x69, 0x73, 0x6F, 0x6D,
// isom
0x61, 0x76, 0x63, 0x31 // avc1
]);
constants.STSD_PREFIX = new Uint8Array([0x00, 0x00, 0x00, 0x00,
// version(0) + flags
0x00, 0x00, 0x00, 0x01 // entry_count
]);
constants.STTS = new Uint8Array([0x00, 0x00, 0x00, 0x00,
// version(0) + flags
0x00, 0x00, 0x00, 0x00 // entry_count
]);
constants.STSC = constants.STCO = constants.STTS;
constants.STSZ = new Uint8Array([0x00, 0x00, 0x00, 0x00,
// version(0) + flags
0x00, 0x00, 0x00, 0x00,
// sample_size
0x00, 0x00, 0x00, 0x00 // sample_count
]);
constants.HDLR_VIDEO = new Uint8Array([0x00, 0x00, 0x00, 0x00,
// version(0) + flags
0x00, 0x00, 0x00, 0x00,
// pre_defined
0x76, 0x69, 0x64, 0x65,
// handler_type: 'vide'
0x00, 0x00, 0x00, 0x00,
// reserved: 3 * 4 bytes
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x69, 0x64, 0x65, 0x6F, 0x48, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x72, 0x00 // name: VideoHandler
]);
constants.HDLR_AUDIO = new Uint8Array([0x00, 0x00, 0x00, 0x00,
// version(0) + flags
0x00, 0x00, 0x00, 0x00,
// pre_defined
0x73, 0x6F, 0x75, 0x6E,
// handler_type: 'soun'
0x00, 0x00, 0x00, 0x00,
// reserved: 3 * 4 bytes
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, 0x6F, 0x75, 0x6E, 0x64, 0x48, 0x61, 0x6E, 0x64, 0x6C, 0x65, 0x72, 0x00 // name: SoundHandler
]);
constants.DREF = new Uint8Array([0x00, 0x00, 0x00, 0x00,
// version(0) + flags
0x00, 0x00, 0x00, 0x01,
// entry_count
0x00, 0x00, 0x00, 0x0C,
// entry_size
0x75, 0x72, 0x6C, 0x20,
// type 'url '
0x00, 0x00, 0x00, 0x01 // version(0) + flags
]);
// Sound media header
constants.SMHD = new Uint8Array([0x00, 0x00, 0x00, 0x00,
// version(0) + flags
0x00, 0x00, 0x00, 0x00 // balance(2) + reserved(2)
]);
// video media header
constants.VMHD = new Uint8Array([0x00, 0x00, 0x00, 0x01,
// version(0) + flags
0x00, 0x00,
// graphicsmode: 2 bytes
0x00, 0x00, 0x00, 0x00,
// opcolor: 3 * 2 bytes
0x00, 0x00]);
}
// Generate a box
}, {
key: "box",
value: function box(type) {
var size = 8;
var result = null;
var datas = Array.prototype.slice.call(arguments, 1);
var arrayCount = datas.length;
for (var i = 0; i < arrayCount; i++) {
size += datas[i].byteLength;
}
result = new Uint8Array(size);
result[0] = size >>> 24 & 0xFF; // size
result[1] = size >>> 16 & 0xFF;
result[2] = size >>> 8 & 0xFF;
result[3] = size & 0xFF;
result.set(type, 4); // type
var offset = 8;
for (var _i = 0; _i < arrayCount; _i++) {
// data body
result.set(datas[_i], offset);
offset += datas[_i].byteLength;
}
return result;
}
// emit ftyp & moov
}, {
key: "generateInitSegment",
value: function generateInitSegment(meta) {
var ftyp = MP4.box(MP4.types.ftyp, MP4.constants.FTYP);
var moov = MP4.moov(meta);
var result = new Uint8Array(ftyp.byteLength + moov.byteLength);
result.set(ftyp, 0);
result.set(moov, ftyp.byteLength);
return result;
}
// Movie metadata box
}, {
key: "moov",
value: function moov(meta) {
var mvhd = MP4.mvhd(meta.timescale, meta.duration);
var trak = MP4.trak(meta);
var mvex = MP4.mvex(meta);
return MP4.box(MP4.types.moov, mvhd, trak, mvex);
}
// Movie header box
}, {
key: "mvhd",
value: function mvhd(timescale, duration) {
return MP4.box(MP4.types.mvhd, new Uint8Array([0x00, 0x00, 0x00, 0x00,
// version(0) + flags
0x00, 0x00, 0x00, 0x00,
// creation_time
0x00, 0x00, 0x00, 0x00,
// modification_time
timescale >>> 24 & 0xFF,
// timescale: 4 bytes
timescale >>> 16 & 0xFF, timescale >>> 8 & 0xFF, timescale & 0xFF, duration >>> 24 & 0xFF,
// duration: 4 bytes
duration >>> 16 & 0xFF, duration >>> 8 & 0xFF, duration & 0xFF, 0x00, 0x01, 0x00, 0x00,
// Preferred rate: 1.0
0x01, 0x00, 0x00, 0x00,
// PreferredVolume(1.0, 2bytes) + reserved(2bytes)
0x00, 0x00, 0x00, 0x00,
// reserved: 4 + 4 bytes
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
// ----begin composition matrix----
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
// ----end composition matrix----
0x00, 0x00, 0x00, 0x00,
// ----begin pre_defined 6 * 4 bytes----
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// ----end pre_defined 6 * 4 bytes----
0xFF, 0xFF, 0xFF, 0xFF // next_track_ID
]));
}
// Track box
}, {
key: "trak",
value: function trak(meta) {
return MP4.box(MP4.types.trak, MP4.tkhd(meta), MP4.mdia(meta));
}
// Track header box
}, {
key: "tkhd",
value: function tkhd(meta) {
var trackId = meta.id,
duration = meta.duration;
var width = meta.presentWidth,
height = meta.presentHeight;
return MP4.box(MP4.types.tkhd, new Uint8Array([0x00, 0x00, 0x00, 0x07,
// version(0) + flags
0x00, 0x00, 0x00, 0x00,
// creation_time
0x00, 0x00, 0x00, 0x00,
// modification_time
trackId >>> 24 & 0xFF,
// track_ID: 4 bytes
trackId >>> 16 & 0xFF, trackId >>> 8 & 0xFF, trackId & 0xFF, 0x00, 0x00, 0x00, 0x00,
// reserved: 4 bytes
duration >>> 24 & 0xFF,
// duration: 4 bytes
duration >>> 16 & 0xFF, duration >>> 8 & 0xFF, duration & 0xFF, 0x00, 0x00, 0x00, 0x00,
// reserved: 2 * 4 bytes
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// layer(2bytes) + alternate_group(2bytes)
0x00, 0x00, 0x00, 0x00,
// volume(2bytes) + reserved(2bytes)
0x00, 0x01, 0x00, 0x00,
// ----begin composition matrix----
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
// ----end composition matrix----
width >>> 8 & 0xFF,
// width and height
width & 0xFF, 0x00, 0x00, height >>> 8 & 0xFF, height & 0xFF, 0x00, 0x00]));
}
// Media Box
}, {
key: "mdia",
value: function mdia(meta) {
return MP4.box(MP4.types.mdia, MP4.mdhd(meta), MP4.hdlr(meta), MP4.minf(meta));
}
// Media header box
}, {
key: "mdhd",
value: function mdhd(meta) {
var timescale = meta.timescale;
var duration = meta.duration;
return MP4.box(MP4.types.mdhd, new Uint8Array([0x00, 0x00, 0x00, 0x00,
// version(0) + flags
0x00, 0x00, 0x00, 0x00,
// creation_time
0x00, 0x00, 0x00, 0x00,
// modification_time
timescale >>> 24 & 0xFF,
// timescale: 4 bytes
timescale >>> 16 & 0xFF, timescale >>> 8 & 0xFF, timescale & 0xFF, duration >>> 24 & 0xFF,
// duration: 4 bytes
duration >>> 16 & 0xFF, duration >>> 8 & 0xFF, duration & 0xFF, 0x55, 0xC4,
// language: und (undetermined)
0x00, 0x00 // pre_defined = 0
]));
}
// Media handler reference box
}, {
key: "hdlr",
value: function hdlr(meta) {
var data = null;
if (meta.type === 'audio') {
data = MP4.constants.HDLR_AUDIO;
} else {
data = MP4.constants.HDLR_VIDEO;
}
return MP4.box(MP4.types.hdlr, data);
}
// Media infomation box
}, {
key: "minf",
value: function minf(meta) {
var xmhd = null;
if (meta.type === 'audio') {
xmhd = MP4.box(MP4.types.smhd, MP4.constants.SMHD);
} else {
xmhd = MP4.box(MP4.types.vmhd, MP4.constants.VMHD);
}
return MP4.box(MP4.types.minf, xmhd, MP4.dinf(), MP4.stbl(meta));
}
// Data infomation box
}, {
key: "dinf",
value: function dinf() {
var result = MP4.box(MP4.types.dinf, MP4.box(MP4.types.dref, MP4.constants.DREF));
return result;
}
// Sample table box
}, {
key: "stbl",
value: function stbl(meta) {
var result = MP4.box(MP4.types.stbl,
// type: stbl
MP4.stsd(meta),
// Sample Description Table
MP4.box(MP4.types.stts, MP4.constants.STTS),
// Time-To-Sample
MP4.box(MP4.types.stsc, MP4.constants.STSC),
// Sample-To-Chunk
MP4.box(MP4.types.stsz, MP4.constants.STSZ),
// Sample size
MP4.box(MP4.types.stco, MP4.constants.STCO) // Chunk offset
);
return result;
}
// Sample description box
}, {
key: "stsd",
value: function stsd(meta) {
if (meta.type === 'audio') {
if (meta.codec === 'mp3') {
return MP4.box(MP4.types.stsd, MP4.constants.STSD_PREFIX, MP4.mp3(meta));
}
// else: aac -> mp4a
return MP4.box(MP4.types.stsd, MP4.constants.STSD_PREFIX, MP4.mp4a(meta));
} else {
return MP4.box(MP4.types.stsd, MP4.constants.STSD_PREFIX, MP4.avc1(meta));
}
}
}, {
key: "mp3",
value: function mp3(meta) {
var channelCount = meta.channelCount;
var sampleRate = meta.audioSampleRate;
var data = new Uint8Array([0x00, 0x00, 0x00, 0x00,
// reserved(4)
0x00, 0x00, 0x00, 0x01,
// reserved(2) + data_reference_index(2)
0x00, 0x00, 0x00, 0x00,
// reserved: 2 * 4 bytes
0x00, 0x00, 0x00, 0x00, 0x00, channelCount,
// channelCount(2)
0x00, 0x10,
// sampleSize(2)
0x00, 0x00, 0x00, 0x00,
// reserved(4)
sampleRate >>> 8 & 0xFF,
// Audio sample rate
sampleRate & 0xFF, 0x00, 0x00]);
return MP4.box(MP4.types['.mp3'], data);
}
}, {
key: "mp4a",
value: function mp4a(meta) {
var channelCount = meta.channelCount;
var sampleRate = meta.audioSampleRate;
var data = new Uint8Array([0x00, 0x00, 0x00, 0x00,
// reserved(4)
0x00, 0x00, 0x00, 0x01,
// reserved(2) + data_reference_index(2)
0x00, 0x00, 0x00, 0x00,
// reserved: 2 * 4 bytes
0x00, 0x00, 0x00, 0x00, 0x00, channelCount,
// channelCount(2)
0x00, 0x10,
// sampleSize(2)
0x00, 0x00, 0x00, 0x00,
// reserved(4)
sampleRate >>> 8 & 0xFF,
// Audio sample rate
sampleRate & 0xFF, 0x00, 0x00]);
return MP4.box(MP4.types.mp4a, data, MP4.esds(meta));
}
}, {
key: "esds",
value: function esds(meta) {
var config = meta.config || [];
var configSize = config.length;
var data = new Uint8Array([0x00, 0x00, 0x00, 0x00,
// version 0 + flags
0x03,
// descriptor_type
0x17 + configSize,
// length3
0x00, 0x01,
// es_id
0x00,
// stream_priority
0x04,
// descriptor_type
0x0F + configSize,
// length
0x40,
// codec: mpeg4_audio
0x15,
// stream_type: Audio
0x00, 0x00, 0x00,
// buffer_size
0x00, 0x00, 0x00, 0x00,
// maxBitrate
0x00, 0x00, 0x00, 0x00,
// avgBitrate
0x05 // descriptor_type
].concat([configSize]).concat(config).concat([0x06, 0x01, 0x02 // GASpecificConfig
]));
return MP4.box(MP4.types.esds, data);
}
}, {
key: "avc1",
value: function avc1(meta) {
var avcc = meta.avcc;
var width = meta.codecWidth,
height = meta.codecHeight;
var data = new Uint8Array([0x00, 0x00, 0x00, 0x00,
// reserved(4)
0x00, 0x00, 0x00, 0x01,
// reserved(2) + data_reference_index(2)
0x00, 0x00, 0x00, 0x00,
// pre_defined(2) + reserved(2)
0x00, 0x00, 0x00, 0x00,
// pre_defined: 3 * 4 bytes
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, width >>> 8 & 0xFF,
// width: 2 bytes
width & 0xFF, height >>> 8 & 0xFF,
// height: 2 bytes
height & 0xFF, 0x00, 0x48, 0x00, 0x00,
// horizresolution: 4 bytes
0x00, 0x48, 0x00, 0x00,
// vertresolution: 4 bytes
0x00, 0x00, 0x00, 0x00,
// reserved: 4 bytes
0x00, 0x01,
// frame_count
0x0A,
// strlen
0x78, 0x71, 0x71, 0x2F,
// compressorname: 32 bytes
0x66, 0x6C, 0x76, 0x2E, 0x6A, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,
// depth
0xFF, 0xFF // pre_defined = -1
]);
return MP4.box(MP4.types.avc1, data, MP4.box(MP4.types.avcC, avcc));
}
// Movie Extends box
}, {
key: "mvex",
value: function mvex(meta) {
return MP4.box(MP4.types.mvex, MP4.trex(meta));
}
// Track Extends box
}, {
key: "trex",
value: function trex(meta) {
var trackId = meta.id;
var data = new Uint8Array([0x00, 0x00, 0x00, 0x00,
// version(0) + flags
trackId >>> 24 & 0xFF,
// track_ID
trackId >>> 16 & 0xFF, trackId >>> 8 & 0xFF, trackId & 0xFF, 0x00, 0x00, 0x00, 0x01,
// default_sample_description_index
0x00, 0x00, 0x00, 0x00,
// default_sample_duration
0x00, 0x00, 0x00, 0x00,
// default_sample_size
0x00, 0x01, 0x00, 0x01 // default_sample_flags
]);
return MP4.box(MP4.types.trex, data);
}
// Movie fragment box
}, {
key: "moof",
value: function moof(track, baseMediaDecodeTime) {
return MP4.box(MP4.types.moof, MP4.mfhd(track.sequenceNumber), MP4.traf(track, baseMediaDecodeTime));
}
}, {
key: "mfhd",
value: function mfhd(sequenceNumber) {
var data = new Uint8Array([0x00, 0x00, 0x00, 0x00, sequenceNumber >>> 24 & 0xFF,
// sequence_number: int32
sequenceNumber >>> 16 & 0xFF, sequenceNumber >>> 8 & 0xFF, sequenceNumber & 0xFF]);
return MP4.box(MP4.types.mfhd, data);
}
// Track fragment box
}, {
key: "traf",
value: function traf(track, baseMediaDecodeTime) {
var trackId = track.id;
// Track fragment header box
var tfhd = MP4.box(MP4.types.tfhd, new Uint8Array([0x00, 0x00, 0x00, 0x00,
// version(0) & flags
trackId >>> 24 & 0xFF,
// track_ID
trackId >>> 16 & 0xFF, trackId >>> 8 & 0xFF, trackId & 0xFF]));
// Track Fragment Decode Time
var tfdt = MP4.box(MP4.types.tfdt, new Uint8Array([0x00, 0x00, 0x00, 0x00,
// version(0) & flags
baseMediaDecodeTime >>> 24 & 0xFF,
// baseMediaDecodeTime: int32
baseMediaDecodeTime >>> 16 & 0xFF, baseMediaDecodeTime >>> 8 & 0xFF, baseMediaDecodeTime & 0xFF]));
var sdtp = MP4.sdtp(track);
var trun = MP4.trun(track, sdtp.byteLength + 16 + 16 + 8 + 16 + 8 + 8);
return MP4.box(MP4.types.traf, tfhd, tfdt, trun, sdtp);
}
// Sample Dependency Type box
}, {
key: "sdtp",
value: function sdtp(track) {
var samples = track.samples || [];
var sampleCount = samples.length;
var data = new Uint8Array(4 + sampleCount);
// 0~4 bytes: version(0) & flags
for (var i = 0; i < sampleCount; i++) {
var flags = samples[i].flags;
data[i + 4] = flags.isLeading << 6 // is_leading: 2 (bit)
| flags.dependsOn << 4 // sample_depends_on
| flags.isDependedOn << 2 // sample_is_depended_on
| flags.hasRedundancy; // sample_has_redundancy
}
return MP4.box(MP4.types.sdtp, data);
}
// Track fragment run box
}, {
key: "trun",
value: function trun(track, offset) {
var samples = track.samples || [];
var sampleCount = samples.length;
var dataSize = 12 + 16 * sampleCount;
var data = new Uint8Array(dataSize);
offset += 8 + dataSize;
data.set([0x00, 0x00, 0x0F, 0x01,
// version(0) & flags
sampleCount >>> 24 & 0xFF,
// sample_count
sampleCount >>> 16 & 0xFF, sampleCount >>> 8 & 0xFF, sampleCount & 0xFF, offset >>> 24 & 0xFF,
// data_offset
offset >>> 16 & 0xFF, offset >>> 8 & 0xFF, offset & 0xFF], 0);
for (var i = 0; i < sampleCount; i++) {
var duration = samples[i].duration;
var size = samples[i].size;
var flags = samples[i].flags;
var cts = samples[i].cts;
data.set([duration >>> 24 & 0xFF,
// sample_duration
duration >>> 16 & 0xFF, duration >>> 8 & 0xFF, duration & 0xFF, size >>> 24 & 0xFF,
// sample_size
size >>> 16 & 0xFF, size >>> 8 & 0xFF, size & 0xFF, flags.isLeading << 2 | flags.dependsOn,
// sample_flags
flags.isDependedOn << 6 | flags.hasRedundancy << 4 | flags.isNonSync, 0x00, 0x00,
// sample_degradation_priority
cts >>> 24 & 0xFF,
// sample_composition_time_offset
cts >>> 16 & 0xFF, cts >>> 8 & 0xFF, cts & 0xFF], 12 + 16 * i);
}
return MP4.box(MP4.types.trun, data);
}
}, {
key: "mdat",
value: function mdat(data) {
return MP4.box(MP4.types.mdat, data);
}
}]);
return MP4;
}();
MP4.init();
/* harmony default export */ var mp4_generator = (MP4);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/remux/aac-silent.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* This file is modified from dailymotion's hls.js library (hls.js/src/helper/aac.js)
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var AAC = /*#__PURE__*/function () {
function AAC() {
classCallCheck_default()(this, AAC);
}
createClass_default()(AAC, null, [{
key: "getSilentFrame",
value: function getSilentFrame(codec, channelCount) {
if (codec === 'mp4a.40.2') {
// handle LC-AAC
if (channelCount === 1) {
return new Uint8Array([0x00, 0xc8, 0x00, 0x80, 0x23, 0x80]);
} else if (channelCount === 2) {
return new Uint8Array([0x21, 0x00, 0x49, 0x90, 0x02, 0x19, 0x00, 0x23, 0x80]);
} else if (channelCount === 3) {
return new Uint8Array([0x00, 0xc8, 0x00, 0x80, 0x20, 0x84, 0x01, 0x26, 0x40, 0x08, 0x64, 0x00, 0x8e]);
} else if (channelCount === 4) {
return new Uint8Array([0x00, 0xc8, 0x00, 0x80, 0x20, 0x84, 0x01, 0x26, 0x40, 0x08, 0x64, 0x00, 0x80, 0x2c, 0x80, 0x08, 0x02, 0x38]);
} else if (channelCount === 5) {
return new Uint8Array([0x00, 0xc8, 0x00, 0x80, 0x20, 0x84, 0x01, 0x26, 0x40, 0x08, 0x64, 0x00, 0x82, 0x30, 0x04, 0x99, 0x00, 0x21, 0x90, 0x02, 0x38]);
} else if (channelCount === 6) {
return new Uint8Array([0x00, 0xc8, 0x00, 0x80, 0x20, 0x84, 0x01, 0x26, 0x40, 0x08, 0x64, 0x00, 0x82, 0x30, 0x04, 0x99, 0x00, 0x21, 0x90, 0x02, 0x00, 0xb2, 0x00, 0x20, 0x08, 0xe0]);
}
} else {
// handle HE-AAC (mp4a.40.5 / mp4a.40.29)
if (channelCount === 1) {
// ffmpeg -y -f lavfi -i "aevalsrc=0:d=0.05" -c:a libfdk_aac -profile:a aac_he -b:a 4k output.aac && hexdump -v -e '16/1 "0x%x," "\n"' -v output.aac
return new Uint8Array([0x1, 0x40, 0x22, 0x80, 0xa3, 0x4e, 0xe6, 0x80, 0xba, 0x8, 0x0, 0x0, 0x0, 0x1c, 0x6, 0xf1, 0xc1, 0xa, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5e]);
} else if (channelCount === 2) {
// ffmpeg -y -f lavfi -i "aevalsrc=0|0:d=0.05" -c:a libfdk_aac -profile:a aac_he_v2 -b:a 4k output.aac && hexdump -v -e '16/1 "0x%x," "\n"' -v output.aac
return new Uint8Array([0x1, 0x40, 0x22, 0x80, 0xa3, 0x5e, 0xe6, 0x80, 0xba, 0x8, 0x0, 0x0, 0x0, 0x0, 0x95, 0x0, 0x6, 0xf1, 0xa1, 0xa, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5e]);
} else if (channelCount === 3) {
// ffmpeg -y -f lavfi -i "aevalsrc=0|0|0:d=0.05" -c:a libfdk_aac -profile:a aac_he_v2 -b:a 4k output.aac && hexdump -v -e '16/1 "0x%x," "\n"' -v output.aac
return new Uint8Array([0x1, 0x40, 0x22, 0x80, 0xa3, 0x5e, 0xe6, 0x80, 0xba, 0x8, 0x0, 0x0, 0x0, 0x0, 0x95, 0x0, 0x6, 0xf1, 0xa1, 0xa, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5e]);
}
}
return null;
}
}]);
return AAC;
}();
/* harmony default export */ var aac_silent = (AAC);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/core/media-segment-info.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// Represents an media sample (audio / video)
var SampleInfo = /*#__PURE__*/createClass_default()(function SampleInfo(dts, pts, duration, originalDts, isSync) {
classCallCheck_default()(this, SampleInfo);
this.dts = dts;
this.pts = pts;
this.duration = duration;
this.originalDts = originalDts;
this.isSyncPoint = isSync;
this.fileposition = null;
});
// Media Segment concept is defined in Media Source Extensions spec.
// Particularly in ISO BMFF format, an Media Segment contains a moof box followed by a mdat box.
var MediaSegmentInfo = /*#__PURE__*/function () {
function MediaSegmentInfo() {
classCallCheck_default()(this, MediaSegmentInfo);
this.beginDts = 0;
this.endDts = 0;
this.beginPts = 0;
this.endPts = 0;
this.originalBeginDts = 0;
this.originalEndDts = 0;
this.syncPoints = []; // SampleInfo[n], for video IDR frames only
this.firstSample = null; // SampleInfo
this.lastSample = null; // SampleInfo
}
createClass_default()(MediaSegmentInfo, [{
key: "appendSyncPoint",
value: function appendSyncPoint(sampleInfo) {
// also called Random Access Point
sampleInfo.isSyncPoint = true;
this.syncPoints.push(sampleInfo);
}
}]);
return MediaSegmentInfo;
}();
// Ordered list for recording video IDR frames, sorted by originalDts
var IDRSampleList = /*#__PURE__*/function () {
function IDRSampleList() {
classCallCheck_default()(this, IDRSampleList);
this._list = [];
}
createClass_default()(IDRSampleList, [{
key: "clear",
value: function clear() {
this._list = [];
}
}, {
key: "appendArray",
value: function appendArray(syncPoints) {
var list = this._list;
if (syncPoints.length === 0) {
return;
}
if (list.length > 0 && syncPoints[0].originalDts < list[list.length - 1].originalDts) {
this.clear();
}
Array.prototype.push.apply(list, syncPoints);
}
}, {
key: "getLastSyncPointBeforeDts",
value: function getLastSyncPointBeforeDts(dts) {
if (this._list.length == 0) {
return null;
}
var list = this._list;
var idx = 0;
var last = list.length - 1;
var mid = 0;
var lbound = 0;
var ubound = last;
if (dts < list[0].dts) {
idx = 0;
lbound = ubound + 1;
}
while (lbound <= ubound) {
mid = lbound + Math.floor((ubound - lbound) / 2);
if (mid === last || dts >= list[mid].dts && dts < list[mid + 1].dts) {
idx = mid;
break;
} else if (list[mid].dts < dts) {
lbound = mid + 1;
} else {
ubound = mid - 1;
}
}
return this._list[idx];
}
}]);
return IDRSampleList;
}();
// Data structure for recording information of media segments in single track.
var MediaSegmentInfoList = /*#__PURE__*/function () {
function MediaSegmentInfoList(type) {
classCallCheck_default()(this, MediaSegmentInfoList);
this._type = type;
this._list = [];
this._lastAppendLocation = -1; // cached last insert location
}
createClass_default()(MediaSegmentInfoList, [{
key: "type",
get: function get() {
return this._type;
}
}, {
key: "length",
get: function get() {
return this._list.length;
}
}, {
key: "isEmpty",
value: function isEmpty() {
return this._list.length === 0;
}
}, {
key: "clear",
value: function clear() {
this._list = [];
this._lastAppendLocation = -1;
}
}, {
key: "_searchNearestSegmentBefore",
value: function _searchNearestSegmentBefore(originalBeginDts) {
var list = this._list;
if (list.length === 0) {
return -2;
}
var last = list.length - 1;
var mid = 0;
var lbound = 0;
var ubound = last;
var idx = 0;
if (originalBeginDts < list[0].originalBeginDts) {
idx = -1;
return idx;
}
while (lbound <= ubound) {
mid = lbound + Math.floor((ubound - lbound) / 2);
if (mid === last || originalBeginDts > list[mid].lastSample.originalDts && originalBeginDts < list[mid + 1].originalBeginDts) {
idx = mid;
break;
} else if (list[mid].originalBeginDts < originalBeginDts) {
lbound = mid + 1;
} else {
ubound = mid - 1;
}
}
return idx;
}
}, {
key: "_searchNearestSegmentAfter",
value: function _searchNearestSegmentAfter(originalBeginDts) {
return this._searchNearestSegmentBefore(originalBeginDts) + 1;
}
}, {
key: "append",
value: function append(mediaSegmentInfo) {
var list = this._list;
var msi = mediaSegmentInfo;
var lastAppendIdx = this._lastAppendLocation;
var insertIdx = 0;
if (lastAppendIdx !== -1 && lastAppendIdx < list.length && msi.originalBeginDts >= list[lastAppendIdx].lastSample.originalDts && (lastAppendIdx === list.length - 1 || lastAppendIdx < list.length - 1 && msi.originalBeginDts < list[lastAppendIdx + 1].originalBeginDts)) {
insertIdx = lastAppendIdx + 1; // use cached location idx
} else {
if (list.length > 0) {
insertIdx = this._searchNearestSegmentBefore(msi.originalBeginDts) + 1;
}
}
this._lastAppendLocation = insertIdx;
this._list.splice(insertIdx, 0, msi);
}
}, {
key: "getLastSegmentBefore",
value: function getLastSegmentBefore(originalBeginDts) {
var idx = this._searchNearestSegmentBefore(originalBeginDts);
if (idx >= 0) {
return this._list[idx];
} else {
// -1
return null;
}
}
}, {
key: "getLastSampleBefore",
value: function getLastSampleBefore(originalBeginDts) {
var segment = this.getLastSegmentBefore(originalBeginDts);
if (segment != null) {
return segment.lastSample;
} else {
return null;
}
}
}, {
key: "getLastSyncPointBefore",
value: function getLastSyncPointBefore(originalBeginDts) {
var segmentIdx = this._searchNearestSegmentBefore(originalBeginDts);
var syncPoints = this._list[segmentIdx].syncPoints;
while (syncPoints.length === 0 && segmentIdx > 0) {
segmentIdx--;
syncPoints = this._list[segmentIdx].syncPoints;
}
if (syncPoints.length > 0) {
return syncPoints[syncPoints.length - 1];
} else {
return null;
}
}
}]);
return MediaSegmentInfoList;
}();
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/remux/mp4-remuxer.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// Fragmented mp4 remuxer
var MP4Remuxer = /*#__PURE__*/function () {
function MP4Remuxer(config) {
classCallCheck_default()(this, MP4Remuxer);
this.TAG = 'MP4Remuxer';
this._config = config;
this._isLive = config.isLive === true ? true : false;
this._dtsBase = -1;
this._dtsBaseInited = false;
this._audioDtsBase = Infinity;
this._videoDtsBase = Infinity;
this._audioNextDts = undefined;
this._videoNextDts = undefined;
this._audioStashedLastSample = null;
this._videoStashedLastSample = null;
this._audioMeta = null;
this._videoMeta = null;
this._audioSegmentInfoList = new MediaSegmentInfoList('audio');
this._videoSegmentInfoList = new MediaSegmentInfoList('video');
this._onInitSegment = null;
this._onMediaSegment = null;
// Workaround for chrome < 50: Always force first sample as a Random Access Point in media segment
// see https://bugs.chromium.org/p/chromium/issues/detail?id=229412
this._forceFirstIDR = browser.chrome && (browser.version.major < 50 || browser.version.major === 50 && browser.version.build < 2661) ? true : false;
// Workaround for IE11/Edge: Fill silent aac frame after keyframe-seeking
// Make audio beginDts equals with video beginDts, in order to fix seek freeze
this._fillSilentAfterSeek = browser.msedge || browser.msie;
// While only FireFox supports 'audio/mp4, codecs="mp3"', use 'audio/mpeg' for chrome, safari, ...
this._mp3UseMpegAudio = !browser.firefox;
this._fillAudioTimestampGap = this._config.fixAudioTimestampGap;
}
createClass_default()(MP4Remuxer, [{
key: "destroy",
value: function destroy() {
this._dtsBase = -1;
this._dtsBaseInited = false;
this._audioMeta = null;
this._videoMeta = null;
this._audioSegmentInfoList.clear();
this._audioSegmentInfoList = null;
this._videoSegmentInfoList.clear();
this._videoSegmentInfoList = null;
this._onInitSegment = null;
this._onMediaSegment = null;
}
}, {
key: "bindDataSource",
value: function bindDataSource(producer) {
producer.onDataAvailable = this.remux.bind(this);
producer.onTrackMetadata = this._onTrackMetadataReceived.bind(this);
return this;
}
/* prototype: function onInitSegment(type: string, initSegment: ArrayBuffer): void
InitSegment: {
type: string,
data: ArrayBuffer,
codec: string,
container: string
}
*/
}, {
key: "onInitSegment",
get: function get() {
return this._onInitSegment;
},
set: function set(callback) {
this._onInitSegment = callback;
}
/* prototype: function onMediaSegment(type: string, mediaSegment: MediaSegment): void
MediaSegment: {
type: string,
data: ArrayBuffer,
sampleCount: int32
info: MediaSegmentInfo
}
*/
}, {
key: "onMediaSegment",
get: function get() {
return this._onMediaSegment;
},
set: function set(callback) {
this._onMediaSegment = callback;
}
}, {
key: "insertDiscontinuity",
value: function insertDiscontinuity() {
this._audioNextDts = this._videoNextDts = undefined;
}
}, {
key: "seek",
value: function seek(originalDts) {
this._audioStashedLastSample = null;
this._videoStashedLastSample = null;
this._videoSegmentInfoList.clear();
this._audioSegmentInfoList.clear();
}
}, {
key: "remux",
value: function remux(audioTrack, videoTrack) {
if (!this._onMediaSegment) {
throw new IllegalStateException('MP4Remuxer: onMediaSegment callback must be specificed!');
}
if (!this._dtsBaseInited) {
this._calculateDtsBase(audioTrack, videoTrack);
}
this._remuxVideo(videoTrack);
this._remuxAudio(audioTrack);
}
}, {
key: "_onTrackMetadataReceived",
value: function _onTrackMetadataReceived(type, metadata) {
var metabox = null;
var container = 'mp4';
var codec = metadata.codec;
if (type === 'audio') {
this._audioMeta = metadata;
if (metadata.codec === 'mp3' && this._mp3UseMpegAudio) {
// 'audio/mpeg' for MP3 audio track
container = 'mpeg';
codec = '';
metabox = new Uint8Array();
} else {
// 'audio/mp4, codecs="codec"'
metabox = mp4_generator.generateInitSegment(metadata);
}
} else if (type === 'video') {
this._videoMeta = metadata;
metabox = mp4_generator.generateInitSegment(metadata);
} else {
return;
}
// dispatch metabox (Initialization Segment)
if (!this._onInitSegment) {
throw new IllegalStateException('MP4Remuxer: onInitSegment callback must be specified!');
}
this._onInitSegment(type, {
type: type,
data: metabox.buffer,
codec: codec,
container: "".concat(type, "/").concat(container),
mediaDuration: metadata.duration // in timescale 1000 (milliseconds)
});
}
}, {
key: "_calculateDtsBase",
value: function _calculateDtsBase(audioTrack, videoTrack) {
if (this._dtsBaseInited) {
return;
}
if (audioTrack.samples && audioTrack.samples.length) {
this._audioDtsBase = audioTrack.samples[0].dts;
}
if (videoTrack.samples && videoTrack.samples.length) {
this._videoDtsBase = videoTrack.samples[0].dts;
}
this._dtsBase = Math.min(this._audioDtsBase, this._videoDtsBase);
this._dtsBaseInited = true;
}
}, {
key: "flushStashedSamples",
value: function flushStashedSamples() {
var videoSample = this._videoStashedLastSample;
var audioSample = this._audioStashedLastSample;
var videoTrack = {
type: 'video',
id: 1,
sequenceNumber: 0,
samples: [],
length: 0
};
if (videoSample != null) {
videoTrack.samples.push(videoSample);
videoTrack.length = videoSample.length;
}
var audioTrack = {
type: 'audio',
id: 2,
sequenceNumber: 0,
samples: [],
length: 0
};
if (audioSample != null) {
audioTrack.samples.push(audioSample);
audioTrack.length = audioSample.length;
}
this._videoStashedLastSample = null;
this._audioStashedLastSample = null;
this._remuxVideo(videoTrack, true);
this._remuxAudio(audioTrack, true);
}
}, {
key: "_remuxAudio",
value: function _remuxAudio(audioTrack, force) {
if (this._audioMeta == null) {
return;
}
var track = audioTrack;
var samples = track.samples;
var dtsCorrection = undefined;
var firstDts = -1,
lastDts = -1,
lastPts = -1;
var refSampleDuration = this._audioMeta.refSampleDuration;
var mpegRawTrack = this._audioMeta.codec === 'mp3' && this._mp3UseMpegAudio;
var firstSegmentAfterSeek = this._dtsBaseInited && this._audioNextDts === undefined;
var insertPrefixSilentFrame = false;
if (!samples || samples.length === 0) {
return;
}
if (samples.length === 1 && !force) {
// If [sample count in current batch] === 1 && (force != true)
// Ignore and keep in demuxer's queue
return;
} // else if (force === true) do remux
var offset = 0;
var mdatbox = null;
var mdatBytes = 0;
// calculate initial mdat size
if (mpegRawTrack) {
// for raw mpeg buffer
offset = 0;
mdatBytes = track.length;
} else {
// for fmp4 mdat box
offset = 8; // size + type
mdatBytes = 8 + track.length;
}
var lastSample = null;
// Pop the lastSample and waiting for stash
if (samples.length > 1) {
lastSample = samples.pop();
mdatBytes -= lastSample.length;
}
// Insert [stashed lastSample in the previous batch] to the front
if (this._audioStashedLastSample != null) {
var sample = this._audioStashedLastSample;
this._audioStashedLastSample = null;
samples.unshift(sample);
mdatBytes += sample.length;
}
// Stash the lastSample of current batch, waiting for next batch
if (lastSample != null) {
this._audioStashedLastSample = lastSample;
}
var firstSampleOriginalDts = samples[0].dts - this._dtsBase;
// calculate dtsCorrection
if (this._audioNextDts) {
dtsCorrection = firstSampleOriginalDts - this._audioNextDts;
} else {
// this._audioNextDts == undefined
if (this._audioSegmentInfoList.isEmpty()) {
dtsCorrection = 0;
if (this._fillSilentAfterSeek && !this._videoSegmentInfoList.isEmpty()) {
if (this._audioMeta.originalCodec !== 'mp3') {
insertPrefixSilentFrame = true;
}
}
} else {
var _lastSample = this._audioSegmentInfoList.getLastSampleBefore(firstSampleOriginalDts);
if (_lastSample != null) {
var distance = firstSampleOriginalDts - (_lastSample.originalDts + _lastSample.duration);
if (distance <= 3) {
distance = 0;
}
var expectedDts = _lastSample.dts + _lastSample.duration + distance;
dtsCorrection = firstSampleOriginalDts - expectedDts;
} else {
// lastSample == null, cannot found
dtsCorrection = 0;
}
}
}
if (insertPrefixSilentFrame) {
// align audio segment beginDts to match with current video segment's beginDts
var firstSampleDts = firstSampleOriginalDts - dtsCorrection;
var videoSegment = this._videoSegmentInfoList.getLastSegmentBefore(firstSampleOriginalDts);
if (videoSegment != null && videoSegment.beginDts < firstSampleDts) {
var silentUnit = aac_silent.getSilentFrame(this._audioMeta.originalCodec, this._audioMeta.channelCount);
if (silentUnit) {
var dts = videoSegment.beginDts;
var silentFrameDuration = firstSampleDts - videoSegment.beginDts;
logger.v(this.TAG, "InsertPrefixSilentAudio: dts: ".concat(dts, ", duration: ").concat(silentFrameDuration));
samples.unshift({
unit: silentUnit,
dts: dts,
pts: dts
});
mdatBytes += silentUnit.byteLength;
} // silentUnit == null: Cannot generate, skip
} else {
insertPrefixSilentFrame = false;
}
}
var mp4Samples = [];
// Correct dts for each sample, and calculate sample duration. Then output to mp4Samples
for (var i = 0; i < samples.length; i++) {
var _sample = samples[i];
var unit = _sample.unit;
var originalDts = _sample.dts - this._dtsBase;
var _dts = originalDts - dtsCorrection;
if (firstDts === -1) {
firstDts = _dts;
}
var sampleDuration = 0;
if (i !== samples.length - 1) {
var nextDts = samples[i + 1].dts - this._dtsBase - dtsCorrection;
sampleDuration = nextDts - _dts;
} else {
// the last sample
if (lastSample != null) {
// use stashed sample's dts to calculate sample duration
var _nextDts = lastSample.dts - this._dtsBase - dtsCorrection;
sampleDuration = _nextDts - _dts;
} else if (mp4Samples.length >= 1) {
// use second last sample duration
sampleDuration = mp4Samples[mp4Samples.length - 1].duration;
} else {
// the only one sample, use reference sample duration
sampleDuration = Math.floor(refSampleDuration);
}
}
var needFillSilentFrames = false;
var silentFrames = null;
// Silent frame generation, if large timestamp gap detected && config.fixAudioTimestampGap
if (sampleDuration > refSampleDuration * 1.5 && this._audioMeta.codec !== 'mp3' && this._fillAudioTimestampGap && !browser.safari) {
// We need to insert silent frames to fill timestamp gap
needFillSilentFrames = true;
var delta = Math.abs(sampleDuration - refSampleDuration);
var frameCount = Math.ceil(delta / refSampleDuration);
var currentDts = _dts + refSampleDuration; // Notice: in float
logger.w(this.TAG, 'Large audio timestamp gap detected, may cause AV sync to drift. ' + 'Silent frames will be generated to avoid unsync.\n' + "dts: ".concat(_dts + sampleDuration, " ms, expected: ").concat(_dts + Math.round(refSampleDuration), " ms, ") + "delta: ".concat(Math.round(delta), " ms, generate: ").concat(frameCount, " frames"));
var _silentUnit = aac_silent.getSilentFrame(this._audioMeta.originalCodec, this._audioMeta.channelCount);
if (_silentUnit == null) {
logger.w(this.TAG, 'Unable to generate silent frame for ' + "".concat(this._audioMeta.originalCodec, " with ").concat(this._audioMeta.channelCount, " channels, repeat last frame"));
// Repeat last frame
_silentUnit = unit;
}
silentFrames = [];
for (var j = 0; j < frameCount; j++) {
var intDts = Math.round(currentDts); // round to integer
if (silentFrames.length > 0) {
// Set previous frame sample duration
var previousFrame = silentFrames[silentFrames.length - 1];
previousFrame.duration = intDts - previousFrame.dts;
}
var frame = {
dts: intDts,
pts: intDts,
cts: 0,
unit: _silentUnit,
size: _silentUnit.byteLength,
duration: 0,
// wait for next sample
originalDts: originalDts,
flags: {
isLeading: 0,
dependsOn: 1,
isDependedOn: 0,
hasRedundancy: 0
}
};
silentFrames.push(frame);
mdatBytes += frame.size;
currentDts += refSampleDuration;
}
// last frame: align end time to next frame dts
var lastFrame = silentFrames[silentFrames.length - 1];
lastFrame.duration = _dts + sampleDuration - lastFrame.dts;
// silentFrames.forEach((frame) => {
// Log.w(this.TAG, `SilentAudio: dts: ${frame.dts}, duration: ${frame.duration}`);
// });
// Set correct sample duration for current frame
sampleDuration = Math.round(refSampleDuration);
}
mp4Samples.push({
dts: _dts,
pts: _dts,
cts: 0,
unit: _sample.unit,
size: _sample.unit.byteLength,
duration: sampleDuration,
originalDts: originalDts,
flags: {
isLeading: 0,
dependsOn: 1,
isDependedOn: 0,
hasRedundancy: 0
}
});
if (needFillSilentFrames) {
// Silent frames should be inserted after wrong-duration frame
mp4Samples.push.apply(mp4Samples, silentFrames);
}
}
// allocate mdatbox
if (mpegRawTrack) {
// allocate for raw mpeg buffer
mdatbox = new Uint8Array(mdatBytes);
} else {
// allocate for fmp4 mdat box
mdatbox = new Uint8Array(mdatBytes);
// size field
mdatbox[0] = mdatBytes >>> 24 & 0xFF;
mdatbox[1] = mdatBytes >>> 16 & 0xFF;
mdatbox[2] = mdatBytes >>> 8 & 0xFF;
mdatbox[3] = mdatBytes & 0xFF;
// type field (fourCC)
mdatbox.set(mp4_generator.types.mdat, 4);
}
// Write samples into mdatbox
for (var _i = 0; _i < mp4Samples.length; _i++) {
var _unit = mp4Samples[_i].unit;
mdatbox.set(_unit, offset);
offset += _unit.byteLength;
}
var latest = mp4Samples[mp4Samples.length - 1];
lastDts = latest.dts + latest.duration;
this._audioNextDts = lastDts;
// fill media segment info & add to info list
var info = new MediaSegmentInfo();
info.beginDts = firstDts;
info.endDts = lastDts;
info.beginPts = firstDts;
info.endPts = lastDts;
info.originalBeginDts = mp4Samples[0].originalDts;
info.originalEndDts = latest.originalDts + latest.duration;
info.firstSample = new SampleInfo(mp4Samples[0].dts, mp4Samples[0].pts, mp4Samples[0].duration, mp4Samples[0].originalDts, false);
info.lastSample = new SampleInfo(latest.dts, latest.pts, latest.duration, latest.originalDts, false);
if (!this._isLive) {
this._audioSegmentInfoList.append(info);
}
track.samples = mp4Samples;
track.sequenceNumber++;
var moofbox = null;
if (mpegRawTrack) {
// Generate empty buffer, because useless for raw mpeg
moofbox = new Uint8Array();
} else {
// Generate moof for fmp4 segment
moofbox = mp4_generator.moof(track, firstDts);
}
track.samples = [];
track.length = 0;
var segment = {
type: 'audio',
data: this._mergeBoxes(moofbox, mdatbox).buffer,
sampleCount: mp4Samples.length,
info: info
};
if (mpegRawTrack && firstSegmentAfterSeek) {
// For MPEG audio stream in MSE, if seeking occurred, before appending new buffer
// We need explicitly set timestampOffset to the desired point in timeline for mpeg SourceBuffer.
segment.timestampOffset = firstDts;
}
this._onMediaSegment('audio', segment);
}
}, {
key: "_remuxVideo",
value: function _remuxVideo(videoTrack, force) {
if (this._videoMeta == null) {
return;
}
var track = videoTrack;
var samples = track.samples;
var dtsCorrection = undefined;
var firstDts = -1,
lastDts = -1;
var firstPts = -1,
lastPts = -1;
if (!samples || samples.length === 0) {
return;
}
if (samples.length === 1 && !force) {
// If [sample count in current batch] === 1 && (force != true)
// Ignore and keep in demuxer's queue
return;
} // else if (force === true) do remux
var offset = 8;
var mdatbox = null;
var mdatBytes = 8 + videoTrack.length;
var lastSample = null;
// Pop the lastSample and waiting for stash
if (samples.length > 1) {
lastSample = samples.pop();
mdatBytes -= lastSample.length;
}
// Insert [stashed lastSample in the previous batch] to the front
if (this._videoStashedLastSample != null) {
var sample = this._videoStashedLastSample;
this._videoStashedLastSample = null;
samples.unshift(sample);
mdatBytes += sample.length;
}
// Stash the lastSample of current batch, waiting for next batch
if (lastSample != null) {
this._videoStashedLastSample = lastSample;
}
var firstSampleOriginalDts = samples[0].dts - this._dtsBase;
// calculate dtsCorrection
if (this._videoNextDts) {
dtsCorrection = firstSampleOriginalDts - this._videoNextDts;
} else {
// this._videoNextDts == undefined
if (this._videoSegmentInfoList.isEmpty()) {
dtsCorrection = 0;
} else {
var _lastSample2 = this._videoSegmentInfoList.getLastSampleBefore(firstSampleOriginalDts);
if (_lastSample2 != null) {
var distance = firstSampleOriginalDts - (_lastSample2.originalDts + _lastSample2.duration);
if (distance <= 3) {
distance = 0;
}
var expectedDts = _lastSample2.dts + _lastSample2.duration + distance;
dtsCorrection = firstSampleOriginalDts - expectedDts;
} else {
// lastSample == null, cannot found
dtsCorrection = 0;
}
}
}
var info = new MediaSegmentInfo();
var mp4Samples = [];
// Correct dts for each sample, and calculate sample duration. Then output to mp4Samples
for (var i = 0; i < samples.length; i++) {
var _sample2 = samples[i];
var originalDts = _sample2.dts - this._dtsBase;
var isKeyframe = _sample2.isKeyframe;
var dts = originalDts - dtsCorrection;
var cts = _sample2.cts;
var pts = dts + cts;
if (firstDts === -1) {
firstDts = dts;
firstPts = pts;
}
var sampleDuration = 0;
if (i !== samples.length - 1) {
var nextDts = samples[i + 1].dts - this._dtsBase - dtsCorrection;
sampleDuration = nextDts - dts;
} else {
// the last sample
if (lastSample != null) {
// use stashed sample's dts to calculate sample duration
var _nextDts2 = lastSample.dts - this._dtsBase - dtsCorrection;
sampleDuration = _nextDts2 - dts;
} else if (mp4Samples.length >= 1) {
// use second last sample duration
sampleDuration = mp4Samples[mp4Samples.length - 1].duration;
} else {
// the only one sample, use reference sample duration
sampleDuration = Math.floor(this._videoMeta.refSampleDuration);
}
}
if (isKeyframe) {
var syncPoint = new SampleInfo(dts, pts, sampleDuration, _sample2.dts, true);
syncPoint.fileposition = _sample2.fileposition;
info.appendSyncPoint(syncPoint);
}
mp4Samples.push({
dts: dts,
pts: pts,
cts: cts,
units: _sample2.units,
size: _sample2.length,
isKeyframe: isKeyframe,
duration: sampleDuration,
originalDts: originalDts,
flags: {
isLeading: 0,
dependsOn: isKeyframe ? 2 : 1,
isDependedOn: isKeyframe ? 1 : 0,
hasRedundancy: 0,
isNonSync: isKeyframe ? 0 : 1
}
});
}
// allocate mdatbox
mdatbox = new Uint8Array(mdatBytes);
mdatbox[0] = mdatBytes >>> 24 & 0xFF;
mdatbox[1] = mdatBytes >>> 16 & 0xFF;
mdatbox[2] = mdatBytes >>> 8 & 0xFF;
mdatbox[3] = mdatBytes & 0xFF;
mdatbox.set(mp4_generator.types.mdat, 4);
// Write samples into mdatbox
for (var _i2 = 0; _i2 < mp4Samples.length; _i2++) {
var units = mp4Samples[_i2].units;
while (units.length) {
var unit = units.shift();
var data = unit.data;
mdatbox.set(data, offset);
offset += data.byteLength;
}
}
var latest = mp4Samples[mp4Samples.length - 1];
lastDts = latest.dts + latest.duration;
lastPts = latest.pts + latest.duration;
this._videoNextDts = lastDts;
// fill media segment info & add to info list
info.beginDts = firstDts;
info.endDts = lastDts;
info.beginPts = firstPts;
info.endPts = lastPts;
info.originalBeginDts = mp4Samples[0].originalDts;
info.originalEndDts = latest.originalDts + latest.duration;
info.firstSample = new SampleInfo(mp4Samples[0].dts, mp4Samples[0].pts, mp4Samples[0].duration, mp4Samples[0].originalDts, mp4Samples[0].isKeyframe);
info.lastSample = new SampleInfo(latest.dts, latest.pts, latest.duration, latest.originalDts, latest.isKeyframe);
if (!this._isLive) {
this._videoSegmentInfoList.append(info);
}
track.samples = mp4Samples;
track.sequenceNumber++;
// workaround for chrome < 50: force first sample as a random access point
// see https://bugs.chromium.org/p/chromium/issues/detail?id=229412
if (this._forceFirstIDR) {
var flags = mp4Samples[0].flags;
flags.dependsOn = 2;
flags.isNonSync = 0;
}
var moofbox = mp4_generator.moof(track, firstDts);
track.samples = [];
track.length = 0;
this._onMediaSegment('video', {
type: 'video',
data: this._mergeBoxes(moofbox, mdatbox).buffer,
sampleCount: mp4Samples.length,
info: info
});
}
}, {
key: "_mergeBoxes",
value: function _mergeBoxes(moof, mdat) {
var result = new Uint8Array(moof.byteLength + mdat.byteLength);
result.set(moof, 0);
result.set(mdat, moof.byteLength);
return result;
}
}]);
return MP4Remuxer;
}();
/* harmony default export */ var mp4_remuxer = (MP4Remuxer);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/core/transmuxing-events.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var TransmuxingEvents = {
IO_ERROR: 'io_error',
DEMUX_ERROR: 'demux_error',
INIT_SEGMENT: 'init_segment',
MEDIA_SEGMENT: 'media_segment',
LOADING_COMPLETE: 'loading_complete',
RECOVERED_EARLY_EOF: 'recovered_early_eof',
MEDIA_INFO: 'media_info',
METADATA_ARRIVED: 'metadata_arrived',
SCRIPTDATA_ARRIVED: 'scriptdata_arrived',
STATISTICS_INFO: 'statistics_info',
RECOMMEND_SEEKPOINT: 'recommend_seekpoint'
};
/* harmony default export */ var transmuxing_events = (TransmuxingEvents);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/core/transmuxing-controller.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// Transmuxing (IO, Demuxing, Remuxing) controller, with multipart support
var TransmuxingController = /*#__PURE__*/function () {
function TransmuxingController(mediaDataSource, config) {
classCallCheck_default()(this, TransmuxingController);
this.TAG = 'TransmuxingController';
this._emitter = new (events_default())();
this._config = config;
// treat single part media as multipart media, which has only one segment
if (!mediaDataSource.segments) {
mediaDataSource.segments = [{
duration: mediaDataSource.duration,
filesize: mediaDataSource.filesize,
url: mediaDataSource.url
}];
}
// fill in default IO params if not exists
if (typeof mediaDataSource.cors !== 'boolean') {
mediaDataSource.cors = true;
}
if (typeof mediaDataSource.withCredentials !== 'boolean') {
mediaDataSource.withCredentials = false;
}
this._mediaDataSource = mediaDataSource;
this._currentSegmentIndex = 0;
var totalDuration = 0;
this._mediaDataSource.segments.forEach(function (segment) {
// timestampBase for each segment, and calculate total duration
segment.timestampBase = totalDuration;
totalDuration += segment.duration;
// params needed by IOController
segment.cors = mediaDataSource.cors;
segment.withCredentials = mediaDataSource.withCredentials;
// referrer policy control, if exist
if (config.referrerPolicy) {
segment.referrerPolicy = config.referrerPolicy;
}
});
if (!isNaN(totalDuration) && this._mediaDataSource.duration !== totalDuration) {
this._mediaDataSource.duration = totalDuration;
}
this._mediaInfo = null;
this._demuxer = null;
this._remuxer = null;
this._ioctl = null;
this._pendingSeekTime = null;
this._pendingResolveSeekPoint = null;
this._statisticsReporter = null;
}
createClass_default()(TransmuxingController, [{
key: "destroy",
value: function destroy() {
this._mediaInfo = null;
this._mediaDataSource = null;
if (this._statisticsReporter) {
this._disableStatisticsReporter();
}
if (this._ioctl) {
this._ioctl.destroy();
this._ioctl = null;
}
if (this._demuxer) {
this._demuxer.destroy();
this._demuxer = null;
}
if (this._remuxer) {
this._remuxer.destroy();
this._remuxer = null;
}
this._emitter.removeAllListeners();
this._emitter = null;
}
}, {
key: "on",
value: function on(event, listener) {
this._emitter.addListener(event, listener);
}
}, {
key: "off",
value: function off(event, listener) {
this._emitter.removeListener(event, listener);
}
}, {
key: "start",
value: function start() {
this._loadSegment(0);
this._enableStatisticsReporter();
}
}, {
key: "_loadSegment",
value: function _loadSegment(segmentIndex, optionalFrom) {
this._currentSegmentIndex = segmentIndex;
var dataSource = this._mediaDataSource.segments[segmentIndex];
var ioctl = this._ioctl = new io_controller(dataSource, this._config, segmentIndex);
ioctl.onError = this._onIOException.bind(this);
ioctl.onSeeked = this._onIOSeeked.bind(this);
ioctl.onComplete = this._onIOComplete.bind(this);
ioctl.onRedirect = this._onIORedirect.bind(this);
ioctl.onRecoveredEarlyEof = this._onIORecoveredEarlyEof.bind(this);
if (optionalFrom) {
this._demuxer.bindDataSource(this._ioctl);
} else {
ioctl.onDataArrival = this._onInitChunkArrival.bind(this);
}
ioctl.open(optionalFrom);
}
}, {
key: "stop",
value: function stop() {
this._internalAbort();
this._disableStatisticsReporter();
}
}, {
key: "_internalAbort",
value: function _internalAbort() {
if (this._ioctl) {
this._ioctl.destroy();
this._ioctl = null;
}
}
}, {
key: "pause",
value: function pause() {
// take a rest
if (this._ioctl && this._ioctl.isWorking()) {
this._ioctl.pause();
this._disableStatisticsReporter();
}
}
}, {
key: "resume",
value: function resume() {
if (this._ioctl && this._ioctl.isPaused()) {
this._ioctl.resume();
this._enableStatisticsReporter();
}
}
}, {
key: "seek",
value: function seek(milliseconds) {
if (this._mediaInfo == null || !this._mediaInfo.isSeekable()) {
return;
}
var targetSegmentIndex = this._searchSegmentIndexContains(milliseconds);
if (targetSegmentIndex === this._currentSegmentIndex) {
// intra-segment seeking
var segmentInfo = this._mediaInfo.segments[targetSegmentIndex];
if (segmentInfo == undefined) {
// current segment loading started, but mediainfo hasn't received yet
// wait for the metadata loaded, then seek to expected position
this._pendingSeekTime = milliseconds;
} else {
var keyframe = segmentInfo.getNearestKeyframe(milliseconds);
this._remuxer.seek(keyframe.milliseconds);
this._ioctl.seek(keyframe.fileposition);
// Will be resolved in _onRemuxerMediaSegmentArrival()
this._pendingResolveSeekPoint = keyframe.milliseconds;
}
} else {
// cross-segment seeking
var targetSegmentInfo = this._mediaInfo.segments[targetSegmentIndex];
if (targetSegmentInfo == undefined) {
// target segment hasn't been loaded. We need metadata then seek to expected time
this._pendingSeekTime = milliseconds;
this._internalAbort();
this._remuxer.seek();
this._remuxer.insertDiscontinuity();
this._loadSegment(targetSegmentIndex);
// Here we wait for the metadata loaded, then seek to expected position
} else {
// We have target segment's metadata, direct seek to target position
var _keyframe = targetSegmentInfo.getNearestKeyframe(milliseconds);
this._internalAbort();
this._remuxer.seek(milliseconds);
this._remuxer.insertDiscontinuity();
this._demuxer.resetMediaInfo();
this._demuxer.timestampBase = this._mediaDataSource.segments[targetSegmentIndex].timestampBase;
this._loadSegment(targetSegmentIndex, _keyframe.fileposition);
this._pendingResolveSeekPoint = _keyframe.milliseconds;
this._reportSegmentMediaInfo(targetSegmentIndex);
}
}
this._enableStatisticsReporter();
}
}, {
key: "_searchSegmentIndexContains",
value: function _searchSegmentIndexContains(milliseconds) {
var segments = this._mediaDataSource.segments;
var idx = segments.length - 1;
for (var i = 0; i < segments.length; i++) {
if (milliseconds < segments[i].timestampBase) {
idx = i - 1;
break;
}
}
return idx;
}
}, {
key: "_onInitChunkArrival",
value: function _onInitChunkArrival(data, byteStart) {
var _this = this;
var probeData = null;
var consumed = 0;
if (byteStart > 0) {
// IOController seeked immediately after opened, byteStart > 0 callback may received
this._demuxer.bindDataSource(this._ioctl);
this._demuxer.timestampBase = this._mediaDataSource.segments[this._currentSegmentIndex].timestampBase;
consumed = this._demuxer.parseChunks(data, byteStart);
} else if ((probeData = flv_demuxer.probe(data)).match) {
// Always create new FLVDemuxer
this._demuxer = new flv_demuxer(probeData, this._config);
if (!this._remuxer) {
this._remuxer = new mp4_remuxer(this._config);
}
var mds = this._mediaDataSource;
if (mds.duration != undefined && !isNaN(mds.duration)) {
this._demuxer.overridedDuration = mds.duration;
}
if (typeof mds.hasAudio === 'boolean') {
this._demuxer.overridedHasAudio = mds.hasAudio;
}
if (typeof mds.hasVideo === 'boolean') {
this._demuxer.overridedHasVideo = mds.hasVideo;
}
this._demuxer.timestampBase = mds.segments[this._currentSegmentIndex].timestampBase;
this._demuxer.onError = this._onDemuxException.bind(this);
this._demuxer.onMediaInfo = this._onMediaInfo.bind(this);
this._demuxer.onMetaDataArrived = this._onMetaDataArrived.bind(this);
this._demuxer.onScriptDataArrived = this._onScriptDataArrived.bind(this);
this._remuxer.bindDataSource(this._demuxer.bindDataSource(this._ioctl));
this._remuxer.onInitSegment = this._onRemuxerInitSegmentArrival.bind(this);
this._remuxer.onMediaSegment = this._onRemuxerMediaSegmentArrival.bind(this);
consumed = this._demuxer.parseChunks(data, byteStart);
} else {
probeData = null;
logger.e(this.TAG, 'Non-FLV, Unsupported media type!');
Promise.resolve().then(function () {
_this._internalAbort();
});
this._emitter.emit(transmuxing_events.DEMUX_ERROR, demux_errors.FORMAT_UNSUPPORTED, 'Non-FLV, Unsupported media type');
consumed = 0;
}
return consumed;
}
}, {
key: "_onMediaInfo",
value: function _onMediaInfo(mediaInfo) {
var _this2 = this;
if (this._mediaInfo == null) {
// Store first segment's mediainfo as global mediaInfo
this._mediaInfo = Object.assign({}, mediaInfo);
this._mediaInfo.keyframesIndex = null;
this._mediaInfo.segments = [];
this._mediaInfo.segmentCount = this._mediaDataSource.segments.length;
Object.setPrototypeOf(this._mediaInfo, media_info.prototype);
}
var segmentInfo = Object.assign({}, mediaInfo);
Object.setPrototypeOf(segmentInfo, media_info.prototype);
this._mediaInfo.segments[this._currentSegmentIndex] = segmentInfo;
// notify mediaInfo update
this._reportSegmentMediaInfo(this._currentSegmentIndex);
if (this._pendingSeekTime != null) {
Promise.resolve().then(function () {
var target = _this2._pendingSeekTime;
_this2._pendingSeekTime = null;
_this2.seek(target);
});
}
}
}, {
key: "_onMetaDataArrived",
value: function _onMetaDataArrived(metadata) {
this._emitter.emit(transmuxing_events.METADATA_ARRIVED, metadata);
}
}, {
key: "_onScriptDataArrived",
value: function _onScriptDataArrived(data) {
this._emitter.emit(transmuxing_events.SCRIPTDATA_ARRIVED, data);
}
}, {
key: "_onIOSeeked",
value: function _onIOSeeked() {
this._remuxer.insertDiscontinuity();
}
}, {
key: "_onIOComplete",
value: function _onIOComplete(extraData) {
var segmentIndex = extraData;
var nextSegmentIndex = segmentIndex + 1;
if (nextSegmentIndex < this._mediaDataSource.segments.length) {
this._internalAbort();
this._remuxer.flushStashedSamples();
this._loadSegment(nextSegmentIndex);
} else {
this._remuxer.flushStashedSamples();
this._emitter.emit(transmuxing_events.LOADING_COMPLETE);
this._disableStatisticsReporter();
}
}
}, {
key: "_onIORedirect",
value: function _onIORedirect(redirectedURL) {
var segmentIndex = this._ioctl.extraData;
this._mediaDataSource.segments[segmentIndex].redirectedURL = redirectedURL;
}
}, {
key: "_onIORecoveredEarlyEof",
value: function _onIORecoveredEarlyEof() {
this._emitter.emit(transmuxing_events.RECOVERED_EARLY_EOF);
}
}, {
key: "_onIOException",
value: function _onIOException(type, info) {
logger.e(this.TAG, "IOException: type = ".concat(type, ", code = ").concat(info.code, ", msg = ").concat(info.msg));
this._emitter.emit(transmuxing_events.IO_ERROR, type, info);
this._disableStatisticsReporter();
}
}, {
key: "_onDemuxException",
value: function _onDemuxException(type, info) {
logger.e(this.TAG, "DemuxException: type = ".concat(type, ", info = ").concat(info));
this._emitter.emit(transmuxing_events.DEMUX_ERROR, type, info);
}
}, {
key: "_onRemuxerInitSegmentArrival",
value: function _onRemuxerInitSegmentArrival(type, initSegment) {
this._emitter.emit(transmuxing_events.INIT_SEGMENT, type, initSegment);
}
}, {
key: "_onRemuxerMediaSegmentArrival",
value: function _onRemuxerMediaSegmentArrival(type, mediaSegment) {
if (this._pendingSeekTime != null) {
// Media segments after new-segment cross-seeking should be dropped.
return;
}
this._emitter.emit(transmuxing_events.MEDIA_SEGMENT, type, mediaSegment);
// Resolve pending seekPoint
if (this._pendingResolveSeekPoint != null && type === 'video') {
var syncPoints = mediaSegment.info.syncPoints;
var seekpoint = this._pendingResolveSeekPoint;
this._pendingResolveSeekPoint = null;
// Safari: Pass PTS for recommend_seekpoint
if (browser.safari && syncPoints.length > 0 && syncPoints[0].originalDts === seekpoint) {
seekpoint = syncPoints[0].pts;
}
// else: use original DTS (keyframe.milliseconds)
this._emitter.emit(transmuxing_events.RECOMMEND_SEEKPOINT, seekpoint);
}
}
}, {
key: "_enableStatisticsReporter",
value: function _enableStatisticsReporter() {
if (this._statisticsReporter == null) {
this._statisticsReporter = self.setInterval(this._reportStatisticsInfo.bind(this), this._config.statisticsInfoReportInterval);
}
}
}, {
key: "_disableStatisticsReporter",
value: function _disableStatisticsReporter() {
if (this._statisticsReporter) {
self.clearInterval(this._statisticsReporter);
this._statisticsReporter = null;
}
}
}, {
key: "_reportSegmentMediaInfo",
value: function _reportSegmentMediaInfo(segmentIndex) {
var segmentInfo = this._mediaInfo.segments[segmentIndex];
var exportInfo = Object.assign({}, segmentInfo);
exportInfo.duration = this._mediaInfo.duration;
exportInfo.segmentCount = this._mediaInfo.segmentCount;
delete exportInfo.segments;
delete exportInfo.keyframesIndex;
this._emitter.emit(transmuxing_events.MEDIA_INFO, exportInfo);
}
}, {
key: "_reportStatisticsInfo",
value: function _reportStatisticsInfo() {
var info = {};
info.url = this._ioctl.currentURL;
info.hasRedirect = this._ioctl.hasRedirect;
if (info.hasRedirect) {
info.redirectedURL = this._ioctl.currentRedirectedURL;
}
info.speed = this._ioctl.currentSpeed;
info.loaderType = this._ioctl.loaderType;
info.currentSegmentIndex = this._currentSegmentIndex;
info.totalSegmentCount = this._mediaDataSource.segments.length;
this._emitter.emit(transmuxing_events.STATISTICS_INFO, info);
}
}]);
return TransmuxingController;
}();
/* harmony default export */ var transmuxing_controller = (TransmuxingController);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/core/transmuxing-worker.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* post message to worker:
data: {
cmd: string
param: any
}
receive message from worker:
data: {
msg: string,
data: any
}
*/
var TransmuxingWorker = function TransmuxingWorker(self) {
var TAG = 'TransmuxingWorker';
var controller = null;
var logcatListener = onLogcatCallback.bind(this);
polyfill.install();
self.addEventListener('message', function (e) {
switch (e.data.cmd) {
case 'init':
controller = new transmuxing_controller(e.data.param[0], e.data.param[1]);
controller.on(transmuxing_events.IO_ERROR, onIOError.bind(this));
controller.on(transmuxing_events.DEMUX_ERROR, onDemuxError.bind(this));
controller.on(transmuxing_events.INIT_SEGMENT, onInitSegment.bind(this));
controller.on(transmuxing_events.MEDIA_SEGMENT, onMediaSegment.bind(this));
controller.on(transmuxing_events.LOADING_COMPLETE, onLoadingComplete.bind(this));
controller.on(transmuxing_events.RECOVERED_EARLY_EOF, onRecoveredEarlyEof.bind(this));
controller.on(transmuxing_events.MEDIA_INFO, onMediaInfo.bind(this));
controller.on(transmuxing_events.METADATA_ARRIVED, onMetaDataArrived.bind(this));
controller.on(transmuxing_events.SCRIPTDATA_ARRIVED, onScriptDataArrived.bind(this));
controller.on(transmuxing_events.STATISTICS_INFO, onStatisticsInfo.bind(this));
controller.on(transmuxing_events.RECOMMEND_SEEKPOINT, onRecommendSeekpoint.bind(this));
break;
case 'destroy':
if (controller) {
controller.destroy();
controller = null;
}
self.postMessage({
msg: 'destroyed'
});
break;
case 'start':
controller.start();
break;
case 'stop':
controller.stop();
break;
case 'seek':
controller.seek(e.data.param);
break;
case 'pause':
controller.pause();
break;
case 'resume':
controller.resume();
break;
case 'logging_config':
{
var config = e.data.param;
logging_control.applyConfig(config);
if (config.enableCallback === true) {
logging_control.addLogListener(logcatListener);
} else {
logging_control.removeLogListener(logcatListener);
}
break;
}
}
});
function onInitSegment(type, initSegment) {
var obj = {
msg: transmuxing_events.INIT_SEGMENT,
data: {
type: type,
data: initSegment
}
};
self.postMessage(obj, [initSegment.data]); // data: ArrayBuffer
}
function onMediaSegment(type, mediaSegment) {
var obj = {
msg: transmuxing_events.MEDIA_SEGMENT,
data: {
type: type,
data: mediaSegment
}
};
self.postMessage(obj, [mediaSegment.data]); // data: ArrayBuffer
}
function onLoadingComplete() {
var obj = {
msg: transmuxing_events.LOADING_COMPLETE
};
self.postMessage(obj);
}
function onRecoveredEarlyEof() {
var obj = {
msg: transmuxing_events.RECOVERED_EARLY_EOF
};
self.postMessage(obj);
}
function onMediaInfo(mediaInfo) {
var obj = {
msg: transmuxing_events.MEDIA_INFO,
data: mediaInfo
};
self.postMessage(obj);
}
function onMetaDataArrived(metadata) {
var obj = {
msg: transmuxing_events.METADATA_ARRIVED,
data: metadata
};
self.postMessage(obj);
}
function onScriptDataArrived(data) {
var obj = {
msg: transmuxing_events.SCRIPTDATA_ARRIVED,
data: data
};
self.postMessage(obj);
}
function onStatisticsInfo(statInfo) {
var obj = {
msg: transmuxing_events.STATISTICS_INFO,
data: statInfo
};
self.postMessage(obj);
}
function onIOError(type, info) {
self.postMessage({
msg: transmuxing_events.IO_ERROR,
data: {
type: type,
info: info
}
});
}
function onDemuxError(type, info) {
self.postMessage({
msg: transmuxing_events.DEMUX_ERROR,
data: {
type: type,
info: info
}
});
}
function onRecommendSeekpoint(milliseconds) {
self.postMessage({
msg: transmuxing_events.RECOMMEND_SEEKPOINT,
data: milliseconds
});
}
function onLogcatCallback(type, str) {
self.postMessage({
msg: 'logcat_callback',
data: {
type: type,
logcat: str
}
});
}
};
/* harmony default export */ var transmuxing_worker = (TransmuxingWorker);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/core/transmuxer.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var Transmuxer = /*#__PURE__*/function () {
function Transmuxer(mediaDataSource, config) {
classCallCheck_default()(this, Transmuxer);
this.TAG = 'Transmuxer';
this._emitter = new (events_default())();
if (config.enableWorker && typeof Worker !== 'undefined') {
try {
var work = __webpack_require__(/*! webworkify */ 82059);
this._worker = work(transmuxing_worker);
this._workerDestroying = false;
this._worker.addEventListener('message', this._onWorkerMessage.bind(this));
this._worker.postMessage({
cmd: 'init',
param: [mediaDataSource, config]
});
this.e = {
onLoggingConfigChanged: this._onLoggingConfigChanged.bind(this)
};
logging_control.registerListener(this.e.onLoggingConfigChanged);
this._worker.postMessage({
cmd: 'logging_config',
param: logging_control.getConfig()
});
} catch (error) {
logger.e(this.TAG, 'Error while initialize transmuxing worker, fallback to inline transmuxing');
this._worker = null;
this._controller = new transmuxing_controller(mediaDataSource, config);
}
} else {
this._controller = new transmuxing_controller(mediaDataSource, config);
}
if (this._controller) {
var ctl = this._controller;
ctl.on(transmuxing_events.IO_ERROR, this._onIOError.bind(this));
ctl.on(transmuxing_events.DEMUX_ERROR, this._onDemuxError.bind(this));
ctl.on(transmuxing_events.INIT_SEGMENT, this._onInitSegment.bind(this));
ctl.on(transmuxing_events.MEDIA_SEGMENT, this._onMediaSegment.bind(this));
ctl.on(transmuxing_events.LOADING_COMPLETE, this._onLoadingComplete.bind(this));
ctl.on(transmuxing_events.RECOVERED_EARLY_EOF, this._onRecoveredEarlyEof.bind(this));
ctl.on(transmuxing_events.MEDIA_INFO, this._onMediaInfo.bind(this));
ctl.on(transmuxing_events.METADATA_ARRIVED, this._onMetaDataArrived.bind(this));
ctl.on(transmuxing_events.SCRIPTDATA_ARRIVED, this._onScriptDataArrived.bind(this));
ctl.on(transmuxing_events.STATISTICS_INFO, this._onStatisticsInfo.bind(this));
ctl.on(transmuxing_events.RECOMMEND_SEEKPOINT, this._onRecommendSeekpoint.bind(this));
}
}
createClass_default()(Transmuxer, [{
key: "destroy",
value: function destroy() {
if (this._worker) {
if (!this._workerDestroying) {
this._workerDestroying = true;
this._worker.postMessage({
cmd: 'destroy'
});
logging_control.removeListener(this.e.onLoggingConfigChanged);
this.e = null;
}
} else {
this._controller.destroy();
this._controller = null;
}
this._emitter.removeAllListeners();
this._emitter = null;
}
}, {
key: "on",
value: function on(event, listener) {
this._emitter.addListener(event, listener);
}
}, {
key: "off",
value: function off(event, listener) {
this._emitter.removeListener(event, listener);
}
}, {
key: "hasWorker",
value: function hasWorker() {
return this._worker != null;
}
}, {
key: "open",
value: function open() {
if (this._worker) {
this._worker.postMessage({
cmd: 'start'
});
} else {
this._controller.start();
}
}
}, {
key: "close",
value: function close() {
if (this._worker) {
this._worker.postMessage({
cmd: 'stop'
});
} else {
this._controller.stop();
}
}
}, {
key: "seek",
value: function seek(milliseconds) {
if (this._worker) {
this._worker.postMessage({
cmd: 'seek',
param: milliseconds
});
} else {
this._controller.seek(milliseconds);
}
}
}, {
key: "pause",
value: function pause() {
if (this._worker) {
this._worker.postMessage({
cmd: 'pause'
});
} else {
this._controller.pause();
}
}
}, {
key: "resume",
value: function resume() {
if (this._worker) {
this._worker.postMessage({
cmd: 'resume'
});
} else {
this._controller.resume();
}
}
}, {
key: "_onInitSegment",
value: function _onInitSegment(type, initSegment) {
var _this = this;
// do async invoke
Promise.resolve().then(function () {
_this._emitter.emit(transmuxing_events.INIT_SEGMENT, type, initSegment);
});
}
}, {
key: "_onMediaSegment",
value: function _onMediaSegment(type, mediaSegment) {
var _this2 = this;
Promise.resolve().then(function () {
_this2._emitter.emit(transmuxing_events.MEDIA_SEGMENT, type, mediaSegment);
});
}
}, {
key: "_onLoadingComplete",
value: function _onLoadingComplete() {
var _this3 = this;
Promise.resolve().then(function () {
_this3._emitter.emit(transmuxing_events.LOADING_COMPLETE);
});
}
}, {
key: "_onRecoveredEarlyEof",
value: function _onRecoveredEarlyEof() {
var _this4 = this;
Promise.resolve().then(function () {
_this4._emitter.emit(transmuxing_events.RECOVERED_EARLY_EOF);
});
}
}, {
key: "_onMediaInfo",
value: function _onMediaInfo(mediaInfo) {
var _this5 = this;
Promise.resolve().then(function () {
_this5._emitter.emit(transmuxing_events.MEDIA_INFO, mediaInfo);
});
}
}, {
key: "_onMetaDataArrived",
value: function _onMetaDataArrived(metadata) {
var _this6 = this;
Promise.resolve().then(function () {
_this6._emitter.emit(transmuxing_events.METADATA_ARRIVED, metadata);
});
}
}, {
key: "_onScriptDataArrived",
value: function _onScriptDataArrived(data) {
var _this7 = this;
Promise.resolve().then(function () {
_this7._emitter.emit(transmuxing_events.SCRIPTDATA_ARRIVED, data);
});
}
}, {
key: "_onStatisticsInfo",
value: function _onStatisticsInfo(statisticsInfo) {
var _this8 = this;
Promise.resolve().then(function () {
_this8._emitter.emit(transmuxing_events.STATISTICS_INFO, statisticsInfo);
});
}
}, {
key: "_onIOError",
value: function _onIOError(type, info) {
var _this9 = this;
Promise.resolve().then(function () {
_this9._emitter.emit(transmuxing_events.IO_ERROR, type, info);
});
}
}, {
key: "_onDemuxError",
value: function _onDemuxError(type, info) {
var _this10 = this;
Promise.resolve().then(function () {
_this10._emitter.emit(transmuxing_events.DEMUX_ERROR, type, info);
});
}
}, {
key: "_onRecommendSeekpoint",
value: function _onRecommendSeekpoint(milliseconds) {
var _this11 = this;
Promise.resolve().then(function () {
_this11._emitter.emit(transmuxing_events.RECOMMEND_SEEKPOINT, milliseconds);
});
}
}, {
key: "_onLoggingConfigChanged",
value: function _onLoggingConfigChanged(config) {
if (this._worker) {
this._worker.postMessage({
cmd: 'logging_config',
param: config
});
}
}
}, {
key: "_onWorkerMessage",
value: function _onWorkerMessage(e) {
var message = e.data;
var data = message.data;
if (message.msg === 'destroyed' || this._workerDestroying) {
this._workerDestroying = false;
this._worker.terminate();
this._worker = null;
return;
}
switch (message.msg) {
case transmuxing_events.INIT_SEGMENT:
case transmuxing_events.MEDIA_SEGMENT:
this._emitter.emit(message.msg, data.type, data.data);
break;
case transmuxing_events.LOADING_COMPLETE:
case transmuxing_events.RECOVERED_EARLY_EOF:
this._emitter.emit(message.msg);
break;
case transmuxing_events.MEDIA_INFO:
Object.setPrototypeOf(data, media_info.prototype);
this._emitter.emit(message.msg, data);
break;
case transmuxing_events.METADATA_ARRIVED:
case transmuxing_events.SCRIPTDATA_ARRIVED:
case transmuxing_events.STATISTICS_INFO:
this._emitter.emit(message.msg, data);
break;
case transmuxing_events.IO_ERROR:
case transmuxing_events.DEMUX_ERROR:
this._emitter.emit(message.msg, data.type, data.info);
break;
case transmuxing_events.RECOMMEND_SEEKPOINT:
this._emitter.emit(message.msg, data);
break;
case 'logcat_callback':
logger.emitter.emit('log', data.type, data.logcat);
break;
default:
break;
}
}
}]);
return Transmuxer;
}();
/* harmony default export */ var transmuxer = (Transmuxer);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/core/mse-events.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var MSEEvents = {
ERROR: 'error',
SOURCE_OPEN: 'source_open',
UPDATE_END: 'update_end',
BUFFER_FULL: 'buffer_full'
};
/* harmony default export */ var mse_events = (MSEEvents);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/core/mse-controller.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// Media Source Extensions controller
var MSEController = /*#__PURE__*/function () {
function MSEController(config) {
classCallCheck_default()(this, MSEController);
this.TAG = 'MSEController';
this._config = config;
this._emitter = new (events_default())();
if (this._config.isLive && this._config.autoCleanupSourceBuffer == undefined) {
// For live stream, do auto cleanup by default
this._config.autoCleanupSourceBuffer = true;
}
this.e = {
onSourceOpen: this._onSourceOpen.bind(this),
onSourceEnded: this._onSourceEnded.bind(this),
onSourceClose: this._onSourceClose.bind(this),
onSourceBufferError: this._onSourceBufferError.bind(this),
onSourceBufferUpdateEnd: this._onSourceBufferUpdateEnd.bind(this)
};
this._mediaSource = null;
this._mediaSourceObjectURL = null;
this._mediaElement = null;
this._isBufferFull = false;
this._hasPendingEos = false;
this._requireSetMediaDuration = false;
this._pendingMediaDuration = 0;
this._pendingSourceBufferInit = [];
this._mimeTypes = {
video: null,
audio: null
};
this._sourceBuffers = {
video: null,
audio: null
};
this._lastInitSegments = {
video: null,
audio: null
};
this._pendingSegments = {
video: [],
audio: []
};
this._pendingRemoveRanges = {
video: [],
audio: []
};
this._idrList = new IDRSampleList();
}
createClass_default()(MSEController, [{
key: "destroy",
value: function destroy() {
if (this._mediaElement || this._mediaSource) {
this.detachMediaElement();
}
this.e = null;
this._emitter.removeAllListeners();
this._emitter = null;
}
}, {
key: "on",
value: function on(event, listener) {
this._emitter.addListener(event, listener);
}
}, {
key: "off",
value: function off(event, listener) {
this._emitter.removeListener(event, listener);
}
}, {
key: "attachMediaElement",
value: function attachMediaElement(mediaElement) {
if (this._mediaSource) {
throw new IllegalStateException('MediaSource has been attached to an HTMLMediaElement!');
}
var ms = this._mediaSource = new window.MediaSource();
ms.addEventListener('sourceopen', this.e.onSourceOpen);
ms.addEventListener('sourceended', this.e.onSourceEnded);
ms.addEventListener('sourceclose', this.e.onSourceClose);
this._mediaElement = mediaElement;
this._mediaSourceObjectURL = window.URL.createObjectURL(this._mediaSource);
mediaElement.src = this._mediaSourceObjectURL;
}
}, {
key: "detachMediaElement",
value: function detachMediaElement() {
if (this._mediaSource) {
var ms = this._mediaSource;
for (var type in this._sourceBuffers) {
// pending segments should be discard
var ps = this._pendingSegments[type];
ps.splice(0, ps.length);
this._pendingSegments[type] = null;
this._pendingRemoveRanges[type] = null;
this._lastInitSegments[type] = null;
// remove all sourcebuffers
var sb = this._sourceBuffers[type];
if (sb) {
if (ms.readyState !== 'closed') {
// ms edge can throw an error: Unexpected call to method or property access
try {
ms.removeSourceBuffer(sb);
} catch (error) {
logger.e(this.TAG, error.message);
}
sb.removeEventListener('error', this.e.onSourceBufferError);
sb.removeEventListener('updateend', this.e.onSourceBufferUpdateEnd);
}
this._mimeTypes[type] = null;
this._sourceBuffers[type] = null;
}
}
if (ms.readyState === 'open') {
try {
ms.endOfStream();
} catch (error) {
logger.e(this.TAG, error.message);
}
}
ms.removeEventListener('sourceopen', this.e.onSourceOpen);
ms.removeEventListener('sourceended', this.e.onSourceEnded);
ms.removeEventListener('sourceclose', this.e.onSourceClose);
this._pendingSourceBufferInit = [];
this._isBufferFull = false;
this._idrList.clear();
this._mediaSource = null;
}
if (this._mediaElement) {
this._mediaElement.src = '';
this._mediaElement.removeAttribute('src');
this._mediaElement = null;
}
if (this._mediaSourceObjectURL) {
window.URL.revokeObjectURL(this._mediaSourceObjectURL);
this._mediaSourceObjectURL = null;
}
}
}, {
key: "appendInitSegment",
value: function appendInitSegment(initSegment, deferred) {
if (!this._mediaSource || this._mediaSource.readyState !== 'open') {
// sourcebuffer creation requires mediaSource.readyState === 'open'
// so we defer the sourcebuffer creation, until sourceopen event triggered
this._pendingSourceBufferInit.push(initSegment);
// make sure that this InitSegment is in the front of pending segments queue
this._pendingSegments[initSegment.type].push(initSegment);
return;
}
var is = initSegment;
var mimeType = "".concat(is.container);
if (is.codec && is.codec.length > 0) {
mimeType += ";codecs=".concat(is.codec);
}
var firstInitSegment = false;
logger.v(this.TAG, 'Received Initialization Segment, mimeType: ' + mimeType);
this._lastInitSegments[is.type] = is;
if (mimeType !== this._mimeTypes[is.type]) {
if (!this._mimeTypes[is.type]) {
// empty, first chance create sourcebuffer
firstInitSegment = true;
try {
var sb = this._sourceBuffers[is.type] = this._mediaSource.addSourceBuffer(mimeType);
sb.addEventListener('error', this.e.onSourceBufferError);
sb.addEventListener('updateend', this.e.onSourceBufferUpdateEnd);
} catch (error) {
logger.e(this.TAG, error.message);
this._emitter.emit(mse_events.ERROR, {
code: error.code,
msg: error.message
});
return;
}
} else {
logger.v(this.TAG, "Notice: ".concat(is.type, " mimeType changed, origin: ").concat(this._mimeTypes[is.type], ", target: ").concat(mimeType));
}
this._mimeTypes[is.type] = mimeType;
}
if (!deferred) {
// deferred means this InitSegment has been pushed to pendingSegments queue
this._pendingSegments[is.type].push(is);
}
if (!firstInitSegment) {
// append immediately only if init segment in subsequence
if (this._sourceBuffers[is.type] && !this._sourceBuffers[is.type].updating) {
this._doAppendSegments();
}
}
if (browser.safari && is.container === 'audio/mpeg' && is.mediaDuration > 0) {
// 'audio/mpeg' track under Safari may cause MediaElement's duration to be NaN
// Manually correct MediaSource.duration to make progress bar seekable, and report right duration
this._requireSetMediaDuration = true;
this._pendingMediaDuration = is.mediaDuration / 1000; // in seconds
this._updateMediaSourceDuration();
}
}
}, {
key: "appendMediaSegment",
value: function appendMediaSegment(mediaSegment) {
var ms = mediaSegment;
this._pendingSegments[ms.type].push(ms);
if (this._config.autoCleanupSourceBuffer && this._needCleanupSourceBuffer()) {
this._doCleanupSourceBuffer();
}
var sb = this._sourceBuffers[ms.type];
if (sb && !sb.updating && !this._hasPendingRemoveRanges()) {
this._doAppendSegments();
}
}
}, {
key: "seek",
value: function seek(seconds) {
// remove all appended buffers
for (var type in this._sourceBuffers) {
if (!this._sourceBuffers[type]) {
continue;
}
// abort current buffer append algorithm
var sb = this._sourceBuffers[type];
if (this._mediaSource.readyState === 'open') {
try {
// If range removal algorithm is running, InvalidStateError will be throwed
// Ignore it.
sb.abort();
} catch (error) {
logger.e(this.TAG, error.message);
}
}
// IDRList should be clear
this._idrList.clear();
// pending segments should be discard
var ps = this._pendingSegments[type];
ps.splice(0, ps.length);
if (this._mediaSource.readyState === 'closed') {
// Parent MediaSource object has been detached from HTMLMediaElement
continue;
}
// record ranges to be remove from SourceBuffer
for (var i = 0; i < sb.buffered.length; i++) {
var start = sb.buffered.start(i);
var end = sb.buffered.end(i);
this._pendingRemoveRanges[type].push({
start: start,
end: end
});
}
// if sb is not updating, let's remove ranges now!
if (!sb.updating) {
this._doRemoveRanges();
}
// Safari 10 may get InvalidStateError in the later appendBuffer() after SourceBuffer.remove() call
// Internal parser's state may be invalid at this time. Re-append last InitSegment to workaround.
// Related issue: https://bugs.webkit.org/show_bug.cgi?id=159230
if (browser.safari) {
var lastInitSegment = this._lastInitSegments[type];
if (lastInitSegment) {
this._pendingSegments[type].push(lastInitSegment);
if (!sb.updating) {
this._doAppendSegments();
}
}
}
}
}
}, {
key: "endOfStream",
value: function endOfStream() {
var ms = this._mediaSource;
var sb = this._sourceBuffers;
if (!ms || ms.readyState !== 'open') {
if (ms && ms.readyState === 'closed' && this._hasPendingSegments()) {
// If MediaSource hasn't turned into open state, and there're pending segments
// Mark pending endOfStream, defer call until all pending segments appended complete
this._hasPendingEos = true;
}
return;
}
if (sb.video && sb.video.updating || sb.audio && sb.audio.updating) {
// If any sourcebuffer is updating, defer endOfStream operation
// See _onSourceBufferUpdateEnd()
this._hasPendingEos = true;
} else {
this._hasPendingEos = false;
// Notify media data loading complete
// This is helpful for correcting total duration to match last media segment
// Otherwise MediaElement's ended event may not be triggered
ms.endOfStream();
}
}
}, {
key: "getNearestKeyframe",
value: function getNearestKeyframe(dts) {
return this._idrList.getLastSyncPointBeforeDts(dts);
}
}, {
key: "_needCleanupSourceBuffer",
value: function _needCleanupSourceBuffer() {
if (!this._config.autoCleanupSourceBuffer) {
return false;
}
var currentTime = this._mediaElement.currentTime;
for (var type in this._sourceBuffers) {
var sb = this._sourceBuffers[type];
if (sb) {
var buffered = sb.buffered;
if (buffered.length >= 1) {
if (currentTime - buffered.start(0) >= this._config.autoCleanupMaxBackwardDuration) {
return true;
}
}
}
}
return false;
}
}, {
key: "_doCleanupSourceBuffer",
value: function _doCleanupSourceBuffer() {
var currentTime = this._mediaElement.currentTime;
for (var type in this._sourceBuffers) {
var sb = this._sourceBuffers[type];
if (sb) {
var buffered = sb.buffered;
var doRemove = false;
for (var i = 0; i < buffered.length; i++) {
var start = buffered.start(i);
var end = buffered.end(i);
if (start <= currentTime && currentTime < end + 3) {
// padding 3 seconds
if (currentTime - start >= this._config.autoCleanupMaxBackwardDuration) {
doRemove = true;
var removeEnd = currentTime - this._config.autoCleanupMinBackwardDuration;
this._pendingRemoveRanges[type].push({
start: start,
end: removeEnd
});
}
} else if (end < currentTime) {
doRemove = true;
this._pendingRemoveRanges[type].push({
start: start,
end: end
});
}
}
if (doRemove && !sb.updating) {
this._doRemoveRanges();
}
}
}
}
}, {
key: "_updateMediaSourceDuration",
value: function _updateMediaSourceDuration() {
var sb = this._sourceBuffers;
if (this._mediaElement.readyState === 0 || this._mediaSource.readyState !== 'open') {
return;
}
if (sb.video && sb.video.updating || sb.audio && sb.audio.updating) {
return;
}
var current = this._mediaSource.duration;
var target = this._pendingMediaDuration;
if (target > 0 && (isNaN(current) || target > current)) {
logger.v(this.TAG, "Update MediaSource duration from ".concat(current, " to ").concat(target));
this._mediaSource.duration = target;
}
this._requireSetMediaDuration = false;
this._pendingMediaDuration = 0;
}
}, {
key: "_doRemoveRanges",
value: function _doRemoveRanges() {
for (var type in this._pendingRemoveRanges) {
if (!this._sourceBuffers[type] || this._sourceBuffers[type].updating) {
continue;
}
var sb = this._sourceBuffers[type];
var ranges = this._pendingRemoveRanges[type];
while (ranges.length && !sb.updating) {
var range = ranges.shift();
sb.remove(range.start, range.end);
}
}
}
}, {
key: "_doAppendSegments",
value: function _doAppendSegments() {
var pendingSegments = this._pendingSegments;
for (var type in pendingSegments) {
if (!this._sourceBuffers[type] || this._sourceBuffers[type].updating) {
continue;
}
if (pendingSegments[type].length > 0) {
var segment = pendingSegments[type].shift();
if (segment.timestampOffset) {
// For MPEG audio stream in MSE, if unbuffered-seeking occurred
// We need explicitly set timestampOffset to the desired point in timeline for mpeg SourceBuffer.
var currentOffset = this._sourceBuffers[type].timestampOffset;
var targetOffset = segment.timestampOffset / 1000; // in seconds
var delta = Math.abs(currentOffset - targetOffset);
if (delta > 0.1) {
// If time delta > 100ms
logger.v(this.TAG, "Update MPEG audio timestampOffset from ".concat(currentOffset, " to ").concat(targetOffset));
this._sourceBuffers[type].timestampOffset = targetOffset;
}
delete segment.timestampOffset;
}
if (!segment.data || segment.data.byteLength === 0) {
// Ignore empty buffer
continue;
}
try {
this._sourceBuffers[type].appendBuffer(segment.data);
this._isBufferFull = false;
if (type === 'video' && segment.hasOwnProperty('info')) {
this._idrList.appendArray(segment.info.syncPoints);
}
} catch (error) {
this._pendingSegments[type].unshift(segment);
if (error.code === 22) {
// QuotaExceededError
/* Notice that FireFox may not throw QuotaExceededError if SourceBuffer is full
* Currently we can only do lazy-load to avoid SourceBuffer become scattered.
* SourceBuffer eviction policy may be changed in future version of FireFox.
*
* Related issues:
* https://bugzilla.mozilla.org/show_bug.cgi?id=1279885
* https://bugzilla.mozilla.org/show_bug.cgi?id=1280023
*/
// report buffer full, abort network IO
if (!this._isBufferFull) {
this._emitter.emit(mse_events.BUFFER_FULL);
}
this._isBufferFull = true;
} else {
logger.e(this.TAG, error.message);
this._emitter.emit(mse_events.ERROR, {
code: error.code,
msg: error.message
});
}
}
}
}
}
}, {
key: "_onSourceOpen",
value: function _onSourceOpen() {
logger.v(this.TAG, 'MediaSource onSourceOpen');
this._mediaSource.removeEventListener('sourceopen', this.e.onSourceOpen);
// deferred sourcebuffer creation / initialization
if (this._pendingSourceBufferInit.length > 0) {
var pendings = this._pendingSourceBufferInit;
while (pendings.length) {
var segment = pendings.shift();
this.appendInitSegment(segment, true);
}
}
// there may be some pending media segments, append them
if (this._hasPendingSegments()) {
this._doAppendSegments();
}
this._emitter.emit(mse_events.SOURCE_OPEN);
}
}, {
key: "_onSourceEnded",
value: function _onSourceEnded() {
// fired on endOfStream
logger.v(this.TAG, 'MediaSource onSourceEnded');
}
}, {
key: "_onSourceClose",
value: function _onSourceClose() {
// fired on detaching from media element
logger.v(this.TAG, 'MediaSource onSourceClose');
if (this._mediaSource && this.e != null) {
this._mediaSource.removeEventListener('sourceopen', this.e.onSourceOpen);
this._mediaSource.removeEventListener('sourceended', this.e.onSourceEnded);
this._mediaSource.removeEventListener('sourceclose', this.e.onSourceClose);
}
}
}, {
key: "_hasPendingSegments",
value: function _hasPendingSegments() {
var ps = this._pendingSegments;
return ps.video.length > 0 || ps.audio.length > 0;
}
}, {
key: "_hasPendingRemoveRanges",
value: function _hasPendingRemoveRanges() {
var prr = this._pendingRemoveRanges;
return prr.video.length > 0 || prr.audio.length > 0;
}
}, {
key: "_onSourceBufferUpdateEnd",
value: function _onSourceBufferUpdateEnd() {
if (this._requireSetMediaDuration) {
this._updateMediaSourceDuration();
} else if (this._hasPendingRemoveRanges()) {
this._doRemoveRanges();
} else if (this._hasPendingSegments()) {
this._doAppendSegments();
} else if (this._hasPendingEos) {
this.endOfStream();
}
this._emitter.emit(mse_events.UPDATE_END);
}
}, {
key: "_onSourceBufferError",
value: function _onSourceBufferError(e) {
logger.e(this.TAG, "SourceBuffer Error: ".concat(e));
// this error might not always be fatal, just ignore it
}
}]);
return MSEController;
}();
/* harmony default export */ var mse_controller = (MSEController);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/player/player-errors.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var ErrorTypes = {
NETWORK_ERROR: 'NetworkError',
MEDIA_ERROR: 'MediaError',
OTHER_ERROR: 'OtherError'
};
var ErrorDetails = {
NETWORK_EXCEPTION: loader_LoaderErrors.EXCEPTION,
NETWORK_STATUS_CODE_INVALID: loader_LoaderErrors.HTTP_STATUS_CODE_INVALID,
NETWORK_TIMEOUT: loader_LoaderErrors.CONNECTING_TIMEOUT,
NETWORK_UNRECOVERABLE_EARLY_EOF: loader_LoaderErrors.UNRECOVERABLE_EARLY_EOF,
MEDIA_MSE_ERROR: 'MediaMSEError',
MEDIA_FORMAT_ERROR: demux_errors.FORMAT_ERROR,
MEDIA_FORMAT_UNSUPPORTED: demux_errors.FORMAT_UNSUPPORTED,
MEDIA_CODEC_UNSUPPORTED: demux_errors.CODEC_UNSUPPORTED
};
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/player/flv-player.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var FlvPlayer = /*#__PURE__*/function () {
function FlvPlayer(mediaDataSource, config) {
classCallCheck_default()(this, FlvPlayer);
this.TAG = 'FlvPlayer';
this._type = 'FlvPlayer';
this._emitter = new (events_default())();
this._config = createDefaultConfig();
if (typeof_default()(config) === 'object') {
Object.assign(this._config, config);
}
if (mediaDataSource.type.toLowerCase() !== 'flv') {
throw new InvalidArgumentException('FlvPlayer requires an flv MediaDataSource input!');
}
if (mediaDataSource.isLive === true) {
this._config.isLive = true;
}
this.e = {
onvLoadedMetadata: this._onvLoadedMetadata.bind(this),
onvSeeking: this._onvSeeking.bind(this),
onvCanPlay: this._onvCanPlay.bind(this),
onvStalled: this._onvStalled.bind(this),
onvProgress: this._onvProgress.bind(this)
};
if (self.performance && self.performance.now) {
this._now = self.performance.now.bind(self.performance);
} else {
this._now = Date.now;
}
this._pendingSeekTime = null; // in seconds
this._requestSetTime = false;
this._seekpointRecord = null;
this._progressChecker = null;
this._mediaDataSource = mediaDataSource;
this._mediaElement = null;
this._msectl = null;
this._transmuxer = null;
this._mseSourceOpened = false;
this._hasPendingLoad = false;
this._receivedCanPlay = false;
this._mediaInfo = null;
this._statisticsInfo = null;
var chromeNeedIDRFix = browser.chrome && (browser.version.major < 50 || browser.version.major === 50 && browser.version.build < 2661);
this._alwaysSeekKeyframe = chromeNeedIDRFix || browser.msedge || browser.msie ? true : false;
if (this._alwaysSeekKeyframe) {
this._config.accurateSeek = false;
}
}
createClass_default()(FlvPlayer, [{
key: "destroy",
value: function destroy() {
if (this._progressChecker != null) {
window.clearInterval(this._progressChecker);
this._progressChecker = null;
}
if (this._transmuxer) {
this.unload();
}
if (this._mediaElement) {
this.detachMediaElement();
}
this.e = null;
this._mediaDataSource = null;
this._emitter.removeAllListeners();
this._emitter = null;
}
}, {
key: "on",
value: function on(event, listener) {
var _this = this;
if (event === player_events.MEDIA_INFO) {
if (this._mediaInfo != null) {
Promise.resolve().then(function () {
_this._emitter.emit(player_events.MEDIA_INFO, _this.mediaInfo);
});
}
} else if (event === player_events.STATISTICS_INFO) {
if (this._statisticsInfo != null) {
Promise.resolve().then(function () {
_this._emitter.emit(player_events.STATISTICS_INFO, _this.statisticsInfo);
});
}
}
this._emitter.addListener(event, listener);
}
}, {
key: "off",
value: function off(event, listener) {
this._emitter.removeListener(event, listener);
}
}, {
key: "attachMediaElement",
value: function attachMediaElement(mediaElement) {
var _this2 = this;
this._mediaElement = mediaElement;
mediaElement.addEventListener('loadedmetadata', this.e.onvLoadedMetadata);
mediaElement.addEventListener('seeking', this.e.onvSeeking);
mediaElement.addEventListener('canplay', this.e.onvCanPlay);
mediaElement.addEventListener('stalled', this.e.onvStalled);
mediaElement.addEventListener('progress', this.e.onvProgress);
this._msectl = new mse_controller(this._config);
this._msectl.on(mse_events.UPDATE_END, this._onmseUpdateEnd.bind(this));
this._msectl.on(mse_events.BUFFER_FULL, this._onmseBufferFull.bind(this));
this._msectl.on(mse_events.SOURCE_OPEN, function () {
_this2._mseSourceOpened = true;
if (_this2._hasPendingLoad) {
_this2._hasPendingLoad = false;
_this2.load();
}
});
this._msectl.on(mse_events.ERROR, function (info) {
_this2._emitter.emit(player_events.ERROR, ErrorTypes.MEDIA_ERROR, ErrorDetails.MEDIA_MSE_ERROR, info);
});
this._msectl.attachMediaElement(mediaElement);
if (this._pendingSeekTime != null) {
try {
mediaElement.currentTime = this._pendingSeekTime;
this._pendingSeekTime = null;
} catch (e) {
// IE11 may throw InvalidStateError if readyState === 0
// We can defer set currentTime operation after loadedmetadata
}
}
}
}, {
key: "detachMediaElement",
value: function detachMediaElement() {
if (this._mediaElement) {
this._msectl.detachMediaElement();
this._mediaElement.removeEventListener('loadedmetadata', this.e.onvLoadedMetadata);
this._mediaElement.removeEventListener('seeking', this.e.onvSeeking);
this._mediaElement.removeEventListener('canplay', this.e.onvCanPlay);
this._mediaElement.removeEventListener('stalled', this.e.onvStalled);
this._mediaElement.removeEventListener('progress', this.e.onvProgress);
this._mediaElement = null;
}
if (this._msectl) {
this._msectl.destroy();
this._msectl = null;
}
}
}, {
key: "load",
value: function load() {
var _this3 = this;
if (!this._mediaElement) {
throw new IllegalStateException('HTMLMediaElement must be attached before load()!');
}
if (this._transmuxer) {
throw new IllegalStateException('FlvPlayer.load() has been called, please call unload() first!');
}
if (this._hasPendingLoad) {
return;
}
if (this._config.deferLoadAfterSourceOpen && this._mseSourceOpened === false) {
this._hasPendingLoad = true;
return;
}
if (this._mediaElement.readyState > 0) {
this._requestSetTime = true;
// IE11 may throw InvalidStateError if readyState === 0
this._mediaElement.currentTime = 0;
}
this._transmuxer = new transmuxer(this._mediaDataSource, this._config);
this._transmuxer.on(transmuxing_events.INIT_SEGMENT, function (type, is) {
_this3._msectl.appendInitSegment(is);
});
this._transmuxer.on(transmuxing_events.MEDIA_SEGMENT, function (type, ms) {
_this3._msectl.appendMediaSegment(ms);
// lazyLoad check
if (_this3._config.lazyLoad && !_this3._config.isLive) {
var currentTime = _this3._mediaElement.currentTime;
if (ms.info.endDts >= (currentTime + _this3._config.lazyLoadMaxDuration) * 1000) {
if (_this3._progressChecker == null) {
logger.v(_this3.TAG, 'Maximum buffering duration exceeded, suspend transmuxing task');
_this3._suspendTransmuxer();
}
}
}
});
this._transmuxer.on(transmuxing_events.LOADING_COMPLETE, function () {
_this3._msectl.endOfStream();
_this3._emitter.emit(player_events.LOADING_COMPLETE);
});
this._transmuxer.on(transmuxing_events.RECOVERED_EARLY_EOF, function () {
_this3._emitter.emit(player_events.RECOVERED_EARLY_EOF);
});
this._transmuxer.on(transmuxing_events.IO_ERROR, function (detail, info) {
_this3._emitter.emit(player_events.ERROR, ErrorTypes.NETWORK_ERROR, detail, info);
});
this._transmuxer.on(transmuxing_events.DEMUX_ERROR, function (detail, info) {
_this3._emitter.emit(player_events.ERROR, ErrorTypes.MEDIA_ERROR, detail, {
code: -1,
msg: info
});
});
this._transmuxer.on(transmuxing_events.MEDIA_INFO, function (mediaInfo) {
_this3._mediaInfo = mediaInfo;
_this3._emitter.emit(player_events.MEDIA_INFO, Object.assign({}, mediaInfo));
});
this._transmuxer.on(transmuxing_events.METADATA_ARRIVED, function (metadata) {
_this3._emitter.emit(player_events.METADATA_ARRIVED, metadata);
});
this._transmuxer.on(transmuxing_events.SCRIPTDATA_ARRIVED, function (data) {
_this3._emitter.emit(player_events.SCRIPTDATA_ARRIVED, data);
});
this._transmuxer.on(transmuxing_events.STATISTICS_INFO, function (statInfo) {
_this3._statisticsInfo = _this3._fillStatisticsInfo(statInfo);
_this3._emitter.emit(player_events.STATISTICS_INFO, Object.assign({}, _this3._statisticsInfo));
});
this._transmuxer.on(transmuxing_events.RECOMMEND_SEEKPOINT, function (milliseconds) {
if (_this3._mediaElement && !_this3._config.accurateSeek) {
_this3._requestSetTime = true;
_this3._mediaElement.currentTime = milliseconds / 1000;
}
});
this._transmuxer.open();
}
}, {
key: "unload",
value: function unload() {
if (this._mediaElement) {
this._mediaElement.pause();
}
if (this._msectl) {
this._msectl.seek(0);
}
if (this._transmuxer) {
this._transmuxer.close();
this._transmuxer.destroy();
this._transmuxer = null;
}
}
}, {
key: "play",
value: function play() {
return this._mediaElement.play();
}
}, {
key: "pause",
value: function pause() {
this._mediaElement.pause();
}
}, {
key: "type",
get: function get() {
return this._type;
}
}, {
key: "buffered",
get: function get() {
return this._mediaElement.buffered;
}
}, {
key: "duration",
get: function get() {
return this._mediaElement.duration;
}
}, {
key: "volume",
get: function get() {
return this._mediaElement.volume;
},
set: function set(value) {
this._mediaElement.volume = value;
}
}, {
key: "muted",
get: function get() {
return this._mediaElement.muted;
},
set: function set(muted) {
this._mediaElement.muted = muted;
}
}, {
key: "currentTime",
get: function get() {
if (this._mediaElement) {
return this._mediaElement.currentTime;
}
return 0;
},
set: function set(seconds) {
if (this._mediaElement) {
this._internalSeek(seconds);
} else {
this._pendingSeekTime = seconds;
}
}
}, {
key: "mediaInfo",
get: function get() {
return Object.assign({}, this._mediaInfo);
}
}, {
key: "statisticsInfo",
get: function get() {
if (this._statisticsInfo == null) {
this._statisticsInfo = {};
}
this._statisticsInfo = this._fillStatisticsInfo(this._statisticsInfo);
return Object.assign({}, this._statisticsInfo);
}
}, {
key: "_fillStatisticsInfo",
value: function _fillStatisticsInfo(statInfo) {
statInfo.playerType = this._type;
if (!(this._mediaElement instanceof HTMLVideoElement)) {
return statInfo;
}
var hasQualityInfo = true;
var decoded = 0;
var dropped = 0;
if (this._mediaElement.getVideoPlaybackQuality) {
var quality = this._mediaElement.getVideoPlaybackQuality();
decoded = quality.totalVideoFrames;
dropped = quality.droppedVideoFrames;
} else if (this._mediaElement.webkitDecodedFrameCount != undefined) {
decoded = this._mediaElement.webkitDecodedFrameCount;
dropped = this._mediaElement.webkitDroppedFrameCount;
} else {
hasQualityInfo = false;
}
if (hasQualityInfo) {
statInfo.decodedFrames = decoded;
statInfo.droppedFrames = dropped;
}
return statInfo;
}
}, {
key: "_onmseUpdateEnd",
value: function _onmseUpdateEnd() {
if (!this._config.lazyLoad || this._config.isLive) {
return;
}
var buffered = this._mediaElement.buffered;
var currentTime = this._mediaElement.currentTime;
var currentRangeStart = 0;
var currentRangeEnd = 0;
for (var i = 0; i < buffered.length; i++) {
var start = buffered.start(i);
var end = buffered.end(i);
if (start <= currentTime && currentTime < end) {
currentRangeStart = start;
currentRangeEnd = end;
break;
}
}
if (currentRangeEnd >= currentTime + this._config.lazyLoadMaxDuration && this._progressChecker == null) {
logger.v(this.TAG, 'Maximum buffering duration exceeded, suspend transmuxing task');
this._suspendTransmuxer();
}
}
}, {
key: "_onmseBufferFull",
value: function _onmseBufferFull() {
logger.v(this.TAG, 'MSE SourceBuffer is full, suspend transmuxing task');
if (this._progressChecker == null) {
this._suspendTransmuxer();
}
}
}, {
key: "_suspendTransmuxer",
value: function _suspendTransmuxer() {
if (this._transmuxer) {
this._transmuxer.pause();
if (this._progressChecker == null) {
this._progressChecker = window.setInterval(this._checkProgressAndResume.bind(this), 1000);
}
}
}
}, {
key: "_checkProgressAndResume",
value: function _checkProgressAndResume() {
var currentTime = this._mediaElement.currentTime;
var buffered = this._mediaElement.buffered;
var needResume = false;
for (var i = 0; i < buffered.length; i++) {
var from = buffered.start(i);
var to = buffered.end(i);
if (currentTime >= from && currentTime < to) {
if (currentTime >= to - this._config.lazyLoadRecoverDuration) {
needResume = true;
}
break;
}
}
if (needResume) {
window.clearInterval(this._progressChecker);
this._progressChecker = null;
if (needResume) {
logger.v(this.TAG, 'Continue loading from paused position');
this._transmuxer.resume();
}
}
}
}, {
key: "_isTimepointBuffered",
value: function _isTimepointBuffered(seconds) {
var buffered = this._mediaElement.buffered;
for (var i = 0; i < buffered.length; i++) {
var from = buffered.start(i);
var to = buffered.end(i);
if (seconds >= from && seconds < to) {
return true;
}
}
return false;
}
}, {
key: "_internalSeek",
value: function _internalSeek(seconds) {
var directSeek = this._isTimepointBuffered(seconds);
var directSeekBegin = false;
var directSeekBeginTime = 0;
if (seconds < 1.0 && this._mediaElement.buffered.length > 0) {
var videoBeginTime = this._mediaElement.buffered.start(0);
if (videoBeginTime < 1.0 && seconds < videoBeginTime || browser.safari) {
directSeekBegin = true;
// also workaround for Safari: Seek to 0 may cause video stuck, use 0.1 to avoid
directSeekBeginTime = browser.safari ? 0.1 : videoBeginTime;
}
}
if (directSeekBegin) {
// seek to video begin, set currentTime directly if beginPTS buffered
this._requestSetTime = true;
this._mediaElement.currentTime = directSeekBeginTime;
} else if (directSeek) {
// buffered position
if (!this._alwaysSeekKeyframe) {
this._requestSetTime = true;
this._mediaElement.currentTime = seconds;
} else {
var idr = this._msectl.getNearestKeyframe(Math.floor(seconds * 1000));
this._requestSetTime = true;
if (idr != null) {
this._mediaElement.currentTime = idr.dts / 1000;
} else {
this._mediaElement.currentTime = seconds;
}
}
if (this._progressChecker != null) {
this._checkProgressAndResume();
}
} else {
if (this._progressChecker != null) {
window.clearInterval(this._progressChecker);
this._progressChecker = null;
}
this._msectl.seek(seconds);
this._transmuxer.seek(Math.floor(seconds * 1000)); // in milliseconds
// no need to set mediaElement.currentTime if non-accurateSeek,
// just wait for the recommend_seekpoint callback
if (this._config.accurateSeek) {
this._requestSetTime = true;
this._mediaElement.currentTime = seconds;
}
}
}
}, {
key: "_checkAndApplyUnbufferedSeekpoint",
value: function _checkAndApplyUnbufferedSeekpoint() {
if (this._seekpointRecord) {
if (this._seekpointRecord.recordTime <= this._now() - 100) {
var target = this._mediaElement.currentTime;
this._seekpointRecord = null;
if (!this._isTimepointBuffered(target)) {
if (this._progressChecker != null) {
window.clearTimeout(this._progressChecker);
this._progressChecker = null;
}
// .currentTime is consists with .buffered timestamp
// Chrome/Edge use DTS, while FireFox/Safari use PTS
this._msectl.seek(target);
this._transmuxer.seek(Math.floor(target * 1000));
// set currentTime if accurateSeek, or wait for recommend_seekpoint callback
if (this._config.accurateSeek) {
this._requestSetTime = true;
this._mediaElement.currentTime = target;
}
}
} else {
window.setTimeout(this._checkAndApplyUnbufferedSeekpoint.bind(this), 50);
}
}
}
}, {
key: "_checkAndResumeStuckPlayback",
value: function _checkAndResumeStuckPlayback(stalled) {
var media = this._mediaElement;
if (stalled || !this._receivedCanPlay || media.readyState < 2) {
// HAVE_CURRENT_DATA
var buffered = media.buffered;
if (buffered.length > 0 && media.currentTime < buffered.start(0)) {
logger.w(this.TAG, "Playback seems stuck at ".concat(media.currentTime, ", seek to ").concat(buffered.start(0)));
this._requestSetTime = true;
this._mediaElement.currentTime = buffered.start(0);
this._mediaElement.removeEventListener('progress', this.e.onvProgress);
}
} else {
// Playback didn't stuck, remove progress event listener
this._mediaElement.removeEventListener('progress', this.e.onvProgress);
}
}
}, {
key: "_onvLoadedMetadata",
value: function _onvLoadedMetadata(e) {
if (this._pendingSeekTime != null) {
this._mediaElement.currentTime = this._pendingSeekTime;
this._pendingSeekTime = null;
}
}
}, {
key: "_onvSeeking",
value: function _onvSeeking(e) {
// handle seeking request from browser's progress bar
var target = this._mediaElement.currentTime;
var buffered = this._mediaElement.buffered;
if (this._requestSetTime) {
this._requestSetTime = false;
return;
}
if (target < 1.0 && buffered.length > 0) {
// seek to video begin, set currentTime directly if beginPTS buffered
var videoBeginTime = buffered.start(0);
if (videoBeginTime < 1.0 && target < videoBeginTime || browser.safari) {
this._requestSetTime = true;
// also workaround for Safari: Seek to 0 may cause video stuck, use 0.1 to avoid
this._mediaElement.currentTime = browser.safari ? 0.1 : videoBeginTime;
return;
}
}
if (this._isTimepointBuffered(target)) {
if (this._alwaysSeekKeyframe) {
var idr = this._msectl.getNearestKeyframe(Math.floor(target * 1000));
if (idr != null) {
this._requestSetTime = true;
this._mediaElement.currentTime = idr.dts / 1000;
}
}
if (this._progressChecker != null) {
this._checkProgressAndResume();
}
return;
}
this._seekpointRecord = {
seekPoint: target,
recordTime: this._now()
};
window.setTimeout(this._checkAndApplyUnbufferedSeekpoint.bind(this), 50);
}
}, {
key: "_onvCanPlay",
value: function _onvCanPlay(e) {
this._receivedCanPlay = true;
this._mediaElement.removeEventListener('canplay', this.e.onvCanPlay);
}
}, {
key: "_onvStalled",
value: function _onvStalled(e) {
this._checkAndResumeStuckPlayback(true);
}
}, {
key: "_onvProgress",
value: function _onvProgress(e) {
this._checkAndResumeStuckPlayback();
}
}]);
return FlvPlayer;
}();
/* harmony default export */ var flv_player = (FlvPlayer);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/player/native-player.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// Player wrapper for browser's native player (HTMLVideoElement) without MediaSource src.
var NativePlayer = /*#__PURE__*/function () {
function NativePlayer(mediaDataSource, config) {
classCallCheck_default()(this, NativePlayer);
this.TAG = 'NativePlayer';
this._type = 'NativePlayer';
this._emitter = new (events_default())();
this._config = createDefaultConfig();
if (typeof_default()(config) === 'object') {
Object.assign(this._config, config);
}
if (mediaDataSource.type.toLowerCase() === 'flv') {
throw new InvalidArgumentException('NativePlayer does\'t support flv MediaDataSource input!');
}
if (mediaDataSource.hasOwnProperty('segments')) {
throw new InvalidArgumentException("NativePlayer(".concat(mediaDataSource.type, ") doesn't support multipart playback!"));
}
this.e = {
onvLoadedMetadata: this._onvLoadedMetadata.bind(this)
};
this._pendingSeekTime = null;
this._statisticsReporter = null;
this._mediaDataSource = mediaDataSource;
this._mediaElement = null;
}
createClass_default()(NativePlayer, [{
key: "destroy",
value: function destroy() {
if (this._mediaElement) {
this.unload();
this.detachMediaElement();
}
this.e = null;
this._mediaDataSource = null;
this._emitter.removeAllListeners();
this._emitter = null;
}
}, {
key: "on",
value: function on(event, listener) {
var _this = this;
if (event === player_events.MEDIA_INFO) {
if (this._mediaElement != null && this._mediaElement.readyState !== 0) {
// HAVE_NOTHING
Promise.resolve().then(function () {
_this._emitter.emit(player_events.MEDIA_INFO, _this.mediaInfo);
});
}
} else if (event === player_events.STATISTICS_INFO) {
if (this._mediaElement != null && this._mediaElement.readyState !== 0) {
Promise.resolve().then(function () {
_this._emitter.emit(player_events.STATISTICS_INFO, _this.statisticsInfo);
});
}
}
this._emitter.addListener(event, listener);
}
}, {
key: "off",
value: function off(event, listener) {
this._emitter.removeListener(event, listener);
}
}, {
key: "attachMediaElement",
value: function attachMediaElement(mediaElement) {
this._mediaElement = mediaElement;
mediaElement.addEventListener('loadedmetadata', this.e.onvLoadedMetadata);
if (this._pendingSeekTime != null) {
try {
mediaElement.currentTime = this._pendingSeekTime;
this._pendingSeekTime = null;
} catch (e) {
// IE11 may throw InvalidStateError if readyState === 0
// Defer set currentTime operation after loadedmetadata
}
}
}
}, {
key: "detachMediaElement",
value: function detachMediaElement() {
if (this._mediaElement) {
this._mediaElement.src = '';
this._mediaElement.removeAttribute('src');
this._mediaElement.removeEventListener('loadedmetadata', this.e.onvLoadedMetadata);
this._mediaElement = null;
}
if (this._statisticsReporter != null) {
window.clearInterval(this._statisticsReporter);
this._statisticsReporter = null;
}
}
}, {
key: "load",
value: function load() {
if (!this._mediaElement) {
throw new IllegalStateException('HTMLMediaElement must be attached before load()!');
}
this._mediaElement.src = this._mediaDataSource.url;
if (this._mediaElement.readyState > 0) {
this._mediaElement.currentTime = 0;
}
this._mediaElement.preload = 'auto';
this._mediaElement.load();
this._statisticsReporter = window.setInterval(this._reportStatisticsInfo.bind(this), this._config.statisticsInfoReportInterval);
}
}, {
key: "unload",
value: function unload() {
if (this._mediaElement) {
this._mediaElement.src = '';
this._mediaElement.removeAttribute('src');
}
if (this._statisticsReporter != null) {
window.clearInterval(this._statisticsReporter);
this._statisticsReporter = null;
}
}
}, {
key: "play",
value: function play() {
return this._mediaElement.play();
}
}, {
key: "pause",
value: function pause() {
this._mediaElement.pause();
}
}, {
key: "type",
get: function get() {
return this._type;
}
}, {
key: "buffered",
get: function get() {
return this._mediaElement.buffered;
}
}, {
key: "duration",
get: function get() {
return this._mediaElement.duration;
}
}, {
key: "volume",
get: function get() {
return this._mediaElement.volume;
},
set: function set(value) {
this._mediaElement.volume = value;
}
}, {
key: "muted",
get: function get() {
return this._mediaElement.muted;
},
set: function set(muted) {
this._mediaElement.muted = muted;
}
}, {
key: "currentTime",
get: function get() {
if (this._mediaElement) {
return this._mediaElement.currentTime;
}
return 0;
},
set: function set(seconds) {
if (this._mediaElement) {
this._mediaElement.currentTime = seconds;
} else {
this._pendingSeekTime = seconds;
}
}
}, {
key: "mediaInfo",
get: function get() {
var mediaPrefix = this._mediaElement instanceof HTMLAudioElement ? 'audio/' : 'video/';
var info = {
mimeType: mediaPrefix + this._mediaDataSource.type
};
if (this._mediaElement) {
info.duration = Math.floor(this._mediaElement.duration * 1000);
if (this._mediaElement instanceof HTMLVideoElement) {
info.width = this._mediaElement.videoWidth;
info.height = this._mediaElement.videoHeight;
}
}
return info;
}
}, {
key: "statisticsInfo",
get: function get() {
var info = {
playerType: this._type,
url: this._mediaDataSource.url
};
if (!(this._mediaElement instanceof HTMLVideoElement)) {
return info;
}
var hasQualityInfo = true;
var decoded = 0;
var dropped = 0;
if (this._mediaElement.getVideoPlaybackQuality) {
var quality = this._mediaElement.getVideoPlaybackQuality();
decoded = quality.totalVideoFrames;
dropped = quality.droppedVideoFrames;
} else if (this._mediaElement.webkitDecodedFrameCount != undefined) {
decoded = this._mediaElement.webkitDecodedFrameCount;
dropped = this._mediaElement.webkitDroppedFrameCount;
} else {
hasQualityInfo = false;
}
if (hasQualityInfo) {
info.decodedFrames = decoded;
info.droppedFrames = dropped;
}
return info;
}
}, {
key: "_onvLoadedMetadata",
value: function _onvLoadedMetadata(e) {
if (this._pendingSeekTime != null) {
this._mediaElement.currentTime = this._pendingSeekTime;
this._pendingSeekTime = null;
}
this._emitter.emit(player_events.MEDIA_INFO, this.mediaInfo);
}
}, {
key: "_reportStatisticsInfo",
value: function _reportStatisticsInfo() {
this._emitter.emit(player_events.STATISTICS_INFO, this.statisticsInfo);
}
}]);
return NativePlayer;
}();
/* harmony default export */ var native_player = (NativePlayer);
;// CONCATENATED MODULE: ./node_modules/_flv.js@1.5.0@flv.js/src/flv.js
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// here are all the interfaces
// install polyfills
polyfill.install();
// factory method
function createPlayer(mediaDataSource, optionalConfig) {
var mds = mediaDataSource;
if (mds == null || typeof_default()(mds) !== 'object') {
throw new InvalidArgumentException('MediaDataSource must be an javascript object!');
}
if (!mds.hasOwnProperty('type')) {
throw new InvalidArgumentException('MediaDataSource must has type field to indicate video file type!');
}
switch (mds.type) {
case 'flv':
return new flv_player(mds, optionalConfig);
default:
return new native_player(mds, optionalConfig);
}
}
// feature detection
function isSupported() {
return features.supportMSEH264Playback();
}
function getFeatureList() {
return features.getFeatureList();
}
// interfaces
var flvjs = {};
flvjs.createPlayer = createPlayer;
flvjs.isSupported = isSupported;
flvjs.getFeatureList = getFeatureList;
flvjs.BaseLoader = loader_BaseLoader;
flvjs.LoaderStatus = loader_LoaderStatus;
flvjs.LoaderErrors = loader_LoaderErrors;
flvjs.Events = player_events;
flvjs.ErrorTypes = ErrorTypes;
flvjs.ErrorDetails = ErrorDetails;
flvjs.FlvPlayer = flv_player;
flvjs.NativePlayer = native_player;
flvjs.LoggingControl = logging_control;
Object.defineProperty(flvjs, 'version', {
enumerable: true,
get: function get() {
// replaced by browserify-versionify transform
return '__VERSION__';
}
});
/* harmony default export */ var flv = (flvjs);
/***/ }),
/***/ 3867:
/*!*************************************************************************!*\
!*** ./node_modules/_es6-promise@4.2.8@es6-promise/dist/es6-promise.js ***!
\*************************************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
/* provided dependency */ var process = __webpack_require__(/*! ./node_modules/_process@0.11.10@process/browser.js */ 97671);
/*!
* @overview es6-promise - a tiny implementation of Promises/A+.
* @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
* @license Licensed under MIT license
* See https://raw.githubusercontent.com/stefanpenner/es6-promise/master/LICENSE
* @version v4.2.8+1e68dce6
*/
(function (global, factory) {
true ? module.exports = factory() :
0;
}(this, (function () { 'use strict';
function objectOrFunction(x) {
var type = typeof x;
return x !== null && (type === 'object' || type === 'function');
}
function isFunction(x) {
return typeof x === 'function';
}
var _isArray = void 0;
if (Array.isArray) {
_isArray = Array.isArray;
} else {
_isArray = function (x) {
return Object.prototype.toString.call(x) === '[object Array]';
};
}
var isArray = _isArray;
var len = 0;
var vertxNext = void 0;
var customSchedulerFn = void 0;
var asap = function asap(callback, arg) {
queue[len] = callback;
queue[len + 1] = arg;
len += 2;
if (len === 2) {
// If len is 2, that means that we need to schedule an async flush.
// If additional callbacks are queued before the queue is flushed, they
// will be processed by this flush that we are scheduling.
if (customSchedulerFn) {
customSchedulerFn(flush);
} else {
scheduleFlush();
}
}
};
function setScheduler(scheduleFn) {
customSchedulerFn = scheduleFn;
}
function setAsap(asapFn) {
asap = asapFn;
}
var browserWindow = typeof window !== 'undefined' ? window : undefined;
var browserGlobal = browserWindow || {};
var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
// test for web worker but not in IE10
var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
// node
function useNextTick() {
// node version 0.10.x displays a deprecation warning when nextTick is used recursively
// see https://github.com/cujojs/when/issues/410 for details
return function () {
return process.nextTick(flush);
};
}
// vertx
function useVertxTimer() {
if (typeof vertxNext !== 'undefined') {
return function () {
vertxNext(flush);
};
}
return useSetTimeout();
}
function useMutationObserver() {
var iterations = 0;
var observer = new BrowserMutationObserver(flush);
var node = document.createTextNode('');
observer.observe(node, { characterData: true });
return function () {
node.data = iterations = ++iterations % 2;
};
}
// web worker
function useMessageChannel() {
var channel = new MessageChannel();
channel.port1.onmessage = flush;
return function () {
return channel.port2.postMessage(0);
};
}
function useSetTimeout() {
// Store setTimeout reference so es6-promise will be unaffected by
// other code modifying setTimeout (like sinon.useFakeTimers())
var globalSetTimeout = setTimeout;
return function () {
return globalSetTimeout(flush, 1);
};
}
var queue = new Array(1000);
function flush() {
for (var i = 0; i < len; i += 2) {
var callback = queue[i];
var arg = queue[i + 1];
callback(arg);
queue[i] = undefined;
queue[i + 1] = undefined;
}
len = 0;
}
function attemptVertx() {
try {
var vertx = Function('return this')().require('vertx');
vertxNext = vertx.runOnLoop || vertx.runOnContext;
return useVertxTimer();
} catch (e) {
return useSetTimeout();
}
}
var scheduleFlush = void 0;
// Decide what async method to use to triggering processing of queued callbacks:
if (isNode) {
scheduleFlush = useNextTick();
} else if (BrowserMutationObserver) {
scheduleFlush = useMutationObserver();
} else if (isWorker) {
scheduleFlush = useMessageChannel();
} else if (browserWindow === undefined && "function" === 'function') {
scheduleFlush = attemptVertx();
} else {
scheduleFlush = useSetTimeout();
}
function then(onFulfillment, onRejection) {
var parent = this;
var child = new this.constructor(noop);
if (child[PROMISE_ID] === undefined) {
makePromise(child);
}
var _state = parent._state;
if (_state) {
var callback = arguments[_state - 1];
asap(function () {
return invokeCallback(_state, child, callback, parent._result);
});
} else {
subscribe(parent, child, onFulfillment, onRejection);
}
return child;
}
/**
`Promise.resolve` returns a promise that will become resolved with the
passed `value`. It is shorthand for the following:
```javascript
let promise = new Promise(function(resolve, reject){
resolve(1);
});
promise.then(function(value){
// value === 1
});
```
Instead of writing the above, your code now simply becomes the following:
```javascript
let promise = Promise.resolve(1);
promise.then(function(value){
// value === 1
});
```
@method resolve
@static
@param {Any} value value that the returned promise will be resolved with
Useful for tooling.
@return {Promise} a promise that will become fulfilled with the given
`value`
*/
function resolve$1(object) {
/*jshint validthis:true */
var Constructor = this;
if (object && typeof object === 'object' && object.constructor === Constructor) {
return object;
}
var promise = new Constructor(noop);
resolve(promise, object);
return promise;
}
var PROMISE_ID = Math.random().toString(36).substring(2);
function noop() {}
var PENDING = void 0;
var FULFILLED = 1;
var REJECTED = 2;
function selfFulfillment() {
return new TypeError("You cannot resolve a promise with itself");
}
function cannotReturnOwn() {
return new TypeError('A promises callback cannot return that same promise.');
}
function tryThen(then$$1, value, fulfillmentHandler, rejectionHandler) {
try {
then$$1.call(value, fulfillmentHandler, rejectionHandler);
} catch (e) {
return e;
}
}
function handleForeignThenable(promise, thenable, then$$1) {
asap(function (promise) {
var sealed = false;
var error = tryThen(then$$1, thenable, function (value) {
if (sealed) {
return;
}
sealed = true;
if (thenable !== value) {
resolve(promise, value);
} else {
fulfill(promise, value);
}
}, function (reason) {
if (sealed) {
return;
}
sealed = true;
reject(promise, reason);
}, 'Settle: ' + (promise._label || ' unknown promise'));
if (!sealed && error) {
sealed = true;
reject(promise, error);
}
}, promise);
}
function handleOwnThenable(promise, thenable) {
if (thenable._state === FULFILLED) {
fulfill(promise, thenable._result);
} else if (thenable._state === REJECTED) {
reject(promise, thenable._result);
} else {
subscribe(thenable, undefined, function (value) {
return resolve(promise, value);
}, function (reason) {
return reject(promise, reason);
});
}
}
function handleMaybeThenable(promise, maybeThenable, then$$1) {
if (maybeThenable.constructor === promise.constructor && then$$1 === then && maybeThenable.constructor.resolve === resolve$1) {
handleOwnThenable(promise, maybeThenable);
} else {
if (then$$1 === undefined) {
fulfill(promise, maybeThenable);
} else if (isFunction(then$$1)) {
handleForeignThenable(promise, maybeThenable, then$$1);
} else {
fulfill(promise, maybeThenable);
}
}
}
function resolve(promise, value) {
if (promise === value) {
reject(promise, selfFulfillment());
} else if (objectOrFunction(value)) {
var then$$1 = void 0;
try {
then$$1 = value.then;
} catch (error) {
reject(promise, error);
return;
}
handleMaybeThenable(promise, value, then$$1);
} else {
fulfill(promise, value);
}
}
function publishRejection(promise) {
if (promise._onerror) {
promise._onerror(promise._result);
}
publish(promise);
}
function fulfill(promise, value) {
if (promise._state !== PENDING) {
return;
}
promise._result = value;
promise._state = FULFILLED;
if (promise._subscribers.length !== 0) {
asap(publish, promise);
}
}
function reject(promise, reason) {
if (promise._state !== PENDING) {
return;
}
promise._state = REJECTED;
promise._result = reason;
asap(publishRejection, promise);
}
function subscribe(parent, child, onFulfillment, onRejection) {
var _subscribers = parent._subscribers;
var length = _subscribers.length;
parent._onerror = null;
_subscribers[length] = child;
_subscribers[length + FULFILLED] = onFulfillment;
_subscribers[length + REJECTED] = onRejection;
if (length === 0 && parent._state) {
asap(publish, parent);
}
}
function publish(promise) {
var subscribers = promise._subscribers;
var settled = promise._state;
if (subscribers.length === 0) {
return;
}
var child = void 0,
callback = void 0,
detail = promise._result;
for (var i = 0; i < subscribers.length; i += 3) {
child = subscribers[i];
callback = subscribers[i + settled];
if (child) {
invokeCallback(settled, child, callback, detail);
} else {
callback(detail);
}
}
promise._subscribers.length = 0;
}
function invokeCallback(settled, promise, callback, detail) {
var hasCallback = isFunction(callback),
value = void 0,
error = void 0,
succeeded = true;
if (hasCallback) {
try {
value = callback(detail);
} catch (e) {
succeeded = false;
error = e;
}
if (promise === value) {
reject(promise, cannotReturnOwn());
return;
}
} else {
value = detail;
}
if (promise._state !== PENDING) {
// noop
} else if (hasCallback && succeeded) {
resolve(promise, value);
} else if (succeeded === false) {
reject(promise, error);
} else if (settled === FULFILLED) {
fulfill(promise, value);
} else if (settled === REJECTED) {
reject(promise, value);
}
}
function initializePromise(promise, resolver) {
try {
resolver(function resolvePromise(value) {
resolve(promise, value);
}, function rejectPromise(reason) {
reject(promise, reason);
});
} catch (e) {
reject(promise, e);
}
}
var id = 0;
function nextId() {
return id++;
}
function makePromise(promise) {
promise[PROMISE_ID] = id++;
promise._state = undefined;
promise._result = undefined;
promise._subscribers = [];
}
function validationError() {
return new Error('Array Methods must be provided an Array');
}
var Enumerator = function () {
function Enumerator(Constructor, input) {
this._instanceConstructor = Constructor;
this.promise = new Constructor(noop);
if (!this.promise[PROMISE_ID]) {
makePromise(this.promise);
}
if (isArray(input)) {
this.length = input.length;
this._remaining = input.length;
this._result = new Array(this.length);
if (this.length === 0) {
fulfill(this.promise, this._result);
} else {
this.length = this.length || 0;
this._enumerate(input);
if (this._remaining === 0) {
fulfill(this.promise, this._result);
}
}
} else {
reject(this.promise, validationError());
}
}
Enumerator.prototype._enumerate = function _enumerate(input) {
for (var i = 0; this._state === PENDING && i < input.length; i++) {
this._eachEntry(input[i], i);
}
};
Enumerator.prototype._eachEntry = function _eachEntry(entry, i) {
var c = this._instanceConstructor;
var resolve$$1 = c.resolve;
if (resolve$$1 === resolve$1) {
var _then = void 0;
var error = void 0;
var didError = false;
try {
_then = entry.then;
} catch (e) {
didError = true;
error = e;
}
if (_then === then && entry._state !== PENDING) {
this._settledAt(entry._state, i, entry._result);
} else if (typeof _then !== 'function') {
this._remaining--;
this._result[i] = entry;
} else if (c === Promise$1) {
var promise = new c(noop);
if (didError) {
reject(promise, error);
} else {
handleMaybeThenable(promise, entry, _then);
}
this._willSettleAt(promise, i);
} else {
this._willSettleAt(new c(function (resolve$$1) {
return resolve$$1(entry);
}), i);
}
} else {
this._willSettleAt(resolve$$1(entry), i);
}
};
Enumerator.prototype._settledAt = function _settledAt(state, i, value) {
var promise = this.promise;
if (promise._state === PENDING) {
this._remaining--;
if (state === REJECTED) {
reject(promise, value);
} else {
this._result[i] = value;
}
}
if (this._remaining === 0) {
fulfill(promise, this._result);
}
};
Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i) {
var enumerator = this;
subscribe(promise, undefined, function (value) {
return enumerator._settledAt(FULFILLED, i, value);
}, function (reason) {
return enumerator._settledAt(REJECTED, i, reason);
});
};
return Enumerator;
}();
/**
`Promise.all` accepts an array of promises, and returns a new promise which
is fulfilled with an array of fulfillment values for the passed promises, or
rejected with the reason of the first passed promise to be rejected. It casts all
elements of the passed iterable to promises as it runs this algorithm.
Example:
```javascript
let promise1 = resolve(1);
let promise2 = resolve(2);
let promise3 = resolve(3);
let promises = [ promise1, promise2, promise3 ];
Promise.all(promises).then(function(array){
// The array here would be [ 1, 2, 3 ];
});
```
If any of the `promises` given to `all` are rejected, the first promise
that is rejected will be given as an argument to the returned promises's
rejection handler. For example:
Example:
```javascript
let promise1 = resolve(1);
let promise2 = reject(new Error("2"));
let promise3 = reject(new Error("3"));
let promises = [ promise1, promise2, promise3 ];
Promise.all(promises).then(function(array){
// Code here never runs because there are rejected promises!
}, function(error) {
// error.message === "2"
});
```
@method all
@static
@param {Array} entries array of promises
@param {String} label optional string for labeling the promise.
Useful for tooling.
@return {Promise} promise that is fulfilled when all `promises` have been
fulfilled, or rejected if any of them become rejected.
@static
*/
function all(entries) {
return new Enumerator(this, entries).promise;
}
/**
`Promise.race` returns a new promise which is settled in the same way as the
first passed promise to settle.
Example:
```javascript
let promise1 = new Promise(function(resolve, reject){
setTimeout(function(){
resolve('promise 1');
}, 200);
});
let promise2 = new Promise(function(resolve, reject){
setTimeout(function(){
resolve('promise 2');
}, 100);
});
Promise.race([promise1, promise2]).then(function(result){
// result === 'promise 2' because it was resolved before promise1
// was resolved.
});
```
`Promise.race` is deterministic in that only the state of the first
settled promise matters. For example, even if other promises given to the
`promises` array argument are resolved, but the first settled promise has
become rejected before the other promises became fulfilled, the returned
promise will become rejected:
```javascript
let promise1 = new Promise(function(resolve, reject){
setTimeout(function(){
resolve('promise 1');
}, 200);
});
let promise2 = new Promise(function(resolve, reject){
setTimeout(function(){
reject(new Error('promise 2'));
}, 100);
});
Promise.race([promise1, promise2]).then(function(result){
// Code here never runs
}, function(reason){
// reason.message === 'promise 2' because promise 2 became rejected before
// promise 1 became fulfilled
});
```
An example real-world use case is implementing timeouts:
```javascript
Promise.race([ajax('foo.json'), timeout(5000)])
```
@method race
@static
@param {Array} promises array of promises to observe
Useful for tooling.
@return {Promise} a promise which settles in the same way as the first passed
promise to settle.
*/
function race(entries) {
/*jshint validthis:true */
var Constructor = this;
if (!isArray(entries)) {
return new Constructor(function (_, reject) {
return reject(new TypeError('You must pass an array to race.'));
});
} else {
return new Constructor(function (resolve, reject) {
var length = entries.length;
for (var i = 0; i < length; i++) {
Constructor.resolve(entries[i]).then(resolve, reject);
}
});
}
}
/**
`Promise.reject` returns a promise rejected with the passed `reason`.
It is shorthand for the following:
```javascript
let promise = new Promise(function(resolve, reject){
reject(new Error('WHOOPS'));
});
promise.then(function(value){
// Code here doesn't run because the promise is rejected!
}, function(reason){
// reason.message === 'WHOOPS'
});
```
Instead of writing the above, your code now simply becomes the following:
```javascript
let promise = Promise.reject(new Error('WHOOPS'));
promise.then(function(value){
// Code here doesn't run because the promise is rejected!
}, function(reason){
// reason.message === 'WHOOPS'
});
```
@method reject
@static
@param {Any} reason value that the returned promise will be rejected with.
Useful for tooling.
@return {Promise} a promise rejected with the given `reason`.
*/
function reject$1(reason) {
/*jshint validthis:true */
var Constructor = this;
var promise = new Constructor(noop);
reject(promise, reason);
return promise;
}
function needsResolver() {
throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
}
function needsNew() {
throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
}
/**
Promise objects represent the eventual result of an asynchronous operation. The
primary way of interacting with a promise is through its `then` method, which
registers callbacks to receive either a promise's eventual value or the reason
why the promise cannot be fulfilled.
Terminology
-----------
- `promise` is an object or function with a `then` method whose behavior conforms to this specification.
- `thenable` is an object or function that defines a `then` method.
- `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
- `exception` is a value that is thrown using the throw statement.
- `reason` is a value that indicates why a promise was rejected.
- `settled` the final resting state of a promise, fulfilled or rejected.
A promise can be in one of three states: pending, fulfilled, or rejected.
Promises that are fulfilled have a fulfillment value and are in the fulfilled
state. Promises that are rejected have a rejection reason and are in the
rejected state. A fulfillment value is never a thenable.
Promises can also be said to *resolve* a value. If this value is also a
promise, then the original promise's settled state will match the value's
settled state. So a promise that *resolves* a promise that rejects will
itself reject, and a promise that *resolves* a promise that fulfills will
itself fulfill.
Basic Usage:
------------
```js
let promise = new Promise(function(resolve, reject) {
// on success
resolve(value);
// on failure
reject(reason);
});
promise.then(function(value) {
// on fulfillment
}, function(reason) {
// on rejection
});
```
Advanced Usage:
---------------
Promises shine when abstracting away asynchronous interactions such as
`XMLHttpRequest`s.
```js
function getJSON(url) {
return new Promise(function(resolve, reject){
let xhr = new XMLHttpRequest();
xhr.open('GET', url);
xhr.onreadystatechange = handler;
xhr.responseType = 'json';
xhr.setRequestHeader('Accept', 'application/json');
xhr.send();
function handler() {
if (this.readyState === this.DONE) {
if (this.status === 200) {
resolve(this.response);
} else {
reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
}
}
};
});
}
getJSON('/posts.json').then(function(json) {
// on fulfillment
}, function(reason) {
// on rejection
});
```
Unlike callbacks, promises are great composable primitives.
```js
Promise.all([
getJSON('/posts'),
getJSON('/comments')
]).then(function(values){
values[0] // => postsJSON
values[1] // => commentsJSON
return values;
});
```
@class Promise
@param {Function} resolver
Useful for tooling.
@constructor
*/
var Promise$1 = function () {
function Promise(resolver) {
this[PROMISE_ID] = nextId();
this._result = this._state = undefined;
this._subscribers = [];
if (noop !== resolver) {
typeof resolver !== 'function' && needsResolver();
this instanceof Promise ? initializePromise(this, resolver) : needsNew();
}
}
/**
The primary way of interacting with a promise is through its `then` method,
which registers callbacks to receive either a promise's eventual value or the
reason why the promise cannot be fulfilled.
```js
findUser().then(function(user){
// user is available
}, function(reason){
// user is unavailable, and you are given the reason why
});
```
Chaining
--------
The return value of `then` is itself a promise. This second, 'downstream'
promise is resolved with the return value of the first promise's fulfillment
or rejection handler, or rejected if the handler throws an exception.
```js
findUser().then(function (user) {
return user.name;
}, function (reason) {
return 'default name';
}).then(function (userName) {
// If `findUser` fulfilled, `userName` will be the user's name, otherwise it
// will be `'default name'`
});
findUser().then(function (user) {
throw new Error('Found user, but still unhappy');
}, function (reason) {
throw new Error('`findUser` rejected and we're unhappy');
}).then(function (value) {
// never reached
}, function (reason) {
// if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
// If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
});
```
If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
```js
findUser().then(function (user) {
throw new PedagogicalException('Upstream error');
}).then(function (value) {
// never reached
}).then(function (value) {
// never reached
}, function (reason) {
// The `PedgagocialException` is propagated all the way down to here
});
```
Assimilation
------------
Sometimes the value you want to propagate to a downstream promise can only be
retrieved asynchronously. This can be achieved by returning a promise in the
fulfillment or rejection handler. The downstream promise will then be pending
until the returned promise is settled. This is called *assimilation*.
```js
findUser().then(function (user) {
return findCommentsByAuthor(user);
}).then(function (comments) {
// The user's comments are now available
});
```
If the assimliated promise rejects, then the downstream promise will also reject.
```js
findUser().then(function (user) {
return findCommentsByAuthor(user);
}).then(function (comments) {
// If `findCommentsByAuthor` fulfills, we'll have the value here
}, function (reason) {
// If `findCommentsByAuthor` rejects, we'll have the reason here
});
```
Simple Example
--------------
Synchronous Example
```javascript
let result;
try {
result = findResult();
// success
} catch(reason) {
// failure
}
```
Errback Example
```js
findResult(function(result, err){
if (err) {
// failure
} else {
// success
}
});
```
Promise Example;
```javascript
findResult().then(function(result){
// success
}, function(reason){
// failure
});
```
Advanced Example
--------------
Synchronous Example
```javascript
let author, books;
try {
author = findAuthor();
books = findBooksByAuthor(author);
// success
} catch(reason) {
// failure
}
```
Errback Example
```js
function foundBooks(books) {
}
function failure(reason) {
}
findAuthor(function(author, err){
if (err) {
failure(err);
// failure
} else {
try {
findBoooksByAuthor(author, function(books, err) {
if (err) {
failure(err);
} else {
try {
foundBooks(books);
} catch(reason) {
failure(reason);
}
}
});
} catch(error) {
failure(err);
}
// success
}
});
```
Promise Example;
```javascript
findAuthor().
then(findBooksByAuthor).
then(function(books){
// found books
}).catch(function(reason){
// something went wrong
});
```
@method then
@param {Function} onFulfilled
@param {Function} onRejected
Useful for tooling.
@return {Promise}
*/
/**
`catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
as the catch block of a try/catch statement.
```js
function findAuthor(){
throw new Error('couldn't find that author');
}
// synchronous
try {
findAuthor();
} catch(reason) {
// something went wrong
}
// async with promises
findAuthor().catch(function(reason){
// something went wrong
});
```
@method catch
@param {Function} onRejection
Useful for tooling.
@return {Promise}
*/
Promise.prototype.catch = function _catch(onRejection) {
return this.then(null, onRejection);
};
/**
`finally` will be invoked regardless of the promise's fate just as native
try/catch/finally behaves
Synchronous example:
```js
findAuthor() {
if (Math.random() > 0.5) {
throw new Error();
}
return new Author();
}
try {
return findAuthor(); // succeed or fail
} catch(error) {
return findOtherAuther();
} finally {
// always runs
// doesn't affect the return value
}
```
Asynchronous example:
```js
findAuthor().catch(function(reason){
return findOtherAuther();
}).finally(function(){
// author was either found, or not
});
```
@method finally
@param {Function} callback
@return {Promise}
*/
Promise.prototype.finally = function _finally(callback) {
var promise = this;
var constructor = promise.constructor;
if (isFunction(callback)) {
return promise.then(function (value) {
return constructor.resolve(callback()).then(function () {
return value;
});
}, function (reason) {
return constructor.resolve(callback()).then(function () {
throw reason;
});
});
}
return promise.then(callback, callback);
};
return Promise;
}();
Promise$1.prototype.then = then;
Promise$1.all = all;
Promise$1.race = race;
Promise$1.resolve = resolve$1;
Promise$1.reject = reject$1;
Promise$1._setScheduler = setScheduler;
Promise$1._setAsap = setAsap;
Promise$1._asap = asap;
/*global self*/
function polyfill() {
var local = void 0;
if (typeof __webpack_require__.g !== 'undefined') {
local = __webpack_require__.g;
} else if (typeof self !== 'undefined') {
local = self;
} else {
try {
local = Function('return this')();
} catch (e) {
throw new Error('polyfill failed because global object is unavailable in this environment');
}
}
var P = local.Promise;
if (P) {
var promiseToString = null;
try {
promiseToString = Object.prototype.toString.call(P.resolve());
} catch (e) {
// silently ignored
}
if (promiseToString === '[object Promise]' && !P.cast) {
return;
}
}
local.Promise = Promise$1;
}
// Strange compat..
Promise$1.polyfill = polyfill;
Promise$1.Promise = Promise$1;
return Promise$1;
})));
//# sourceMappingURL=es6-promise.map
/***/ }),
/***/ 86204:
/*!*****************************************************!*\
!*** ./node_modules/_events@3.3.0@events/events.js ***!
\*****************************************************/
/***/ (function(module) {
"use strict";
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
var R = typeof Reflect === 'object' ? Reflect : null
var ReflectApply = R && typeof R.apply === 'function'
? R.apply
: function ReflectApply(target, receiver, args) {
return Function.prototype.apply.call(target, receiver, args);
}
var ReflectOwnKeys
if (R && typeof R.ownKeys === 'function') {
ReflectOwnKeys = R.ownKeys
} else if (Object.getOwnPropertySymbols) {
ReflectOwnKeys = function ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target)
.concat(Object.getOwnPropertySymbols(target));
};
} else {
ReflectOwnKeys = function ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target);
};
}
function ProcessEmitWarning(warning) {
if (console && console.warn) console.warn(warning);
}
var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
return value !== value;
}
function EventEmitter() {
EventEmitter.init.call(this);
}
module.exports = EventEmitter;
module.exports.once = once;
// Backwards-compat with node 0.10.x
EventEmitter.EventEmitter = EventEmitter;
EventEmitter.prototype._events = undefined;
EventEmitter.prototype._eventsCount = 0;
EventEmitter.prototype._maxListeners = undefined;
// By default EventEmitters will print a warning if more than 10 listeners are
// added to it. This is a useful default which helps finding memory leaks.
var defaultMaxListeners = 10;
function checkListener(listener) {
if (typeof listener !== 'function') {
throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
}
}
Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
enumerable: true,
get: function() {
return defaultMaxListeners;
},
set: function(arg) {
if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
}
defaultMaxListeners = arg;
}
});
EventEmitter.init = function() {
if (this._events === undefined ||
this._events === Object.getPrototypeOf(this)._events) {
this._events = Object.create(null);
this._eventsCount = 0;
}
this._maxListeners = this._maxListeners || undefined;
};
// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
}
this._maxListeners = n;
return this;
};
function _getMaxListeners(that) {
if (that._maxListeners === undefined)
return EventEmitter.defaultMaxListeners;
return that._maxListeners;
}
EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
return _getMaxListeners(this);
};
EventEmitter.prototype.emit = function emit(type) {
var args = [];
for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
var doError = (type === 'error');
var events = this._events;
if (events !== undefined)
doError = (doError && events.error === undefined);
else if (!doError)
return false;
// If there is no 'error' event listener then throw.
if (doError) {
var er;
if (args.length > 0)
er = args[0];
if (er instanceof Error) {
// Note: The comments on the `throw` lines are intentional, they show
// up in Node's output if this results in an unhandled exception.
throw er; // Unhandled 'error' event
}
// At least give some kind of context to the user
var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
err.context = er;
throw err; // Unhandled 'error' event
}
var handler = events[type];
if (handler === undefined)
return false;
if (typeof handler === 'function') {
ReflectApply(handler, this, args);
} else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
ReflectApply(listeners[i], this, args);
}
return true;
};
function _addListener(target, type, listener, prepend) {
var m;
var events;
var existing;
checkListener(listener);
events = target._events;
if (events === undefined) {
events = target._events = Object.create(null);
target._eventsCount = 0;
} else {
// To avoid recursion in the case that type === "newListener"! Before
// adding it to the listeners, first emit "newListener".
if (events.newListener !== undefined) {
target.emit('newListener', type,
listener.listener ? listener.listener : listener);
// Re-assign `events` because a newListener handler could have caused the
// this._events to be assigned to a new object
events = target._events;
}
existing = events[type];
}
if (existing === undefined) {
// Optimize the case of one listener. Don't need the extra array object.
existing = events[type] = listener;
++target._eventsCount;
} else {
if (typeof existing === 'function') {
// Adding the second element, need to change to array.
existing = events[type] =
prepend ? [listener, existing] : [existing, listener];
// If we've already got an array, just append.
} else if (prepend) {
existing.unshift(listener);
} else {
existing.push(listener);
}
// Check for listener leak
m = _getMaxListeners(target);
if (m > 0 && existing.length > m && !existing.warned) {
existing.warned = true;
// No error code for this since it is a Warning
// eslint-disable-next-line no-restricted-syntax
var w = new Error('Possible EventEmitter memory leak detected. ' +
existing.length + ' ' + String(type) + ' listeners ' +
'added. Use emitter.setMaxListeners() to ' +
'increase limit');
w.name = 'MaxListenersExceededWarning';
w.emitter = target;
w.type = type;
w.count = existing.length;
ProcessEmitWarning(w);
}
}
return target;
}
EventEmitter.prototype.addListener = function addListener(type, listener) {
return _addListener(this, type, listener, false);
};
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
EventEmitter.prototype.prependListener =
function prependListener(type, listener) {
return _addListener(this, type, listener, true);
};
function onceWrapper() {
if (!this.fired) {
this.target.removeListener(this.type, this.wrapFn);
this.fired = true;
if (arguments.length === 0)
return this.listener.call(this.target);
return this.listener.apply(this.target, arguments);
}
}
function _onceWrap(target, type, listener) {
var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
var wrapped = onceWrapper.bind(state);
wrapped.listener = listener;
state.wrapFn = wrapped;
return wrapped;
}
EventEmitter.prototype.once = function once(type, listener) {
checkListener(listener);
this.on(type, _onceWrap(this, type, listener));
return this;
};
EventEmitter.prototype.prependOnceListener =
function prependOnceListener(type, listener) {
checkListener(listener);
this.prependListener(type, _onceWrap(this, type, listener));
return this;
};
// Emits a 'removeListener' event if and only if the listener was removed.
EventEmitter.prototype.removeListener =
function removeListener(type, listener) {
var list, events, position, i, originalListener;
checkListener(listener);
events = this._events;
if (events === undefined)
return this;
list = events[type];
if (list === undefined)
return this;
if (list === listener || list.listener === listener) {
if (--this._eventsCount === 0)
this._events = Object.create(null);
else {
delete events[type];
if (events.removeListener)
this.emit('removeListener', type, list.listener || listener);
}
} else if (typeof list !== 'function') {
position = -1;
for (i = list.length - 1; i >= 0; i--) {
if (list[i] === listener || list[i].listener === listener) {
originalListener = list[i].listener;
position = i;
break;
}
}
if (position < 0)
return this;
if (position === 0)
list.shift();
else {
spliceOne(list, position);
}
if (list.length === 1)
events[type] = list[0];
if (events.removeListener !== undefined)
this.emit('removeListener', type, originalListener || listener);
}
return this;
};
EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
EventEmitter.prototype.removeAllListeners =
function removeAllListeners(type) {
var listeners, events, i;
events = this._events;
if (events === undefined)
return this;
// not listening for removeListener, no need to emit
if (events.removeListener === undefined) {
if (arguments.length === 0) {
this._events = Object.create(null);
this._eventsCount = 0;
} else if (events[type] !== undefined) {
if (--this._eventsCount === 0)
this._events = Object.create(null);
else
delete events[type];
}
return this;
}
// emit removeListener for all listeners on all events
if (arguments.length === 0) {
var keys = Object.keys(events);
var key;
for (i = 0; i < keys.length; ++i) {
key = keys[i];
if (key === 'removeListener') continue;
this.removeAllListeners(key);
}
this.removeAllListeners('removeListener');
this._events = Object.create(null);
this._eventsCount = 0;
return this;
}
listeners = events[type];
if (typeof listeners === 'function') {
this.removeListener(type, listeners);
} else if (listeners !== undefined) {
// LIFO order
for (i = listeners.length - 1; i >= 0; i--) {
this.removeListener(type, listeners[i]);
}
}
return this;
};
function _listeners(target, type, unwrap) {
var events = target._events;
if (events === undefined)
return [];
var evlistener = events[type];
if (evlistener === undefined)
return [];
if (typeof evlistener === 'function')
return unwrap ? [evlistener.listener || evlistener] : [evlistener];
return unwrap ?
unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
}
EventEmitter.prototype.listeners = function listeners(type) {
return _listeners(this, type, true);
};
EventEmitter.prototype.rawListeners = function rawListeners(type) {
return _listeners(this, type, false);
};
EventEmitter.listenerCount = function(emitter, type) {
if (typeof emitter.listenerCount === 'function') {
return emitter.listenerCount(type);
} else {
return listenerCount.call(emitter, type);
}
};
EventEmitter.prototype.listenerCount = listenerCount;
function listenerCount(type) {
var events = this._events;
if (events !== undefined) {
var evlistener = events[type];
if (typeof evlistener === 'function') {
return 1;
} else if (evlistener !== undefined) {
return evlistener.length;
}
}
return 0;
}
EventEmitter.prototype.eventNames = function eventNames() {
return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
};
function arrayClone(arr, n) {
var copy = new Array(n);
for (var i = 0; i < n; ++i)
copy[i] = arr[i];
return copy;
}
function spliceOne(list, index) {
for (; index + 1 < list.length; index++)
list[index] = list[index + 1];
list.pop();
}
function unwrapListeners(arr) {
var ret = new Array(arr.length);
for (var i = 0; i < ret.length; ++i) {
ret[i] = arr[i].listener || arr[i];
}
return ret;
}
function once(emitter, name) {
return new Promise(function (resolve, reject) {
function errorListener(err) {
emitter.removeListener(name, resolver);
reject(err);
}
function resolver() {
if (typeof emitter.removeListener === 'function') {
emitter.removeListener('error', errorListener);
}
resolve([].slice.call(arguments));
};
eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
if (name !== 'error') {
addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
}
});
}
function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
if (typeof emitter.on === 'function') {
eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
}
}
function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
if (typeof emitter.on === 'function') {
if (flags.once) {
emitter.once(name, listener);
} else {
emitter.on(name, listener);
}
} else if (typeof emitter.addEventListener === 'function') {
// EventTarget does not have `error` event semantics like Node
// EventEmitters, we do not listen for `error` events here.
emitter.addEventListener(name, function wrapListener(arg) {
// IE does not have builtin `{ once: true }` support so we
// have to do it manually.
if (flags.once) {
emitter.removeEventListener(name, wrapListener);
}
listener(arg);
});
} else {
throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
}
}
/***/ }),
/***/ 82059:
/*!************************************************************!*\
!*** ./node_modules/_webworkify@1.5.0@webworkify/index.js ***!
\************************************************************/
/***/ (function(module) {
var bundleFn = arguments[3];
var sources = arguments[4];
var cache = arguments[5];
var stringify = JSON.stringify;
module.exports = function (fn, options) {
var wkey;
var cacheKeys = Object.keys(cache);
for (var i = 0, l = cacheKeys.length; i < l; i++) {
var key = cacheKeys[i];
var exp = cache[key].exports;
// Using babel as a transpiler to use esmodule, the export will always
// be an object with the default export as a property of it. To ensure
// the existing api and babel esmodule exports are both supported we
// check for both
if (exp === fn || exp && exp.default === fn) {
wkey = key;
break;
}
}
if (!wkey) {
wkey = Math.floor(Math.pow(16, 8) * Math.random()).toString(16);
var wcache = {};
for (var i = 0, l = cacheKeys.length; i < l; i++) {
var key = cacheKeys[i];
wcache[key] = key;
}
sources[wkey] = [
'function(require,module,exports){' + fn + '(self); }',
wcache
];
}
var skey = Math.floor(Math.pow(16, 8) * Math.random()).toString(16);
var scache = {}; scache[wkey] = wkey;
sources[skey] = [
'function(require,module,exports){' +
// try to call default if defined to also support babel esmodule exports
'var f = require(' + stringify(wkey) + ');' +
'(f.default ? f.default : f)(self);' +
'}',
scache
];
var workerSources = {};
resolveSources(skey);
function resolveSources(key) {
workerSources[key] = true;
for (var depPath in sources[key][1]) {
var depKey = sources[key][1][depPath];
if (!workerSources[depKey]) {
resolveSources(depKey);
}
}
}
var src = '(' + bundleFn + ')({'
+ Object.keys(workerSources).map(function (key) {
return stringify(key) + ':['
+ sources[key][0]
+ ',' + stringify(sources[key][1]) + ']'
;
}).join(',')
+ '},{},[' + stringify(skey) + '])'
;
var URL = window.URL || window.webkitURL || window.mozURL || window.msURL;
var blob = new Blob([src], { type: 'text/javascript' });
if (options && options.bare) { return blob; }
var workerUrl = URL.createObjectURL(blob);
var worker = new Worker(workerUrl);
worker.objectURL = workerUrl;
return worker;
};
/***/ }),
/***/ 4811:
/*!***************************************************************************!*\
!*** ./node_modules/_@babel_runtime@7.23.6@@babel/runtime/helpers/get.js ***!
\***************************************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var superPropBase = __webpack_require__(/*! ./superPropBase.js */ 22652);
function _get() {
if (typeof Reflect !== "undefined" && Reflect.get) {
module.exports = _get = Reflect.get.bind(), module.exports.__esModule = true, module.exports["default"] = module.exports;
} else {
module.exports = _get = function _get(target, property, receiver) {
var base = superPropBase(target, property);
if (!base) return;
var desc = Object.getOwnPropertyDescriptor(base, property);
if (desc.get) {
return desc.get.call(arguments.length < 3 ? target : receiver);
}
return desc.value;
}, module.exports.__esModule = true, module.exports["default"] = module.exports;
}
return _get.apply(this, arguments);
}
module.exports = _get, module.exports.__esModule = true, module.exports["default"] = module.exports;
/***/ }),
/***/ 22652:
/*!*************************************************************************************!*\
!*** ./node_modules/_@babel_runtime@7.23.6@@babel/runtime/helpers/superPropBase.js ***!
\*************************************************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var getPrototypeOf = __webpack_require__(/*! ./getPrototypeOf.js */ 34577);
function _superPropBase(object, property) {
while (!Object.prototype.hasOwnProperty.call(object, property)) {
object = getPrototypeOf(object);
if (object === null) break;
}
return object;
}
module.exports = _superPropBase, module.exports.__esModule = true, module.exports["default"] = module.exports;
/***/ })
}]);
Reference in new issue View Git Blame Copy Permalink