|
|
@@ -0,0 +1,4152 @@
|
|
|
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Wfs = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
|
|
+// 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.
|
|
|
+
|
|
|
+function EventEmitter() {
|
|
|
+ this._events = this._events || {};
|
|
|
+ this._maxListeners = this._maxListeners || undefined;
|
|
|
+}
|
|
|
+module.exports = EventEmitter;
|
|
|
+
|
|
|
+// Backwards-compat with node 0.10.x
|
|
|
+EventEmitter.EventEmitter = EventEmitter;
|
|
|
+
|
|
|
+EventEmitter.prototype._events = undefined;
|
|
|
+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.
|
|
|
+EventEmitter.defaultMaxListeners = 10;
|
|
|
+
|
|
|
+// 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(n) {
|
|
|
+ if (!isNumber(n) || n < 0 || isNaN(n))
|
|
|
+ throw TypeError('n must be a positive number');
|
|
|
+ this._maxListeners = n;
|
|
|
+ return this;
|
|
|
+};
|
|
|
+
|
|
|
+EventEmitter.prototype.emit = function(type) {
|
|
|
+ var er, handler, len, args, i, listeners;
|
|
|
+
|
|
|
+ if (!this._events)
|
|
|
+ this._events = {};
|
|
|
+
|
|
|
+ // If there is no 'error' event listener then throw.
|
|
|
+ if (type === 'error') {
|
|
|
+ if (!this._events.error ||
|
|
|
+ (isObject(this._events.error) && !this._events.error.length)) {
|
|
|
+ er = arguments[1];
|
|
|
+ if (er instanceof Error) {
|
|
|
+ throw er; // Unhandled 'error' event
|
|
|
+ } else {
|
|
|
+ // At least give some kind of context to the user
|
|
|
+ var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
|
|
|
+ err.context = er;
|
|
|
+ throw err;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ handler = this._events[type];
|
|
|
+
|
|
|
+ if (isUndefined(handler))
|
|
|
+ return false;
|
|
|
+
|
|
|
+ if (isFunction(handler)) {
|
|
|
+ switch (arguments.length) {
|
|
|
+ // fast cases
|
|
|
+ case 1:
|
|
|
+ handler.call(this);
|
|
|
+ break;
|
|
|
+ case 2:
|
|
|
+ handler.call(this, arguments[1]);
|
|
|
+ break;
|
|
|
+ case 3:
|
|
|
+ handler.call(this, arguments[1], arguments[2]);
|
|
|
+ break;
|
|
|
+ // slower
|
|
|
+ default:
|
|
|
+ args = Array.prototype.slice.call(arguments, 1);
|
|
|
+ handler.apply(this, args);
|
|
|
+ }
|
|
|
+ } else if (isObject(handler)) {
|
|
|
+ args = Array.prototype.slice.call(arguments, 1);
|
|
|
+ listeners = handler.slice();
|
|
|
+ len = listeners.length;
|
|
|
+ for (i = 0; i < len; i++)
|
|
|
+ listeners[i].apply(this, args);
|
|
|
+ }
|
|
|
+
|
|
|
+ return true;
|
|
|
+};
|
|
|
+
|
|
|
+EventEmitter.prototype.addListener = function(type, listener) {
|
|
|
+ var m;
|
|
|
+
|
|
|
+ if (!isFunction(listener))
|
|
|
+ throw TypeError('listener must be a function');
|
|
|
+
|
|
|
+ if (!this._events)
|
|
|
+ this._events = {};
|
|
|
+
|
|
|
+ // To avoid recursion in the case that type === "newListener"! Before
|
|
|
+ // adding it to the listeners, first emit "newListener".
|
|
|
+ if (this._events.newListener)
|
|
|
+ this.emit('newListener', type,
|
|
|
+ isFunction(listener.listener) ?
|
|
|
+ listener.listener : listener);
|
|
|
+
|
|
|
+ if (!this._events[type])
|
|
|
+ // Optimize the case of one listener. Don't need the extra array object.
|
|
|
+ this._events[type] = listener;
|
|
|
+ else if (isObject(this._events[type]))
|
|
|
+ // If we've already got an array, just append.
|
|
|
+ this._events[type].push(listener);
|
|
|
+ else
|
|
|
+ // Adding the second element, need to change to array.
|
|
|
+ this._events[type] = [this._events[type], listener];
|
|
|
+
|
|
|
+ // Check for listener leak
|
|
|
+ if (isObject(this._events[type]) && !this._events[type].warned) {
|
|
|
+ if (!isUndefined(this._maxListeners)) {
|
|
|
+ m = this._maxListeners;
|
|
|
+ } else {
|
|
|
+ m = EventEmitter.defaultMaxListeners;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (m && m > 0 && this._events[type].length > m) {
|
|
|
+ this._events[type].warned = true;
|
|
|
+ console.error('(node) warning: possible EventEmitter memory ' +
|
|
|
+ 'leak detected. %d listeners added. ' +
|
|
|
+ 'Use emitter.setMaxListeners() to increase limit.',
|
|
|
+ this._events[type].length);
|
|
|
+ if (typeof console.trace === 'function') {
|
|
|
+ // not supported in IE 10
|
|
|
+ console.trace();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return this;
|
|
|
+};
|
|
|
+
|
|
|
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
|
|
|
+
|
|
|
+EventEmitter.prototype.once = function(type, listener) {
|
|
|
+ if (!isFunction(listener))
|
|
|
+ throw TypeError('listener must be a function');
|
|
|
+
|
|
|
+ var fired = false;
|
|
|
+
|
|
|
+ function g() {
|
|
|
+ this.removeListener(type, g);
|
|
|
+
|
|
|
+ if (!fired) {
|
|
|
+ fired = true;
|
|
|
+ listener.apply(this, arguments);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ g.listener = listener;
|
|
|
+ this.on(type, g);
|
|
|
+
|
|
|
+ return this;
|
|
|
+};
|
|
|
+
|
|
|
+// emits a 'removeListener' event iff the listener was removed
|
|
|
+EventEmitter.prototype.removeListener = function(type, listener) {
|
|
|
+ var list, position, length, i;
|
|
|
+
|
|
|
+ if (!isFunction(listener))
|
|
|
+ throw TypeError('listener must be a function');
|
|
|
+
|
|
|
+ if (!this._events || !this._events[type])
|
|
|
+ return this;
|
|
|
+
|
|
|
+ list = this._events[type];
|
|
|
+ length = list.length;
|
|
|
+ position = -1;
|
|
|
+
|
|
|
+ if (list === listener ||
|
|
|
+ (isFunction(list.listener) && list.listener === listener)) {
|
|
|
+ delete this._events[type];
|
|
|
+ if (this._events.removeListener)
|
|
|
+ this.emit('removeListener', type, listener);
|
|
|
+
|
|
|
+ } else if (isObject(list)) {
|
|
|
+ for (i = length; i-- > 0;) {
|
|
|
+ if (list[i] === listener ||
|
|
|
+ (list[i].listener && list[i].listener === listener)) {
|
|
|
+ position = i;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (position < 0)
|
|
|
+ return this;
|
|
|
+
|
|
|
+ if (list.length === 1) {
|
|
|
+ list.length = 0;
|
|
|
+ delete this._events[type];
|
|
|
+ } else {
|
|
|
+ list.splice(position, 1);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (this._events.removeListener)
|
|
|
+ this.emit('removeListener', type, listener);
|
|
|
+ }
|
|
|
+
|
|
|
+ return this;
|
|
|
+};
|
|
|
+
|
|
|
+EventEmitter.prototype.removeAllListeners = function(type) {
|
|
|
+ var key, listeners;
|
|
|
+
|
|
|
+ if (!this._events)
|
|
|
+ return this;
|
|
|
+
|
|
|
+ // not listening for removeListener, no need to emit
|
|
|
+ if (!this._events.removeListener) {
|
|
|
+ if (arguments.length === 0)
|
|
|
+ this._events = {};
|
|
|
+ else if (this._events[type])
|
|
|
+ delete this._events[type];
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ // emit removeListener for all listeners on all events
|
|
|
+ if (arguments.length === 0) {
|
|
|
+ for (key in this._events) {
|
|
|
+ if (key === 'removeListener') continue;
|
|
|
+ this.removeAllListeners(key);
|
|
|
+ }
|
|
|
+ this.removeAllListeners('removeListener');
|
|
|
+ this._events = {};
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ listeners = this._events[type];
|
|
|
+
|
|
|
+ if (isFunction(listeners)) {
|
|
|
+ this.removeListener(type, listeners);
|
|
|
+ } else if (listeners) {
|
|
|
+ // LIFO order
|
|
|
+ while (listeners.length)
|
|
|
+ this.removeListener(type, listeners[listeners.length - 1]);
|
|
|
+ }
|
|
|
+ delete this._events[type];
|
|
|
+
|
|
|
+ return this;
|
|
|
+};
|
|
|
+
|
|
|
+EventEmitter.prototype.listeners = function(type) {
|
|
|
+ var ret;
|
|
|
+ if (!this._events || !this._events[type])
|
|
|
+ ret = [];
|
|
|
+ else if (isFunction(this._events[type]))
|
|
|
+ ret = [this._events[type]];
|
|
|
+ else
|
|
|
+ ret = this._events[type].slice();
|
|
|
+ return ret;
|
|
|
+};
|
|
|
+
|
|
|
+EventEmitter.prototype.listenerCount = function(type) {
|
|
|
+ if (this._events) {
|
|
|
+ var evlistener = this._events[type];
|
|
|
+
|
|
|
+ if (isFunction(evlistener))
|
|
|
+ return 1;
|
|
|
+ else if (evlistener)
|
|
|
+ return evlistener.length;
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+};
|
|
|
+
|
|
|
+EventEmitter.listenerCount = function(emitter, type) {
|
|
|
+ return emitter.listenerCount(type);
|
|
|
+};
|
|
|
+
|
|
|
+function isFunction(arg) {
|
|
|
+ return typeof arg === 'function';
|
|
|
+}
|
|
|
+
|
|
|
+function isNumber(arg) {
|
|
|
+ return typeof arg === 'number';
|
|
|
+}
|
|
|
+
|
|
|
+function isObject(arg) {
|
|
|
+ return typeof arg === 'object' && arg !== null;
|
|
|
+}
|
|
|
+
|
|
|
+function isUndefined(arg) {
|
|
|
+ return arg === void 0;
|
|
|
+}
|
|
|
+
|
|
|
+},{}],2:[function(require,module,exports){
|
|
|
+// shim for using process in browser
|
|
|
+var process = module.exports = {};
|
|
|
+
|
|
|
+// cached from whatever global is present so that test runners that stub it
|
|
|
+// don't break things. But we need to wrap it in a try catch in case it is
|
|
|
+// wrapped in strict mode code which doesn't define any globals. It's inside a
|
|
|
+// function because try/catches deoptimize in certain engines.
|
|
|
+
|
|
|
+var cachedSetTimeout;
|
|
|
+var cachedClearTimeout;
|
|
|
+
|
|
|
+function defaultSetTimout() {
|
|
|
+ throw new Error('setTimeout has not been defined');
|
|
|
+}
|
|
|
+function defaultClearTimeout () {
|
|
|
+ throw new Error('clearTimeout has not been defined');
|
|
|
+}
|
|
|
+(function () {
|
|
|
+ try {
|
|
|
+ if (typeof setTimeout === 'function') {
|
|
|
+ cachedSetTimeout = setTimeout;
|
|
|
+ } else {
|
|
|
+ cachedSetTimeout = defaultSetTimout;
|
|
|
+ }
|
|
|
+ } catch (e) {
|
|
|
+ cachedSetTimeout = defaultSetTimout;
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ if (typeof clearTimeout === 'function') {
|
|
|
+ cachedClearTimeout = clearTimeout;
|
|
|
+ } else {
|
|
|
+ cachedClearTimeout = defaultClearTimeout;
|
|
|
+ }
|
|
|
+ } catch (e) {
|
|
|
+ cachedClearTimeout = defaultClearTimeout;
|
|
|
+ }
|
|
|
+} ())
|
|
|
+function runTimeout(fun) {
|
|
|
+ if (cachedSetTimeout === setTimeout) {
|
|
|
+ //normal enviroments in sane situations
|
|
|
+ return setTimeout(fun, 0);
|
|
|
+ }
|
|
|
+ // if setTimeout wasn't available but was latter defined
|
|
|
+ if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
|
|
|
+ cachedSetTimeout = setTimeout;
|
|
|
+ return setTimeout(fun, 0);
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ // when when somebody has screwed with setTimeout but no I.E. maddness
|
|
|
+ return cachedSetTimeout(fun, 0);
|
|
|
+ } catch(e){
|
|
|
+ try {
|
|
|
+ // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
|
|
+ return cachedSetTimeout.call(null, fun, 0);
|
|
|
+ } catch(e){
|
|
|
+ // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
|
|
|
+ return cachedSetTimeout.call(this, fun, 0);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+}
|
|
|
+function runClearTimeout(marker) {
|
|
|
+ if (cachedClearTimeout === clearTimeout) {
|
|
|
+ //normal enviroments in sane situations
|
|
|
+ return clearTimeout(marker);
|
|
|
+ }
|
|
|
+ // if clearTimeout wasn't available but was latter defined
|
|
|
+ if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
|
|
|
+ cachedClearTimeout = clearTimeout;
|
|
|
+ return clearTimeout(marker);
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ // when when somebody has screwed with setTimeout but no I.E. maddness
|
|
|
+ return cachedClearTimeout(marker);
|
|
|
+ } catch (e){
|
|
|
+ try {
|
|
|
+ // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
|
|
+ return cachedClearTimeout.call(null, marker);
|
|
|
+ } catch (e){
|
|
|
+ // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
|
|
|
+ // Some versions of I.E. have different rules for clearTimeout vs setTimeout
|
|
|
+ return cachedClearTimeout.call(this, marker);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+}
|
|
|
+var queue = [];
|
|
|
+var draining = false;
|
|
|
+var currentQueue;
|
|
|
+var queueIndex = -1;
|
|
|
+
|
|
|
+function cleanUpNextTick() {
|
|
|
+ if (!draining || !currentQueue) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ draining = false;
|
|
|
+ if (currentQueue.length) {
|
|
|
+ queue = currentQueue.concat(queue);
|
|
|
+ } else {
|
|
|
+ queueIndex = -1;
|
|
|
+ }
|
|
|
+ if (queue.length) {
|
|
|
+ drainQueue();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+function drainQueue() {
|
|
|
+ if (draining) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ var timeout = runTimeout(cleanUpNextTick);
|
|
|
+ draining = true;
|
|
|
+
|
|
|
+ var len = queue.length;
|
|
|
+ while(len) {
|
|
|
+ currentQueue = queue;
|
|
|
+ queue = [];
|
|
|
+ while (++queueIndex < len) {
|
|
|
+ if (currentQueue) {
|
|
|
+ currentQueue[queueIndex].run();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ queueIndex = -1;
|
|
|
+ len = queue.length;
|
|
|
+ }
|
|
|
+ currentQueue = null;
|
|
|
+ draining = false;
|
|
|
+ runClearTimeout(timeout);
|
|
|
+}
|
|
|
+
|
|
|
+process.nextTick = function (fun) {
|
|
|
+ var args = new Array(arguments.length - 1);
|
|
|
+ if (arguments.length > 1) {
|
|
|
+ for (var i = 1; i < arguments.length; i++) {
|
|
|
+ args[i - 1] = arguments[i];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ queue.push(new Item(fun, args));
|
|
|
+ if (queue.length === 1 && !draining) {
|
|
|
+ runTimeout(drainQueue);
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+// v8 likes predictible objects
|
|
|
+function Item(fun, array) {
|
|
|
+ this.fun = fun;
|
|
|
+ this.array = array;
|
|
|
+}
|
|
|
+Item.prototype.run = function () {
|
|
|
+ this.fun.apply(null, this.array);
|
|
|
+};
|
|
|
+process.title = 'browser';
|
|
|
+process.browser = true;
|
|
|
+process.env = {};
|
|
|
+process.argv = [];
|
|
|
+process.version = ''; // empty string to avoid regexp issues
|
|
|
+process.versions = {};
|
|
|
+
|
|
|
+function noop() {}
|
|
|
+
|
|
|
+process.on = noop;
|
|
|
+process.addListener = noop;
|
|
|
+process.once = noop;
|
|
|
+process.off = noop;
|
|
|
+process.removeListener = noop;
|
|
|
+process.removeAllListeners = noop;
|
|
|
+process.emit = noop;
|
|
|
+process.prependListener = noop;
|
|
|
+process.prependOnceListener = noop;
|
|
|
+
|
|
|
+process.listeners = function (name) { return [] }
|
|
|
+
|
|
|
+process.binding = function (name) {
|
|
|
+ throw new Error('process.binding is not supported');
|
|
|
+};
|
|
|
+
|
|
|
+process.cwd = function () { return '/' };
|
|
|
+process.chdir = function (dir) {
|
|
|
+ throw new Error('process.chdir is not supported');
|
|
|
+};
|
|
|
+process.umask = function() { return 0; };
|
|
|
+
|
|
|
+},{}],3:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+Object.defineProperty(exports, "__esModule", {
|
|
|
+ value: true
|
|
|
+});
|
|
|
+
|
|
|
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
+
|
|
|
+var _events = require('../events');
|
|
|
+
|
|
|
+var _events2 = _interopRequireDefault(_events);
|
|
|
+
|
|
|
+var _eventHandler = require('../event-handler');
|
|
|
+
|
|
|
+var _eventHandler2 = _interopRequireDefault(_eventHandler);
|
|
|
+
|
|
|
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
+
|
|
|
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
+
|
|
|
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
+
|
|
|
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /*
|
|
|
+ * Buffer Controller
|
|
|
+ */
|
|
|
+
|
|
|
+var BufferController = function (_EventHandler) {
|
|
|
+ _inherits(BufferController, _EventHandler);
|
|
|
+
|
|
|
+ function BufferController(wfs) {
|
|
|
+ _classCallCheck(this, BufferController);
|
|
|
+
|
|
|
+ var _this = _possibleConstructorReturn(this, (BufferController.__proto__ || Object.getPrototypeOf(BufferController)).call(this, wfs, _events2.default.MEDIA_ATTACHING, _events2.default.BUFFER_APPENDING, _events2.default.BUFFER_RESET));
|
|
|
+
|
|
|
+ _this.mediaSource = null;
|
|
|
+ _this.media = null;
|
|
|
+ _this.pendingTracks = {};
|
|
|
+ _this.sourceBuffer = {};
|
|
|
+ _this.segments = [];
|
|
|
+
|
|
|
+ _this.appended = 0;
|
|
|
+ _this._msDuration = null;
|
|
|
+
|
|
|
+ // Source Buffer listeners
|
|
|
+ _this.onsbue = _this.onSBUpdateEnd.bind(_this);
|
|
|
+
|
|
|
+ _this.browserType = 0;
|
|
|
+ if (navigator.userAgent.toLowerCase().indexOf('firefox') !== -1) {
|
|
|
+ _this.browserType = 1;
|
|
|
+ }
|
|
|
+ _this.mediaType = 'H264Raw';
|
|
|
+
|
|
|
+ _this.websocketName = undefined;
|
|
|
+ _this.channelName = undefined;
|
|
|
+ return _this;
|
|
|
+ }
|
|
|
+
|
|
|
+ _createClass(BufferController, [{
|
|
|
+ key: 'destroy',
|
|
|
+ value: function destroy() {
|
|
|
+ _eventHandler2.default.prototype.destroy.call(this);
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'onMediaAttaching',
|
|
|
+ value: function onMediaAttaching(data) {
|
|
|
+ var media = this.media = data.media;
|
|
|
+ this.mediaType = data.mediaType;
|
|
|
+ this.websocketName = data.websocketName;
|
|
|
+ this.channelName = data.channelName;
|
|
|
+ this.deviceId = data.deviceId;
|
|
|
+ this.clientid = data.clientid;
|
|
|
+ this.loginHandle = data.loginHandle;
|
|
|
+ this.wsUrl = data.wsUrl;
|
|
|
+ this.sessiontype = data.sessiontype;
|
|
|
+ this.begintime = data.begintime;
|
|
|
+ if (media) {
|
|
|
+ // setup the media source
|
|
|
+ var ms = this.mediaSource = new MediaSource();
|
|
|
+ //Media Source listeners
|
|
|
+ this.onmso = this.onMediaSourceOpen.bind(this);
|
|
|
+ this.onmse = this.onMediaSourceEnded.bind(this);
|
|
|
+ this.onmsc = this.onMediaSourceClose.bind(this);
|
|
|
+ ms.addEventListener('sourceopen', this.onmso);
|
|
|
+ ms.addEventListener('sourceended', this.onmse);
|
|
|
+ ms.addEventListener('sourceclose', this.onmsc);
|
|
|
+ // link video and media Source
|
|
|
+ media.src = URL.createObjectURL(ms);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'onMediaDetaching',
|
|
|
+ value: function onMediaDetaching() {}
|
|
|
+ }, {
|
|
|
+ key: 'onBufferAppending',
|
|
|
+ value: function onBufferAppending(data) {
|
|
|
+ if (!this.segments) {
|
|
|
+ this.segments = [data];
|
|
|
+ } else {
|
|
|
+ this.segments.push(data);
|
|
|
+ }
|
|
|
+ if(this.media.paused){
|
|
|
+ //this.media.play();
|
|
|
+ // return;
|
|
|
+ }
|
|
|
+ this.doAppending();
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'onMediaSourceClose',
|
|
|
+ value: function onMediaSourceClose() {
|
|
|
+ console.log('media source closed');
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'onMediaSourceEnded',
|
|
|
+ value: function onMediaSourceEnded() {
|
|
|
+ console.log('media source ended');
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'onSBUpdateEnd',
|
|
|
+ value: function onSBUpdateEnd(event) {
|
|
|
+ // Firefox
|
|
|
+ if (this.browserType === 1) {
|
|
|
+ this.mediaSource.endOfStream();
|
|
|
+ this.media.play();
|
|
|
+ }
|
|
|
+ // console.log("currentTime: " + this.media.currentTime);
|
|
|
+ var buffered = this.sourceBuffer['video'].buffered;
|
|
|
+ var played = this.media.played;
|
|
|
+
|
|
|
+ if(buffered.length >0 && played.length){
|
|
|
+ if((buffered.end(0) - this.media.currentTime)> 1){
|
|
|
+ if(!this.media.paused){
|
|
|
+ this.media.currentTime = buffered.end(0);
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // for (var j = 0; j < played.length; j++) {
|
|
|
+ // console.log("played start: " + played.start(j));
|
|
|
+ // console.log("played end: " + played.end(j));
|
|
|
+ // }
|
|
|
+ // console.log("readystate: " + this.media.readyState);
|
|
|
+ // for (var i = 0; i < buffered.length; i++) {
|
|
|
+ // console.log("start: " + buffered.start(i));
|
|
|
+ // console.log("end: " + buffered.end(i));
|
|
|
+ // }
|
|
|
+ this.appending = false;
|
|
|
+ this.doAppending();
|
|
|
+ this.updateMediaElementDuration();
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'updateMediaElementDuration',
|
|
|
+ value: function updateMediaElementDuration() {}
|
|
|
+ }, {
|
|
|
+ key: 'onMediaSourceOpen',
|
|
|
+ value: function onMediaSourceOpen() {
|
|
|
+ var mediaSource = this.mediaSource;
|
|
|
+ if (mediaSource) {
|
|
|
+ // once received, don't listen anymore to sourceopen event
|
|
|
+ mediaSource.removeEventListener('sourceopen', this.onmso);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (this.mediaType === 'FMp4') {
|
|
|
+ this.checkPendingTracks();
|
|
|
+ }
|
|
|
+ this.wfs.trigger(_events2.default.MEDIA_ATTACHED, { media: this.media, channelName: this.channelName, mediaType: this.mediaType, websocketName: this.websocketName, deviceId: this.deviceId,clientid: this.clientid,loginHandle: this.loginHandle,wsUrl: this.wsUrl, sessiontype: this.sessiontype, begintime: this.begintime });
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'checkPendingTracks',
|
|
|
+ value: function checkPendingTracks() {
|
|
|
+ this.createSourceBuffers({ tracks: 'video', mimeType: '' });
|
|
|
+ this.pendingTracks = {};
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'onBufferReset',
|
|
|
+ value: function onBufferReset(data) {
|
|
|
+ if (this.mediaType === 'H264Raw') {
|
|
|
+ this.createSourceBuffers({ tracks: 'video', mimeType: data.mimeType });
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'createSourceBuffers',
|
|
|
+ value: function createSourceBuffers(tracks) {
|
|
|
+ var sourceBuffer = this.sourceBuffer,
|
|
|
+ mediaSource = this.mediaSource;
|
|
|
+ var mimeType = void 0;
|
|
|
+ if (tracks.mimeType === '') {
|
|
|
+ mimeType = 'video/mp4;codecs=avc1.420028'; // avc1.42c01f avc1.42801e avc1.640028 avc1.420028
|
|
|
+ } else {
|
|
|
+ mimeType = 'video/mp4;codecs=' + tracks.mimeType;
|
|
|
+ }
|
|
|
+
|
|
|
+ try {
|
|
|
+ var sb = sourceBuffer['video'] = this.mediaSource.addSourceBuffer(mimeType);
|
|
|
+ sb.addEventListener('updateend', this.onsbue);
|
|
|
+ track.buffer = sb;
|
|
|
+ } catch (err) {}
|
|
|
+ this.wfs.trigger(_events2.default.BUFFER_CREATED, { tracks: tracks });
|
|
|
+ let playPromise = this.media.play();
|
|
|
+ if (playPromise !== undefined) {
|
|
|
+ playPromise.then(function() {
|
|
|
+ this.media.play();
|
|
|
+ }.bind(this)).catch(function(error) {
|
|
|
+ console.log(error);
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'doAppending',
|
|
|
+ value: function doAppending() {
|
|
|
+ var wfs = this.wfs,
|
|
|
+ sourceBuffer = this.sourceBuffer,
|
|
|
+ segments = this.segments;
|
|
|
+ if (Object.keys(sourceBuffer).length) {
|
|
|
+ if (this.media.error) {
|
|
|
+ this.segments = [];
|
|
|
+ if(this.errLogTimes > 200) return;
|
|
|
+ this.errLogTimes >= 0 ? this.errLogTimes++ : this.errLogTimes = 0;
|
|
|
+ console.log('trying to append although a media error occured, flush segment and abort:'+this.media.error.message);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ this.errLogTimes = 0;
|
|
|
+ if (this.appending) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (segments && segments.length) {
|
|
|
+ var segment = segments.shift();
|
|
|
+ //console.log("segments len: " + segments.length + " segment len: " + segment.data.length);
|
|
|
+ try {
|
|
|
+ if (sourceBuffer[segment.type]) {
|
|
|
+ this.parent = segment.parent;
|
|
|
+ sourceBuffer[segment.type].appendBuffer(segment.data);
|
|
|
+ this.appendError = 0;
|
|
|
+ this.appended++;
|
|
|
+ this.appending = true;
|
|
|
+ } else {}
|
|
|
+ } catch (err) {
|
|
|
+ // in case any error occured while appending, put back segment in segments table
|
|
|
+ segments.unshift(segment);
|
|
|
+ var event = { type: ErrorTypes.MEDIA_ERROR };
|
|
|
+ if (err.code !== 22) {
|
|
|
+ if (this.appendError) {
|
|
|
+ this.appendError++;
|
|
|
+ } else {
|
|
|
+ this.appendError = 1;
|
|
|
+ }
|
|
|
+ event.details = ErrorDetails.BUFFER_APPEND_ERROR;
|
|
|
+ event.frag = this.fragCurrent;
|
|
|
+ if (this.appendError > wfs.config.appendErrorMaxRetry) {
|
|
|
+ segments = [];
|
|
|
+ event.fatal = true;
|
|
|
+ return;
|
|
|
+ } else {
|
|
|
+ event.fatal = false;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ this.segments = [];
|
|
|
+ event.details = ErrorDetails.BUFFER_FULL_ERROR;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }]);
|
|
|
+
|
|
|
+ return BufferController;
|
|
|
+}(_eventHandler2.default);
|
|
|
+
|
|
|
+exports.default = BufferController;
|
|
|
+
|
|
|
+},{"../event-handler":8,"../events":9}],4:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+Object.defineProperty(exports, "__esModule", {
|
|
|
+ value: true
|
|
|
+});
|
|
|
+
|
|
|
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
+
|
|
|
+var _events = require('../events');
|
|
|
+
|
|
|
+var _events2 = _interopRequireDefault(_events);
|
|
|
+
|
|
|
+var _eventHandler = require('../event-handler');
|
|
|
+
|
|
|
+var _eventHandler2 = _interopRequireDefault(_eventHandler);
|
|
|
+
|
|
|
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
+
|
|
|
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
+
|
|
|
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
+
|
|
|
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /*
|
|
|
+ * Flow Controller
|
|
|
+ */
|
|
|
+
|
|
|
+var FlowController = function (_EventHandler) {
|
|
|
+ _inherits(FlowController, _EventHandler);
|
|
|
+
|
|
|
+ function FlowController(wfs) {
|
|
|
+ _classCallCheck(this, FlowController);
|
|
|
+
|
|
|
+ var _this = _possibleConstructorReturn(this, (FlowController.__proto__ || Object.getPrototypeOf(FlowController)).call(this, wfs, _events2.default.MEDIA_ATTACHED, _events2.default.BUFFER_CREATED, _events2.default.FILE_PARSING_DATA, _events2.default.FILE_HEAD_LOADED, _events2.default.FILE_DATA_LOADED, _events2.default.WEBSOCKET_ATTACHED, _events2.default.FRAG_PARSING_DATA, _events2.default.FRAG_PARSING_INIT_SEGMENT));
|
|
|
+
|
|
|
+ _this.fileStart = 0;
|
|
|
+ _this.fileEnd = 0;
|
|
|
+ _this.pendingAppending = 0;
|
|
|
+ _this.mediaType = undefined;
|
|
|
+ channelName: _this.channelName;
|
|
|
+ return _this;
|
|
|
+ }
|
|
|
+
|
|
|
+ _createClass(FlowController, [{
|
|
|
+ key: 'destroy',
|
|
|
+ value: function destroy() {
|
|
|
+ _eventHandler2.default.prototype.destroy.call(this);
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'onMediaAttached',
|
|
|
+ value: function onMediaAttached(data) {
|
|
|
+ if (data.websocketName != undefined) {
|
|
|
+ var client = new WebSocket(data.wsUrl);
|
|
|
+ this.wfs.attachWebsocket(client, data.channelName, data.deviceId, data.clientid, data.loginHandle, data.sessiontype, data.begintime);
|
|
|
+ } else {
|
|
|
+ console.log('websocketName ERROE!!!');
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'onBufferCreated',
|
|
|
+ value: function onBufferCreated(data) {
|
|
|
+ this.mediaType = data.mediaType;
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'onFileHeadLoaded',
|
|
|
+ value: function onFileHeadLoaded(data) {}
|
|
|
+ }, {
|
|
|
+ key: 'onFileDataLoaded',
|
|
|
+ value: function onFileDataLoaded(data) {}
|
|
|
+ }, {
|
|
|
+ key: 'onFileParsingData',
|
|
|
+ value: function onFileParsingData(data) {}
|
|
|
+ }, {
|
|
|
+ key: 'onWebsocketAttached',
|
|
|
+ value: function onWebsocketAttached(data) {
|
|
|
+ this.wfs.trigger(_events2.default.BUFFER_APPENDING, { type: 'video', data: data.payload, parent: 'main' });
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'onFragParsingInitSegment',
|
|
|
+ value: function onFragParsingInitSegment(data) {
|
|
|
+ var tracks = data.tracks,
|
|
|
+ trackName,
|
|
|
+ track;
|
|
|
+
|
|
|
+ track = tracks.video;
|
|
|
+ if (track) {
|
|
|
+ track.id = data.id;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (trackName in tracks) {
|
|
|
+ track = tracks[trackName];
|
|
|
+ var initSegment = track.initSegment;
|
|
|
+ if (initSegment) {
|
|
|
+ this.pendingAppending++;
|
|
|
+ this.wfs.trigger(_events2.default.BUFFER_APPENDING, { type: trackName, data: initSegment, parent: 'main' });
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'onFragParsingData',
|
|
|
+ value: function onFragParsingData(data) {
|
|
|
+ var _this2 = this;
|
|
|
+
|
|
|
+ if (data.type === 'video') {}
|
|
|
+
|
|
|
+ [data.data1, data.data2].forEach(function (buffer) {
|
|
|
+ if (buffer) {
|
|
|
+ _this2.pendingAppending++;
|
|
|
+ _this2.wfs.trigger(_events2.default.BUFFER_APPENDING, { type: data.type, data: buffer, parent: 'main' });
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }]);
|
|
|
+
|
|
|
+ return FlowController;
|
|
|
+}(_eventHandler2.default);
|
|
|
+
|
|
|
+exports.default = FlowController;
|
|
|
+
|
|
|
+},{"../event-handler":8,"../events":9}],5:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+Object.defineProperty(exports, "__esModule", {
|
|
|
+ value: true
|
|
|
+});
|
|
|
+
|
|
|
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /**
|
|
|
+ * Parser for exponential Golomb codes, a variable-bitwidth number encoding scheme used by h264.
|
|
|
+ */
|
|
|
+
|
|
|
+var _logger = require('../utils/logger');
|
|
|
+
|
|
|
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
+
|
|
|
+var ExpGolomb = function () {
|
|
|
+ function ExpGolomb(data) {
|
|
|
+ _classCallCheck(this, ExpGolomb);
|
|
|
+
|
|
|
+ this.data = data;
|
|
|
+ // the number of bytes left to examine in this.data
|
|
|
+ this.bytesAvailable = this.data.byteLength;
|
|
|
+ // the current word being examined
|
|
|
+ this.word = 0; // :uint
|
|
|
+ // the number of bits left to examine in the current word
|
|
|
+ this.bitsAvailable = 0; // :uint
|
|
|
+ }
|
|
|
+
|
|
|
+ // ():void
|
|
|
+
|
|
|
+
|
|
|
+ _createClass(ExpGolomb, [{
|
|
|
+ key: 'loadWord',
|
|
|
+ value: function loadWord() {
|
|
|
+ var position = this.data.byteLength - this.bytesAvailable,
|
|
|
+ workingBytes = new Uint8Array(4),
|
|
|
+ availableBytes = Math.min(4, this.bytesAvailable);
|
|
|
+ if (availableBytes === 0) {
|
|
|
+ throw new Error('no bytes available');
|
|
|
+ }
|
|
|
+ workingBytes.set(this.data.subarray(position, position + availableBytes));
|
|
|
+ this.word = new DataView(workingBytes.buffer).getUint32(0);
|
|
|
+ // track the amount of this.data that has been processed
|
|
|
+ this.bitsAvailable = availableBytes * 8;
|
|
|
+ this.bytesAvailable -= availableBytes;
|
|
|
+ }
|
|
|
+
|
|
|
+ // (count:int):void
|
|
|
+
|
|
|
+ }, {
|
|
|
+ key: 'skipBits',
|
|
|
+ value: function skipBits(count) {
|
|
|
+ var skipBytes; // :int
|
|
|
+ if (this.bitsAvailable > count) {
|
|
|
+ this.word <<= count;
|
|
|
+ this.bitsAvailable -= count;
|
|
|
+ } else {
|
|
|
+ count -= this.bitsAvailable;
|
|
|
+ skipBytes = count >> 3;
|
|
|
+ count -= skipBytes >> 3;
|
|
|
+ this.bytesAvailable -= skipBytes;
|
|
|
+ this.loadWord();
|
|
|
+ this.word <<= count;
|
|
|
+ this.bitsAvailable -= count;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // (size:int):uint
|
|
|
+
|
|
|
+ }, {
|
|
|
+ key: 'readBits',
|
|
|
+ value: function readBits(size) {
|
|
|
+ var bits = Math.min(this.bitsAvailable, size),
|
|
|
+ // :uint
|
|
|
+ valu = this.word >>> 32 - bits; // :uint
|
|
|
+ if (size > 32) {
|
|
|
+ _logger.logger.error('Cannot read more than 32 bits at a time');
|
|
|
+ }
|
|
|
+ this.bitsAvailable -= bits;
|
|
|
+ if (this.bitsAvailable > 0) {
|
|
|
+ this.word <<= bits;
|
|
|
+ } else if (this.bytesAvailable > 0) {
|
|
|
+ this.loadWord();
|
|
|
+ }
|
|
|
+ bits = size - bits;
|
|
|
+ if (bits > 0) {
|
|
|
+ return valu << bits | this.readBits(bits);
|
|
|
+ } else {
|
|
|
+ return valu;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // ():uint
|
|
|
+
|
|
|
+ }, {
|
|
|
+ key: 'skipLZ',
|
|
|
+ value: function skipLZ() {
|
|
|
+ var leadingZeroCount; // :uint
|
|
|
+ for (leadingZeroCount = 0; leadingZeroCount < this.bitsAvailable; ++leadingZeroCount) {
|
|
|
+ if (0 !== (this.word & 0x80000000 >>> leadingZeroCount)) {
|
|
|
+ // the first bit of working word is 1
|
|
|
+ this.word <<= leadingZeroCount;
|
|
|
+ this.bitsAvailable -= leadingZeroCount;
|
|
|
+ return leadingZeroCount;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // we exhausted word and still have not found a 1
|
|
|
+ this.loadWord();
|
|
|
+ return leadingZeroCount + this.skipLZ();
|
|
|
+ }
|
|
|
+
|
|
|
+ // ():void
|
|
|
+
|
|
|
+ }, {
|
|
|
+ key: 'skipUEG',
|
|
|
+ value: function skipUEG() {
|
|
|
+ this.skipBits(1 + this.skipLZ());
|
|
|
+ }
|
|
|
+
|
|
|
+ // ():void
|
|
|
+
|
|
|
+ }, {
|
|
|
+ key: 'skipEG',
|
|
|
+ value: function skipEG() {
|
|
|
+ this.skipBits(1 + this.skipLZ());
|
|
|
+ }
|
|
|
+
|
|
|
+ // ():uint
|
|
|
+
|
|
|
+ }, {
|
|
|
+ key: 'readUEG',
|
|
|
+ value: function readUEG() {
|
|
|
+ var clz = this.skipLZ(); // :uint
|
|
|
+ return this.readBits(clz + 1) - 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ // ():int
|
|
|
+
|
|
|
+ }, {
|
|
|
+ key: 'readEG',
|
|
|
+ value: function readEG() {
|
|
|
+ var valu = this.readUEG(); // :int
|
|
|
+ if (0x01 & valu) {
|
|
|
+ // the number is odd if the low order bit is set
|
|
|
+ return 1 + valu >>> 1; // add 1 to make it even, and divide by 2
|
|
|
+ } else {
|
|
|
+ return -1 * (valu >>> 1); // divide by two then make it negative
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Some convenience functions
|
|
|
+ // :Boolean
|
|
|
+
|
|
|
+ }, {
|
|
|
+ key: 'readBoolean',
|
|
|
+ value: function readBoolean() {
|
|
|
+ return 1 === this.readBits(1);
|
|
|
+ }
|
|
|
+
|
|
|
+ // ():int
|
|
|
+
|
|
|
+ }, {
|
|
|
+ key: 'readUByte',
|
|
|
+ value: function readUByte() {
|
|
|
+ return this.readBits(8);
|
|
|
+ }
|
|
|
+
|
|
|
+ // ():int
|
|
|
+
|
|
|
+ }, {
|
|
|
+ key: 'readUShort',
|
|
|
+ value: function readUShort() {
|
|
|
+ return this.readBits(16);
|
|
|
+ }
|
|
|
+ // ():int
|
|
|
+
|
|
|
+ }, {
|
|
|
+ key: 'readUInt',
|
|
|
+ value: function readUInt() {
|
|
|
+ return this.readBits(32);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Advance the ExpGolomb decoder past a scaling list. The scaling
|
|
|
+ * list is optionally transmitted as part of a sequence parameter
|
|
|
+ * set and is not relevant to transmuxing.
|
|
|
+ * @param count {number} the number of entries in this scaling list
|
|
|
+ * @see Recommendation ITU-T H.264, Section 7.3.2.1.1.1
|
|
|
+ */
|
|
|
+
|
|
|
+ }, {
|
|
|
+ key: 'skipScalingList',
|
|
|
+ value: function skipScalingList(count) {
|
|
|
+ var lastScale = 8,
|
|
|
+ nextScale = 8,
|
|
|
+ j,
|
|
|
+ deltaScale;
|
|
|
+ for (j = 0; j < count; j++) {
|
|
|
+ if (nextScale !== 0) {
|
|
|
+ deltaScale = this.readEG();
|
|
|
+ nextScale = (lastScale + deltaScale + 256) % 256;
|
|
|
+ }
|
|
|
+ lastScale = nextScale === 0 ? lastScale : nextScale;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Read a sequence parameter set and return some interesting video
|
|
|
+ * properties. A sequence parameter set is the H264 metadata that
|
|
|
+ * describes the properties of upcoming video frames.
|
|
|
+ * @param data {Uint8Array} the bytes of a sequence parameter set
|
|
|
+ * @return {object} an object with configuration parsed from the
|
|
|
+ * sequence parameter set, including the dimensions of the
|
|
|
+ * associated video frames.
|
|
|
+ */
|
|
|
+
|
|
|
+ }, {
|
|
|
+ key: 'readSPS',
|
|
|
+ value: function readSPS() {
|
|
|
+ var frameCropLeftOffset = 0,
|
|
|
+ frameCropRightOffset = 0,
|
|
|
+ frameCropTopOffset = 0,
|
|
|
+ frameCropBottomOffset = 0,
|
|
|
+ sarScale = 1,
|
|
|
+ profileIdc,
|
|
|
+ profileCompat,
|
|
|
+ levelIdc,
|
|
|
+ numRefFramesInPicOrderCntCycle,
|
|
|
+ picWidthInMbsMinus1,
|
|
|
+ picHeightInMapUnitsMinus1,
|
|
|
+ frameMbsOnlyFlag,
|
|
|
+ scalingListCount,
|
|
|
+ i;
|
|
|
+ this.readUByte();
|
|
|
+ profileIdc = this.readUByte(); // profile_idc
|
|
|
+ profileCompat = this.readBits(5); // constraint_set[0-4]_flag, u(5)
|
|
|
+ this.skipBits(3); // reserved_zero_3bits u(3),
|
|
|
+ levelIdc = this.readUByte(); //level_idc u(8)
|
|
|
+ this.skipUEG(); // seq_parameter_set_id
|
|
|
+ // some profiles have more optional data we don't need
|
|
|
+ if (profileIdc === 100 || profileIdc === 110 || profileIdc === 122 || profileIdc === 244 || profileIdc === 44 || profileIdc === 83 || profileIdc === 86 || profileIdc === 118 || profileIdc === 128) {
|
|
|
+ var chromaFormatIdc = this.readUEG();
|
|
|
+ if (chromaFormatIdc === 3) {
|
|
|
+ this.skipBits(1); // separate_colour_plane_flag
|
|
|
+ }
|
|
|
+ this.skipUEG(); // bit_depth_luma_minus8
|
|
|
+ this.skipUEG(); // bit_depth_chroma_minus8
|
|
|
+ this.skipBits(1); // qpprime_y_zero_transform_bypass_flag
|
|
|
+ if (this.readBoolean()) {
|
|
|
+ // seq_scaling_matrix_present_flag
|
|
|
+ scalingListCount = chromaFormatIdc !== 3 ? 8 : 12;
|
|
|
+ for (i = 0; i < scalingListCount; i++) {
|
|
|
+ if (this.readBoolean()) {
|
|
|
+ // seq_scaling_list_present_flag[ i ]
|
|
|
+ if (i < 6) {
|
|
|
+ this.skipScalingList(16);
|
|
|
+ } else {
|
|
|
+ this.skipScalingList(64);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ this.skipUEG(); // log2_max_frame_num_minus4
|
|
|
+ var picOrderCntType = this.readUEG();
|
|
|
+ if (picOrderCntType === 0) {
|
|
|
+ this.readUEG(); //log2_max_pic_order_cnt_lsb_minus4
|
|
|
+ } else if (picOrderCntType === 1) {
|
|
|
+ this.skipBits(1); // delta_pic_order_always_zero_flag
|
|
|
+ this.skipEG(); // offset_for_non_ref_pic
|
|
|
+ this.skipEG(); // offset_for_top_to_bottom_field
|
|
|
+ numRefFramesInPicOrderCntCycle = this.readUEG();
|
|
|
+ for (i = 0; i < numRefFramesInPicOrderCntCycle; i++) {
|
|
|
+ this.skipEG(); // offset_for_ref_frame[ i ]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ this.skipUEG(); // max_num_ref_frames
|
|
|
+ this.skipBits(1); // gaps_in_frame_num_value_allowed_flag
|
|
|
+ picWidthInMbsMinus1 = this.readUEG();
|
|
|
+ picHeightInMapUnitsMinus1 = this.readUEG();
|
|
|
+ frameMbsOnlyFlag = this.readBits(1);
|
|
|
+ if (frameMbsOnlyFlag === 0) {
|
|
|
+ this.skipBits(1); // mb_adaptive_frame_field_flag
|
|
|
+ }
|
|
|
+ this.skipBits(1); // direct_8x8_inference_flag
|
|
|
+ if (this.readBoolean()) {
|
|
|
+ // frame_cropping_flag
|
|
|
+ frameCropLeftOffset = this.readUEG();
|
|
|
+ frameCropRightOffset = this.readUEG();
|
|
|
+ frameCropTopOffset = this.readUEG();
|
|
|
+ frameCropBottomOffset = this.readUEG();
|
|
|
+ }
|
|
|
+ if (this.readBoolean()) {
|
|
|
+ // vui_parameters_present_flag
|
|
|
+ if (this.readBoolean()) {
|
|
|
+ // aspect_ratio_info_present_flag
|
|
|
+ var sarRatio = void 0;
|
|
|
+ var aspectRatioIdc = this.readUByte();
|
|
|
+ switch (aspectRatioIdc) {
|
|
|
+ case 1:
|
|
|
+ sarRatio = [1, 1];break;
|
|
|
+ case 2:
|
|
|
+ sarRatio = [12, 11];break;
|
|
|
+ case 3:
|
|
|
+ sarRatio = [10, 11];break;
|
|
|
+ case 4:
|
|
|
+ sarRatio = [16, 11];break;
|
|
|
+ case 5:
|
|
|
+ sarRatio = [40, 33];break;
|
|
|
+ case 6:
|
|
|
+ sarRatio = [24, 11];break;
|
|
|
+ case 7:
|
|
|
+ sarRatio = [20, 11];break;
|
|
|
+ case 8:
|
|
|
+ sarRatio = [32, 11];break;
|
|
|
+ case 9:
|
|
|
+ sarRatio = [80, 33];break;
|
|
|
+ case 10:
|
|
|
+ sarRatio = [18, 11];break;
|
|
|
+ case 11:
|
|
|
+ sarRatio = [15, 11];break;
|
|
|
+ case 12:
|
|
|
+ sarRatio = [64, 33];break;
|
|
|
+ case 13:
|
|
|
+ sarRatio = [160, 99];break;
|
|
|
+ case 14:
|
|
|
+ sarRatio = [4, 3];break;
|
|
|
+ case 15:
|
|
|
+ sarRatio = [3, 2];break;
|
|
|
+ case 16:
|
|
|
+ sarRatio = [2, 1];break;
|
|
|
+ case 255:
|
|
|
+ {
|
|
|
+ sarRatio = [this.readUByte() << 8 | this.readUByte(), this.readUByte() << 8 | this.readUByte()];
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (sarRatio) {
|
|
|
+ sarScale = sarRatio[0] / sarRatio[1];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ width: Math.ceil(((picWidthInMbsMinus1 + 1) * 16 - frameCropLeftOffset * 2 - frameCropRightOffset * 2) * sarScale),
|
|
|
+ height: (2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16 - (frameMbsOnlyFlag ? 2 : 4) * (frameCropTopOffset + frameCropBottomOffset)
|
|
|
+ };
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'readSliceType',
|
|
|
+ value: function readSliceType() {
|
|
|
+ // skip NALu type
|
|
|
+ this.readUByte();
|
|
|
+ // discard first_mb_in_slice
|
|
|
+ this.readUEG();
|
|
|
+ // return slice_type
|
|
|
+ return this.readUEG();
|
|
|
+ }
|
|
|
+ }]);
|
|
|
+
|
|
|
+ return ExpGolomb;
|
|
|
+}();
|
|
|
+
|
|
|
+exports.default = ExpGolomb;
|
|
|
+
|
|
|
+},{"../utils/logger":17}],6:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+Object.defineProperty(exports, "__esModule", {
|
|
|
+ value: true
|
|
|
+});
|
|
|
+
|
|
|
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
+
|
|
|
+var _errors = require('../errors');
|
|
|
+
|
|
|
+var _events = require('../events');
|
|
|
+
|
|
|
+var _events2 = _interopRequireDefault(_events);
|
|
|
+
|
|
|
+var _expGolomb = require('./exp-golomb');
|
|
|
+
|
|
|
+var _expGolomb2 = _interopRequireDefault(_expGolomb);
|
|
|
+
|
|
|
+var _eventHandler = require('../event-handler');
|
|
|
+
|
|
|
+var _eventHandler2 = _interopRequireDefault(_eventHandler);
|
|
|
+
|
|
|
+var _mp4Remuxer = require('../remux/mp4-remuxer');
|
|
|
+
|
|
|
+var _mp4Remuxer2 = _interopRequireDefault(_mp4Remuxer);
|
|
|
+
|
|
|
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
+
|
|
|
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
+
|
|
|
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
+
|
|
|
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /**
|
|
|
+
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+var h264Demuxer = function (_EventHandler) {
|
|
|
+ _inherits(h264Demuxer, _EventHandler);
|
|
|
+
|
|
|
+ function h264Demuxer(wfs) {
|
|
|
+ var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
|
|
|
+
|
|
|
+ _classCallCheck(this, h264Demuxer);
|
|
|
+
|
|
|
+ var _this = _possibleConstructorReturn(this, (h264Demuxer.__proto__ || Object.getPrototypeOf(h264Demuxer)).call(this, wfs, _events2.default.H264_DATA_PARSING));
|
|
|
+
|
|
|
+ _this.config = _this.wfs.config || config;
|
|
|
+ _this.wfs = wfs;
|
|
|
+ _this.id = 'main';
|
|
|
+ var typeSupported = {
|
|
|
+ mp4: MediaSource.isTypeSupported('video/mp4') //,
|
|
|
+ // mp2t : wfs.config.enableMP2TPassThrough && MediaSource.isTypeSupported('video/mp2t')
|
|
|
+ };
|
|
|
+
|
|
|
+ _this.remuxer = new _mp4Remuxer2.default(_this.wfs, _this.id, _this.config);
|
|
|
+ _this.contiguous = true;
|
|
|
+ _this.timeOffset = 1;
|
|
|
+ _this.sn = 0;
|
|
|
+ _this.TIMESCALE = 90000;
|
|
|
+ _this.timestamp = 0;
|
|
|
+ _this.scaleFactor = _this.TIMESCALE / 1000;
|
|
|
+ _this.H264_TIMEBASE = 3000;
|
|
|
+ _this.gloUnits = null;
|
|
|
+ _this.lastUnitType;
|
|
|
+ _this.lastState = 0;
|
|
|
+ _this.trackWidth = 0;
|
|
|
+ _this.trackHeight = 0;
|
|
|
+ _this.firstIFrame = true;
|
|
|
+ _this.gloFirstFrameArr = [];
|
|
|
+ _this._avcTrack = { container: 'video/mp4', type: 'video', id: 1, sequenceNumber: 0,
|
|
|
+ //this._avcTrack = {container : 'video/mp4', type: 'video', id :1, sequenceNumber: 0,
|
|
|
+ samples: [], len: 0, nbNalu: 0, dropped: 0, count: 0 };
|
|
|
+ _this.browserType = 0;
|
|
|
+ if (navigator.userAgent.toLowerCase().indexOf('firefox') !== -1) {
|
|
|
+ _this.browserType = 1;
|
|
|
+ }
|
|
|
+ return _this;
|
|
|
+ }
|
|
|
+
|
|
|
+ _createClass(h264Demuxer, [{
|
|
|
+ key: 'destroy',
|
|
|
+ value: function destroy() {
|
|
|
+ _eventHandler2.default.prototype.destroy.call(this);
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'getTimestampM',
|
|
|
+ value: function getTimestampM() {
|
|
|
+ this.timestamp += this.H264_TIMEBASE;
|
|
|
+ return this.timestamp;
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'onH264DataParsing',
|
|
|
+ value: function onH264DataParsing(event) {
|
|
|
+ this._parseAVCTrack(event.data);
|
|
|
+ if (this.browserType === 1) {
|
|
|
+ // Firefox
|
|
|
+ this.remuxer.pushVideo(0, this.sn, this._avcTrack, this.timeOffset, this.contiguous);
|
|
|
+ this.sn += 1;
|
|
|
+ } else {
|
|
|
+ this.remuxer.pushVideo(0, this.sn, this._avcTrack, this.timeOffset, this.contiguous);
|
|
|
+ this.sn += 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: '_parseAVCTrack',
|
|
|
+ value: function _parseAVCTrack(array) {
|
|
|
+ var _this2 = this;
|
|
|
+ var track = this._avcTrack,
|
|
|
+ samples = track.samples,
|
|
|
+ units = this._parseAVCNALu(array),
|
|
|
+ units2 = [],
|
|
|
+ debug = false,
|
|
|
+ key = false,
|
|
|
+ length = 0,
|
|
|
+ expGolombDecoder,
|
|
|
+ avcSample,
|
|
|
+ push,
|
|
|
+ i;
|
|
|
+ var debugString = '';
|
|
|
+ var pushAccesUnit = function () {
|
|
|
+ if (units2.length) {
|
|
|
+ if (!this.config.forceKeyFrameOnDiscontinuity || key === true || track.sps && (samples.length || this.contiguous)) {
|
|
|
+ var tss = this.getTimestampM();
|
|
|
+ avcSample = { units: { units: units2, length: length }, pts: tss, dts: tss, key: key };
|
|
|
+ samples.push(avcSample);
|
|
|
+ track.len += length;
|
|
|
+ track.nbNalu += units2.length;
|
|
|
+ } else {
|
|
|
+ track.dropped++;
|
|
|
+ }
|
|
|
+ units2 = [];
|
|
|
+ length = 0;
|
|
|
+ }
|
|
|
+ }.bind(this);
|
|
|
+ units.forEach(function (unit) {
|
|
|
+ switch (unit.type) {
|
|
|
+ //NDR
|
|
|
+ case 1:
|
|
|
+ push = true;
|
|
|
+ if (debug) {
|
|
|
+ debugString += 'NDR ';
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ //IDR
|
|
|
+ case 5:
|
|
|
+ push = true;
|
|
|
+ if (debug) {
|
|
|
+ debugString += 'IDR ';
|
|
|
+ }
|
|
|
+ key = true;
|
|
|
+ break;
|
|
|
+ //SEI
|
|
|
+ case 6:
|
|
|
+ unit.data = _this2.discardEPB(unit.data);
|
|
|
+ expGolombDecoder = new _expGolomb2.default(unit.data);
|
|
|
+ // skip frameType
|
|
|
+ expGolombDecoder.readUByte();
|
|
|
+ break;
|
|
|
+ //SPS
|
|
|
+ case 7:
|
|
|
+ push = false;
|
|
|
+ if (debug) {
|
|
|
+ debugString += 'SPS ';
|
|
|
+ }
|
|
|
+ // if (!track.sps) {
|
|
|
+ expGolombDecoder = new _expGolomb2.default(unit.data);
|
|
|
+ var config = expGolombDecoder.readSPS();
|
|
|
+ track.width = config.width;
|
|
|
+ track.height = config.height;
|
|
|
+ track.sps = [unit.data];
|
|
|
+ track.duration = 0;
|
|
|
+ var codecarray = unit.data.subarray(1, 4);
|
|
|
+ var codecstring = 'avc1.';
|
|
|
+ for (i = 0; i < 3; i++) {
|
|
|
+ var h = codecarray[i].toString(16);
|
|
|
+ if (h.length < 2) {
|
|
|
+ h = '0' + h;
|
|
|
+ }
|
|
|
+ codecstring += h;
|
|
|
+ }
|
|
|
+ track.codec = codecstring;
|
|
|
+ if(_this2.trackWidth != track.width || _this2.trackHeight != track.height){
|
|
|
+ _this2.trackWidth = track.width;
|
|
|
+ _this2.trackHeight = track.height;
|
|
|
+ _this2.wfs.trigger(_events2.default.BUFFER_RESET, { mimeType: track.codec });
|
|
|
+ push = true;
|
|
|
+ }
|
|
|
+ // }
|
|
|
+ break;
|
|
|
+ //PPS
|
|
|
+ case 8:
|
|
|
+ push = false;
|
|
|
+ if (debug) {
|
|
|
+ debugString += 'PPS ';
|
|
|
+ }
|
|
|
+ if (!track.pps) {
|
|
|
+ track.pps = [unit.data];
|
|
|
+ push = true;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case 9:
|
|
|
+ push = false;
|
|
|
+ if (debug) {
|
|
|
+ debugString += 'AUD ';
|
|
|
+ }
|
|
|
+ pushAccesUnit();
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ push = false;
|
|
|
+ debugString += 'unknown NAL ' + unit.type + ' ';
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (push) {
|
|
|
+ units2.push(unit);
|
|
|
+ length += unit.data.byteLength;
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ if (debug || debugString.length) {
|
|
|
+ logger.log(debugString);
|
|
|
+ }
|
|
|
+
|
|
|
+ pushAccesUnit();
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: '_parseAVCNALu',
|
|
|
+ value: function _parseAVCNALu(array) {
|
|
|
+ var i = 0,
|
|
|
+ len = array.byteLength,
|
|
|
+ value,
|
|
|
+ overflow,
|
|
|
+ state = 0; //state = this.avcNaluState;
|
|
|
+ var units = [],
|
|
|
+ unit,
|
|
|
+ unitType,
|
|
|
+ lastUnitStart,
|
|
|
+ lastUnitType;
|
|
|
+ while (i < len) {
|
|
|
+ value = array[i++];
|
|
|
+ // finding 3 or 4-byte start codes (00 00 01 OR 00 00 00 01)
|
|
|
+ switch (state) {
|
|
|
+ case 0:
|
|
|
+ if (value === 0) {
|
|
|
+ state = 1;
|
|
|
+ this.lastState = 1;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case 1:
|
|
|
+ if (value === 0) {
|
|
|
+ state = 2;
|
|
|
+ this.lastState = 2;
|
|
|
+ } else {
|
|
|
+ state = 0;
|
|
|
+ this.lastState = 0;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case 2:
|
|
|
+ case 3:
|
|
|
+ if (value === 0) {
|
|
|
+ state = 3;
|
|
|
+ this.lastState = 3;
|
|
|
+ } else if (value === 1 && i < len) {
|
|
|
+ unitType = array[i] & 0x1f;
|
|
|
+ //判断第一次帧数据是否有Idr
|
|
|
+ if(this.firstIFrame && this.lastUnitType !=5 ){
|
|
|
+ //第一次数据包中没有包含完整的IDR,存储此次数据
|
|
|
+ if(lastUnitType){
|
|
|
+ unit = { data: array.subarray(lastUnitStart, i - state - 1), type: lastUnitType};
|
|
|
+ this.gloFirstFrameArr.push(unit);
|
|
|
+ }
|
|
|
+ lastUnitStart = i;
|
|
|
+ lastUnitType = unitType;
|
|
|
+ this.lastUnitType = lastUnitType;
|
|
|
+ state = 0;
|
|
|
+ this.lastState = 0;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ this.firstIFrame = false;
|
|
|
+ //判断此次数据是否包含完整的开头和结尾
|
|
|
+ if (lastUnitStart) {
|
|
|
+ unit = { data: array.subarray(lastUnitStart, i - state - 1), type: lastUnitType };
|
|
|
+ units.push(unit);
|
|
|
+ } else {
|
|
|
+ //当前数据首次找到开头，判断上次数据是否有遗留
|
|
|
+ if(this.gloUnits){
|
|
|
+ //判断是否存在在首次数据包中存储的没有IDR的数据
|
|
|
+ if(this.gloFirstFrameArr.length > 0){
|
|
|
+ for(var index=0;index < this.gloFirstFrameArr.length; index++){
|
|
|
+ units.push(this.gloFirstFrameArr[index]);
|
|
|
+ }
|
|
|
+ this.gloFirstFrameArr = [];
|
|
|
+ }
|
|
|
+ var data = array.subarray(0, i - state - 1);
|
|
|
+ var unitArray = new Uint8Array(data.length + this.gloUnits.data.length);
|
|
|
+ unitArray.set(this.gloUnits.data);
|
|
|
+ unitArray.set(data,this.gloUnits.data.length);
|
|
|
+ unit = { data: unitArray, type: this.gloUnits.type};
|
|
|
+ units.push(unit);
|
|
|
+ this.gloUnits = null;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ lastUnitStart = i;
|
|
|
+ lastUnitType = unitType;
|
|
|
+ this.lastUnitType = lastUnitType;
|
|
|
+ state = 0;
|
|
|
+ this.lastState = 0;
|
|
|
+ } else {
|
|
|
+ this.lastState = 0;
|
|
|
+ state = 0;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var unitData;
|
|
|
+ if (lastUnitStart) {
|
|
|
+ unitData = array.subarray(lastUnitStart, len);
|
|
|
+ }else{
|
|
|
+ unitData = array;
|
|
|
+ }
|
|
|
+ if(this.gloUnits){
|
|
|
+ var unitArray = new Uint8Array(unitData.length + this.gloUnits.data.length);
|
|
|
+ unitArray.set(this.gloUnits.data);
|
|
|
+ unitArray.set(unitData,this.gloUnits.data.length);
|
|
|
+ this.gloUnits ={ data: unitArray, type: this.gloUnits.type, state: this.gloUnits.state };
|
|
|
+ }else if(this.lastUnitType){
|
|
|
+ this.gloUnits ={ data: unitData, type: this.lastUnitType, state: state};
|
|
|
+ }
|
|
|
+ return units;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * remove Emulation Prevention bytes from a RBSP
|
|
|
+ */
|
|
|
+
|
|
|
+ }, {
|
|
|
+ key: 'discardEPB',
|
|
|
+ value: function discardEPB(data) {
|
|
|
+ var length = data.byteLength,
|
|
|
+ EPBPositions = [],
|
|
|
+ i = 1,
|
|
|
+ newLength,
|
|
|
+ newData;
|
|
|
+ // Find all `Emulation Prevention Bytes`
|
|
|
+ while (i < length - 2) {
|
|
|
+ if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 0x03) {
|
|
|
+ EPBPositions.push(i + 2);
|
|
|
+ i += 2;
|
|
|
+ } else {
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // If no Emulation Prevention Bytes were found just return the original
|
|
|
+ // array
|
|
|
+ if (EPBPositions.length === 0) {
|
|
|
+ return data;
|
|
|
+ }
|
|
|
+ // Create a new array to hold the NAL unit data
|
|
|
+ newLength = length - EPBPositions.length;
|
|
|
+ newData = new Uint8Array(newLength);
|
|
|
+ var sourceIndex = 0;
|
|
|
+
|
|
|
+ for (i = 0; i < newLength; sourceIndex++, i++) {
|
|
|
+ if (sourceIndex === EPBPositions[0]) {
|
|
|
+ // Skip this byte
|
|
|
+ sourceIndex++;
|
|
|
+ // Remove this position index
|
|
|
+ EPBPositions.shift();
|
|
|
+ }
|
|
|
+ newData[i] = data[sourceIndex];
|
|
|
+ }
|
|
|
+ return newData;
|
|
|
+ }
|
|
|
+ }]);
|
|
|
+
|
|
|
+ return h264Demuxer;
|
|
|
+}(_eventHandler2.default);
|
|
|
+
|
|
|
+exports.default = h264Demuxer;
|
|
|
+
|
|
|
+},{"../errors":7,"../event-handler":8,"../events":9,"../remux/mp4-remuxer":16,"./exp-golomb":5}],7:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+Object.defineProperty(exports, "__esModule", {
|
|
|
+ value: true
|
|
|
+});
|
|
|
+var ErrorTypes = exports.ErrorTypes = {
|
|
|
+ // Identifier for a network error (loading error / timeout ...)
|
|
|
+ NETWORK_ERROR: 'networkError',
|
|
|
+ // Identifier for a media Error (video/parsing/mediasource error)
|
|
|
+ MEDIA_ERROR: 'mediaError',
|
|
|
+ // Identifier for all other errors
|
|
|
+ OTHER_ERROR: 'otherError'
|
|
|
+};
|
|
|
+
|
|
|
+var ErrorDetails = exports.ErrorDetails = {
|
|
|
+ // Identifier for a manifest load error - data: { url : faulty URL, response : { code: error code, text: error text }}
|
|
|
+ MANIFEST_LOAD_ERROR: 'manifestLoadError',
|
|
|
+ // Identifier for a manifest load timeout - data: { url : faulty URL, response : { code: error code, text: error text }}
|
|
|
+ MANIFEST_LOAD_TIMEOUT: 'manifestLoadTimeOut',
|
|
|
+ // Identifier for a manifest parsing error - data: { url : faulty URL, reason : error reason}
|
|
|
+ MANIFEST_PARSING_ERROR: 'manifestParsingError',
|
|
|
+ // Identifier for a manifest with only incompatible codecs error - data: { url : faulty URL, reason : error reason}
|
|
|
+ MANIFEST_INCOMPATIBLE_CODECS_ERROR: 'manifestIncompatibleCodecsError',
|
|
|
+ // Identifier for a level load error - data: { url : faulty URL, response : { code: error code, text: error text }}
|
|
|
+ LEVEL_LOAD_ERROR: 'levelLoadError',
|
|
|
+ // Identifier for a level load timeout - data: { url : faulty URL, response : { code: error code, text: error text }}
|
|
|
+ LEVEL_LOAD_TIMEOUT: 'levelLoadTimeOut',
|
|
|
+ // Identifier for a level switch error - data: { level : faulty level Id, event : error description}
|
|
|
+ LEVEL_SWITCH_ERROR: 'levelSwitchError',
|
|
|
+ // Identifier for an audio track load error - data: { url : faulty URL, response : { code: error code, text: error text }}
|
|
|
+ AUDIO_TRACK_LOAD_ERROR: 'audioTrackLoadError',
|
|
|
+ // Identifier for an audio track load timeout - data: { url : faulty URL, response : { code: error code, text: error text }}
|
|
|
+ AUDIO_TRACK_LOAD_TIMEOUT: 'audioTrackLoadTimeOut',
|
|
|
+ // Identifier for fragment load error - data: { frag : fragment object, response : { code: error code, text: error text }}
|
|
|
+ FRAG_LOAD_ERROR: 'fragLoadError',
|
|
|
+ // Identifier for fragment loop loading error - data: { frag : fragment object}
|
|
|
+ FRAG_LOOP_LOADING_ERROR: 'fragLoopLoadingError',
|
|
|
+ // Identifier for fragment load timeout error - data: { frag : fragment object}
|
|
|
+ FRAG_LOAD_TIMEOUT: 'fragLoadTimeOut',
|
|
|
+ // Identifier for a fragment decryption error event - data: parsing error description
|
|
|
+ FRAG_DECRYPT_ERROR: 'fragDecryptError',
|
|
|
+ // Identifier for a fragment parsing error event - data: parsing error description
|
|
|
+ FRAG_PARSING_ERROR: 'fragParsingError',
|
|
|
+ // Identifier for decrypt key load error - data: { frag : fragment object, response : { code: error code, text: error text }}
|
|
|
+ KEY_LOAD_ERROR: 'keyLoadError',
|
|
|
+ // Identifier for decrypt key load timeout error - data: { frag : fragment object}
|
|
|
+ KEY_LOAD_TIMEOUT: 'keyLoadTimeOut',
|
|
|
+ // Triggered when an exception occurs while adding a sourceBuffer to MediaSource - data : { err : exception , mimeType : mimeType }
|
|
|
+ BUFFER_ADD_CODEC_ERROR: 'bufferAddCodecError',
|
|
|
+ // Identifier for a buffer append error - data: append error description
|
|
|
+ BUFFER_APPEND_ERROR: 'bufferAppendError',
|
|
|
+ // Identifier for a buffer appending error event - data: appending error description
|
|
|
+ BUFFER_APPENDING_ERROR: 'bufferAppendingError',
|
|
|
+ // Identifier for a buffer stalled error event
|
|
|
+ BUFFER_STALLED_ERROR: 'bufferStalledError',
|
|
|
+ // Identifier for a buffer full event
|
|
|
+ BUFFER_FULL_ERROR: 'bufferFullError',
|
|
|
+ // Identifier for a buffer seek over hole event
|
|
|
+ BUFFER_SEEK_OVER_HOLE: 'bufferSeekOverHole',
|
|
|
+ // Identifier for an internal exception happening inside hls.js while handling an event
|
|
|
+ INTERNAL_EXCEPTION: 'internalException'
|
|
|
+};
|
|
|
+
|
|
|
+},{}],8:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+Object.defineProperty(exports, "__esModule", {
|
|
|
+ value: true
|
|
|
+});
|
|
|
+
|
|
|
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
|
|
+
|
|
|
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /*
|
|
|
+ *
|
|
|
+ * All objects in the event handling chain should inherit from this class
|
|
|
+ *
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+var _events = require('./events');
|
|
|
+
|
|
|
+var _events2 = _interopRequireDefault(_events);
|
|
|
+
|
|
|
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
+
|
|
|
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
+
|
|
|
+var EventHandler = function () {
|
|
|
+ function EventHandler(wfs) {
|
|
|
+ _classCallCheck(this, EventHandler);
|
|
|
+
|
|
|
+ this.wfs = wfs;
|
|
|
+ this.onEvent = this.onEvent.bind(this);
|
|
|
+
|
|
|
+ for (var _len = arguments.length, events = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
|
|
+ events[_key - 1] = arguments[_key];
|
|
|
+ }
|
|
|
+
|
|
|
+ this.handledEvents = events;
|
|
|
+ this.useGenericHandler = true;
|
|
|
+
|
|
|
+ this.registerListeners();
|
|
|
+ }
|
|
|
+
|
|
|
+ _createClass(EventHandler, [{
|
|
|
+ key: 'destroy',
|
|
|
+ value: function destroy() {
|
|
|
+ this.unregisterListeners();
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'isEventHandler',
|
|
|
+ value: function isEventHandler() {
|
|
|
+ return _typeof(this.handledEvents) === 'object' && this.handledEvents.length && typeof this.onEvent === 'function';
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'registerListeners',
|
|
|
+ value: function registerListeners() {
|
|
|
+ if (this.isEventHandler()) {
|
|
|
+ this.handledEvents.forEach(function (event) {
|
|
|
+ if (event === 'wfsEventGeneric') {
|
|
|
+ //throw new Error('Forbidden event name: ' + event);
|
|
|
+ }
|
|
|
+ this.wfs.on(event, this.onEvent);
|
|
|
+ }.bind(this));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'unregisterListeners',
|
|
|
+ value: function unregisterListeners() {
|
|
|
+ if (this.isEventHandler()) {
|
|
|
+ this.handledEvents.forEach(function (event) {
|
|
|
+ this.wfs.off(event, this.onEvent);
|
|
|
+ }.bind(this));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * arguments: event (string), data (any)
|
|
|
+ */
|
|
|
+
|
|
|
+ }, {
|
|
|
+ key: 'onEvent',
|
|
|
+ value: function onEvent(event, data) {
|
|
|
+ this.onEventGeneric(event, data);
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'onEventGeneric',
|
|
|
+ value: function onEventGeneric(event, data) {
|
|
|
+ var eventToFunction = function eventToFunction(event, data) {
|
|
|
+ var funcName = 'on' + event.replace('wfs', '');
|
|
|
+ if (typeof this[funcName] !== 'function') {
|
|
|
+ //throw new Error(`Event ${event} has no generic handler in this ${this.constructor.name} class (tried ${funcName})`);
|
|
|
+ }
|
|
|
+ return this[funcName].bind(this, data);
|
|
|
+ };
|
|
|
+ try {
|
|
|
+ eventToFunction.call(this, event, data).call();
|
|
|
+ } catch (err) {
|
|
|
+ console.log('internal error happened while processing ' + event + ':' + err.message);
|
|
|
+ // this.hls.trigger(Event.ERROR, {type: ErrorTypes.OTHER_ERROR, details: ErrorDetails.INTERNAL_EXCEPTION, fatal: false, event : event, err : err});
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }]);
|
|
|
+
|
|
|
+ return EventHandler;
|
|
|
+}();
|
|
|
+
|
|
|
+exports.default = EventHandler;
|
|
|
+
|
|
|
+},{"./events":9}],9:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+module.exports = {
|
|
|
+
|
|
|
+ MEDIA_ATTACHING: 'wfsMediaAttaching',
|
|
|
+
|
|
|
+ MEDIA_ATTACHED: 'wfsMediaAttached',
|
|
|
+
|
|
|
+ FRAG_LOADING: 'wfsFragLoading',
|
|
|
+
|
|
|
+ BUFFER_CREATED: 'wfsBufferCreated',
|
|
|
+
|
|
|
+ BUFFER_APPENDING: 'wfsBufferAppending',
|
|
|
+
|
|
|
+ BUFFER_RESET: 'wfsBufferReset',
|
|
|
+
|
|
|
+ FRAG_PARSING_DATA: 'wfsFragParsingData',
|
|
|
+
|
|
|
+ FRAG_PARSING_INIT_SEGMENT: 'wfsFragParsingInitSegment',
|
|
|
+ //------------------------------------------
|
|
|
+ H264_DATA_PARSING: 'wfsH264DataParsing',
|
|
|
+ //------------------------------------------
|
|
|
+ WEBSOCKET_ATTACHED: 'wfsWebsocketAttached',
|
|
|
+
|
|
|
+ WEBSOCKET_ATTACHING: 'wfsWebsocketAttaching',
|
|
|
+
|
|
|
+ WEBSOCKET_DATA_UPLOADING: 'wfsWebsocketDataUploading',
|
|
|
+
|
|
|
+ WEBSOCKET_MESSAGE_SENDING: 'wfsWebsocketMessageSending',
|
|
|
+ //------------------------------------------
|
|
|
+ FILE_HEAD_LOADING: 'wfsFileHeadLoading',
|
|
|
+
|
|
|
+ FILE_HEAD_LOADED: 'wfsFileHeadLoaded',
|
|
|
+
|
|
|
+ FILE_DATA_LOADING: 'wfsFileDataLoading',
|
|
|
+
|
|
|
+ FILE_DATA_LOADED: 'wfsFileDataLoaded',
|
|
|
+
|
|
|
+ FILE_PARSING_DATA: 'wfsFileParsingData'
|
|
|
+ //------------------------------------------
|
|
|
+
|
|
|
+};
|
|
|
+
|
|
|
+},{}],10:[function(require,module,exports){
|
|
|
+"use strict";
|
|
|
+
|
|
|
+Object.defineProperty(exports, "__esModule", {
|
|
|
+ value: true
|
|
|
+});
|
|
|
+
|
|
|
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
+
|
|
|
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
+
|
|
|
+/**
|
|
|
+ * AAC helper
|
|
|
+ */
|
|
|
+
|
|
|
+var AAC = function () {
|
|
|
+ function AAC() {
|
|
|
+ _classCallCheck(this, AAC);
|
|
|
+ }
|
|
|
+
|
|
|
+ _createClass(AAC, null, [{
|
|
|
+ key: "getSilentFrame",
|
|
|
+ value: function getSilentFrame(channelCount) {
|
|
|
+ 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]);
|
|
|
+ }
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ }]);
|
|
|
+
|
|
|
+ return AAC;
|
|
|
+}();
|
|
|
+
|
|
|
+exports.default = AAC;
|
|
|
+
|
|
|
+},{}],11:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+// This is mostly for support of the es6 module export
|
|
|
+// syntax with the babel compiler, it looks like it doesnt support
|
|
|
+// function exports like we are used to in node/commonjs
|
|
|
+module.exports = require('./wfs.js').default;
|
|
|
+
|
|
|
+},{"./wfs.js":20}],12:[function(require,module,exports){
|
|
|
+(function (process,global){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
|
|
+
|
|
|
+/**
|
|
|
+ * [js-crc]{@link https://github.com/emn178/js-crc}
|
|
|
+ *
|
|
|
+ * @namespace crc
|
|
|
+ * @version 0.2.0
|
|
|
+ * @author Chen, Yi-Cyuan [emn178@gmail.com]
|
|
|
+ * @copyright Chen, Yi-Cyuan 2015-2017
|
|
|
+ * @license MIT
|
|
|
+ */
|
|
|
+/*jslint bitwise: true */
|
|
|
+(function () {
|
|
|
+ 'use strict';
|
|
|
+
|
|
|
+ var root = (typeof window === 'undefined' ? 'undefined' : _typeof(window)) === 'object' ? window : {};
|
|
|
+ var NODE_JS = !root.JS_CRC_NO_NODE_JS && (typeof process === 'undefined' ? 'undefined' : _typeof(process)) === 'object' && process.versions && process.versions.node;
|
|
|
+ if (NODE_JS) {
|
|
|
+ root = global;
|
|
|
+ }
|
|
|
+ var COMMON_JS = !root.JS_CRC_NO_COMMON_JS && (typeof module === 'undefined' ? 'undefined' : _typeof(module)) === 'object' && module.exports;
|
|
|
+ var AMD = typeof define === 'function' && define.amd;
|
|
|
+ var ARRAY_BUFFER = !root.JS_CRC_NO_ARRAY_BUFFER && typeof ArrayBuffer !== 'undefined';
|
|
|
+ var HEX_CHARS = '0123456789abcdef'.split('');
|
|
|
+
|
|
|
+ var Modules = [{
|
|
|
+ name: 'crc32',
|
|
|
+ polynom: 0xEDB88320,
|
|
|
+ initValue: -1,
|
|
|
+ bytes: 4
|
|
|
+ }, {
|
|
|
+ name: 'crc16',
|
|
|
+ polynom: 0xA001,
|
|
|
+ initValue: 0,
|
|
|
+ bytes: 2
|
|
|
+ }];
|
|
|
+
|
|
|
+ var i, j, k, b;
|
|
|
+ for (i = 0; i < Modules.length; ++i) {
|
|
|
+ var m = Modules[i];
|
|
|
+ m.method = function (m) {
|
|
|
+ return function (message) {
|
|
|
+ return crc(message, m);
|
|
|
+ };
|
|
|
+ }(m);
|
|
|
+ m.table = [];
|
|
|
+ for (j = 0; j < 256; ++j) {
|
|
|
+ b = j;
|
|
|
+ for (k = 0; k < 8; ++k) {
|
|
|
+ b = b & 1 ? m.polynom ^ b >>> 1 : b >>> 1;
|
|
|
+ }
|
|
|
+ m.table[j] = b >>> 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var crc = function crc(message, module) {
|
|
|
+ var notString = typeof message !== 'string';
|
|
|
+ if (notString && ARRAY_BUFFER && message instanceof ArrayBuffer) {
|
|
|
+ message = new Uint8Array(message);
|
|
|
+ }
|
|
|
+
|
|
|
+ var crc = module.initValue,
|
|
|
+ code,
|
|
|
+ i,
|
|
|
+ length = message.length,
|
|
|
+ table = module.table;
|
|
|
+ if (notString) {
|
|
|
+ for (i = 0; i < length; ++i) {
|
|
|
+ crc = table[(crc ^ message[i]) & 0xFF] ^ crc >>> 8;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ for (i = 0; i < length; ++i) {
|
|
|
+ code = message.charCodeAt(i);
|
|
|
+ if (code < 0x80) {
|
|
|
+ crc = table[(crc ^ code) & 0xFF] ^ crc >>> 8;
|
|
|
+ } else if (code < 0x800) {
|
|
|
+ crc = table[(crc ^ (0xc0 | code >> 6)) & 0xFF] ^ crc >>> 8;
|
|
|
+ crc = table[(crc ^ (0x80 | code & 0x3f)) & 0xFF] ^ crc >>> 8;
|
|
|
+ } else if (code < 0xd800 || code >= 0xe000) {
|
|
|
+ crc = table[(crc ^ (0xe0 | code >> 12)) & 0xFF] ^ crc >>> 8;
|
|
|
+ crc = table[(crc ^ (0x80 | code >> 6 & 0x3f)) & 0xFF] ^ crc >>> 8;
|
|
|
+ crc = table[(crc ^ (0x80 | code & 0x3f)) & 0xFF] ^ crc >>> 8;
|
|
|
+ } else {
|
|
|
+ code = 0x10000 + ((code & 0x3ff) << 10 | message.charCodeAt(++i) & 0x3ff);
|
|
|
+ crc = table[(crc ^ (0xf0 | code >> 18)) & 0xFF] ^ crc >>> 8;
|
|
|
+ crc = table[(crc ^ (0x80 | code >> 12 & 0x3f)) & 0xFF] ^ crc >>> 8;
|
|
|
+ crc = table[(crc ^ (0x80 | code >> 6 & 0x3f)) & 0xFF] ^ crc >>> 8;
|
|
|
+ crc = table[(crc ^ (0x80 | code & 0x3f)) & 0xFF] ^ crc >>> 8;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ crc ^= module.initValue;
|
|
|
+
|
|
|
+ var hex = '';
|
|
|
+ if (module.bytes > 2) {
|
|
|
+ hex += HEX_CHARS[crc >> 28 & 0x0F] + HEX_CHARS[crc >> 24 & 0x0F] + HEX_CHARS[crc >> 20 & 0x0F] + HEX_CHARS[crc >> 16 & 0x0F];
|
|
|
+ }
|
|
|
+ hex += HEX_CHARS[crc >> 12 & 0x0F] + HEX_CHARS[crc >> 8 & 0x0F] + HEX_CHARS[crc >> 4 & 0x0F] + HEX_CHARS[crc & 0x0F];
|
|
|
+ return hex;
|
|
|
+ };
|
|
|
+
|
|
|
+ var exports = {};
|
|
|
+ for (i = 0; i < Modules.length; ++i) {
|
|
|
+ var m = Modules[i];
|
|
|
+ exports[m.name] = m.method;
|
|
|
+ }
|
|
|
+ if (COMMON_JS) {
|
|
|
+ module.exports = exports;
|
|
|
+ } else {
|
|
|
+ for (i = 0; i < Modules.length; ++i) {
|
|
|
+ var m = Modules[i];
|
|
|
+ root[m.name] = m.method;
|
|
|
+ }
|
|
|
+ if (AMD) {
|
|
|
+ define(function () {
|
|
|
+ return exports;
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+})();
|
|
|
+
|
|
|
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
|
+
|
|
|
+},{"_process":2}],13:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+Object.defineProperty(exports, "__esModule", {
|
|
|
+ value: true
|
|
|
+});
|
|
|
+
|
|
|
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
+
|
|
|
+var _events = require('../events');
|
|
|
+
|
|
|
+var _events2 = _interopRequireDefault(_events);
|
|
|
+
|
|
|
+var _eventHandler = require('../event-handler');
|
|
|
+
|
|
|
+var _eventHandler2 = _interopRequireDefault(_eventHandler);
|
|
|
+
|
|
|
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
+
|
|
|
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
+
|
|
|
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
+
|
|
|
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /*
|
|
|
+ * File Loader
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+var FileLoader = function (_EventHandler) {
|
|
|
+ _inherits(FileLoader, _EventHandler);
|
|
|
+
|
|
|
+ function FileLoader(wfs) {
|
|
|
+ _classCallCheck(this, FileLoader);
|
|
|
+
|
|
|
+ var _this = _possibleConstructorReturn(this, (FileLoader.__proto__ || Object.getPrototypeOf(FileLoader)).call(this, wfs, _events2.default.FRAG_LOADING, _events2.default.FILE_HEAD_LOADING, _events2.default.FILE_DATA_LOADING));
|
|
|
+
|
|
|
+ _this.loaders = {};
|
|
|
+ return _this;
|
|
|
+ }
|
|
|
+
|
|
|
+ _createClass(FileLoader, [{
|
|
|
+ key: 'destroy',
|
|
|
+ value: function destroy() {
|
|
|
+ for (var loaderName in this.loaders) {
|
|
|
+ var loader = this.loaders[loaderName];
|
|
|
+ if (loader) {
|
|
|
+ loader.destroy();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ this.loaders = {};
|
|
|
+ _eventHandler2.default.prototype.destroy.call(this);
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'onFileHeadLoading',
|
|
|
+ value: function onFileHeadLoading(data) {
|
|
|
+ var config = this.wfs.config;
|
|
|
+ var loader = new config.loader(config);
|
|
|
+ var loaderContext = void 0,
|
|
|
+ loaderConfig = void 0,
|
|
|
+ loaderCallbacks = void 0;
|
|
|
+ loaderContext = { url: config.fmp4FileUrl };
|
|
|
+ loaderConfig = { maxRetry: 0, retryDelay: 0 };
|
|
|
+ loaderCallbacks = { onSuccess: this.fileloadheadsuccess.bind(this) };
|
|
|
+ loader.loadHead(loaderContext, loaderConfig, loaderCallbacks);
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'fileloadheadsuccess',
|
|
|
+ value: function fileloadheadsuccess(response) {
|
|
|
+ this.wfs.trigger(_events2.default.FILE_HEAD_LOADED, { size: response });
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'onFileDataLoading',
|
|
|
+ value: function onFileDataLoading(data) {
|
|
|
+ var config = this.wfs.config;
|
|
|
+ var loader = new config.loader(config);
|
|
|
+ var loaderContext = void 0,
|
|
|
+ loaderConfig = void 0,
|
|
|
+ loaderCallbacks = void 0;
|
|
|
+ loaderContext = { url: config.fmp4FileUrl, responseType: 'arraybuffer', progressData: false };
|
|
|
+ var start = data.fileStart,
|
|
|
+ end = data.fileEnd;
|
|
|
+ if (!isNaN(start) && !isNaN(end)) {
|
|
|
+ loaderContext.rangeStart = start;
|
|
|
+ loaderContext.rangeEnd = end;
|
|
|
+ }
|
|
|
+ loaderConfig = { timeout: config.fragLoadingTimeOut, maxRetry: 0, retryDelay: 0, maxRetryDelay: config.fragLoadingMaxRetryTimeout };
|
|
|
+ loaderCallbacks = { onSuccess: this.fileloaddatasuccess.bind(this) };
|
|
|
+ loader.load(loaderContext, loaderConfig, loaderCallbacks);
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'fileloaddatasuccess',
|
|
|
+ value: function fileloaddatasuccess(response, stats, context) {
|
|
|
+ this.wfs.trigger(_events2.default.FILE_DATA_LOADED, { payload: response.data, stats: stats });
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'loaderror',
|
|
|
+ value: function loaderror(response, context) {
|
|
|
+ var loader = context.loader;
|
|
|
+ if (loader) {
|
|
|
+ loader.abort();
|
|
|
+ }
|
|
|
+ this.loaders[context.type] = undefined;
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'loadtimeout',
|
|
|
+ value: function loadtimeout(stats, context) {
|
|
|
+ var loader = context.loader;
|
|
|
+ if (loader) {
|
|
|
+ loader.abort();
|
|
|
+ }
|
|
|
+ this.loaders[context.type] = undefined;
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'loadprogress',
|
|
|
+ value: function loadprogress(stats, context, data) {
|
|
|
+ var frag = context.frag;
|
|
|
+ frag.loaded = stats.loaded;
|
|
|
+ }
|
|
|
+ }]);
|
|
|
+
|
|
|
+ return FileLoader;
|
|
|
+}(_eventHandler2.default);
|
|
|
+
|
|
|
+exports.default = FileLoader;
|
|
|
+
|
|
|
+},{"../event-handler":8,"../events":9}],14:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+Object.defineProperty(exports, "__esModule", {
|
|
|
+ value: true
|
|
|
+});
|
|
|
+
|
|
|
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
+
|
|
|
+var _events = require('../events');
|
|
|
+
|
|
|
+var _events2 = _interopRequireDefault(_events);
|
|
|
+
|
|
|
+var _eventHandler = require('../event-handler');
|
|
|
+
|
|
|
+var _eventHandler2 = _interopRequireDefault(_eventHandler);
|
|
|
+
|
|
|
+var _h264Demuxer = require('../demux/h264-demuxer');
|
|
|
+
|
|
|
+var _h264Demuxer2 = _interopRequireDefault(_h264Demuxer);
|
|
|
+
|
|
|
+var _crc = require('./crc.js');
|
|
|
+
|
|
|
+var _crc2 = _interopRequireDefault(_crc);
|
|
|
+
|
|
|
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
+
|
|
|
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
+
|
|
|
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
+
|
|
|
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /*
|
|
|
+ * Websocket Loader
|
|
|
+ */
|
|
|
+
|
|
|
+var WebsocketLoader = function (_EventHandler) {
|
|
|
+ _inherits(WebsocketLoader, _EventHandler);
|
|
|
+
|
|
|
+ function WebsocketLoader(wfs) {
|
|
|
+ _classCallCheck(this, WebsocketLoader);
|
|
|
+
|
|
|
+ var _this = _possibleConstructorReturn(this, (WebsocketLoader.__proto__ || Object.getPrototypeOf(WebsocketLoader)).call(this, wfs, _events2.default.WEBSOCKET_ATTACHING, _events2.default.WEBSOCKET_DATA_UPLOADING, _events2.default.WEBSOCKET_MESSAGE_SENDING));
|
|
|
+
|
|
|
+ _this.buf = null;
|
|
|
+ _this.h264Demuxer = new _h264Demuxer2.default(wfs);
|
|
|
+ _this.mediaType = undefined;
|
|
|
+ _this.channelName = undefined;
|
|
|
+ _this.onVideoFrame = null;
|
|
|
+ return _this;
|
|
|
+ }
|
|
|
+
|
|
|
+ _createClass(WebsocketLoader, [{
|
|
|
+ key: 'destroy',
|
|
|
+ value: function destroy() {
|
|
|
+ !!this.client && this.client.close();
|
|
|
+ _eventHandler2.default.prototype.destroy.call(this);
|
|
|
+ this.h264Demuxer.destroy();
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'onWebsocketAttaching',
|
|
|
+ value: function onWebsocketAttaching(data) {
|
|
|
+ this.mediaType = data.mediaType;
|
|
|
+ this.channelName = data.channelName;
|
|
|
+ this.deviceId = data.deviceId;
|
|
|
+ this.clientid = data.clientid;
|
|
|
+ this.loginHandle = data.loginHandle;
|
|
|
+ this.sessiontype = data.sessiontype;
|
|
|
+ this.begintime = data.begintime;
|
|
|
+ if (data.websocket instanceof WebSocket) {
|
|
|
+ this.client = data.websocket;
|
|
|
+ this.client.onopen = this.initSocketClient.bind(this);
|
|
|
+ this.client.onclose = function (e) {
|
|
|
+ console.log('Websocket Disconnected!');
|
|
|
+ };
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'initSocketClient',
|
|
|
+ value: function initSocketClient(client) {
|
|
|
+ this.client.binaryType = 'arraybuffer';
|
|
|
+ this.client.onmessage = this.receiveSocketMessage.bind(this);
|
|
|
+ this.wfs.trigger(_events2.default.WEBSOCKET_MESSAGE_SENDING, { commandType: "open", channelName: this.channelName, commandValue: "NA", deviceId: this.deviceId, clientid: this.clientid, loginHandle: this.loginHandle, sessiontype: this.sessiontype, begintime: this.begintime});
|
|
|
+ console.log('Websocket Open!');
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'receiveSocketMessage',
|
|
|
+ value: function receiveSocketMessage(event) {
|
|
|
+ // var buffer = new Uint8Array(event.data);
|
|
|
+ // console.log(buffer.length);
|
|
|
+ // var newBuffer;
|
|
|
+ // if (this.buf) {
|
|
|
+ // newBuffer = new Uint8Array(this.buf.byteLength + buffer.byteLength);
|
|
|
+ // newBuffer.set(this.buf);
|
|
|
+ // newBuffer.set(buffer, this.buf.byteLength);
|
|
|
+ // console.log("newBuffer.length:"+newBuffer.length);
|
|
|
+ // } else newBuffer = new Uint8Array(buffer);
|
|
|
+ // //get len
|
|
|
+ // var offset = 0;
|
|
|
+ // var lenView = new DataView(newBuffer.buffer);
|
|
|
+ // console.log(lenView);
|
|
|
+ // var len;
|
|
|
+ // if(lenView.byteLength == 0){
|
|
|
+ // len = 0;
|
|
|
+ // }else{
|
|
|
+ // len = lenView.getUint32(0);
|
|
|
+ // }
|
|
|
+ // console.log("len:"+len+",newBuffer:"+(newBuffer.byteLength - 4));
|
|
|
+ // while (len < newBuffer.byteLength - 4) {
|
|
|
+ // console.log("frames, len:" + len);
|
|
|
+ // var copy = newBuffer.subarray(4, len + 4);
|
|
|
+ // console.log(copy);
|
|
|
+ // this.wfs.trigger(_events2.default.H264_DATA_PARSING, { data: copy });
|
|
|
+ // //var copy2 = new Uint8Array(0);
|
|
|
+ // //this.wfs.trigger(Event.H264_DATA_PARSING, {data: copy2});
|
|
|
+ // //this.wfs.trigger(Event.H264_DATA_PARSING, {data: copy2});
|
|
|
+ // newBuffer = newBuffer.subarray(len + 4);
|
|
|
+ // offset += len + 4;
|
|
|
+ // len = lenView.getUint32(offset);
|
|
|
+ // //get len
|
|
|
+ // }
|
|
|
+ // if (len === newBuffer.byteLength - 4) {
|
|
|
+ // var copy = newBuffer.subarray(4, len + 4);
|
|
|
+ // this.wfs.trigger(_events2.default.H264_DATA_PARSING, { data: copy });
|
|
|
+ // //var copy2 = new Uint8Array(0);
|
|
|
+ // //this.wfs.trigger(Event.H264_DATA_PARSING,{data:copy2});
|
|
|
+ // //this.wfs.trigger(Event.H264_DATA_PARSING,{data:copy2});
|
|
|
+ // this.buf = null;
|
|
|
+ // } else this.buf = new Uint8Array(newBuffer);
|
|
|
+
|
|
|
+ // }
|
|
|
+ /****************************************************/
|
|
|
+ if(this.onVideoFrame && typeof(event.data) == "object"){
|
|
|
+ this.onVideoFrame(event.data);
|
|
|
+ }
|
|
|
+ this.buf = new Uint8Array(event.data);
|
|
|
+ var copy = new Uint8Array(this.buf);
|
|
|
+ if (this.mediaType === 'FMp4') {
|
|
|
+ this.wfs.trigger(_events2.default.WEBSOCKET_ATTACHED, { payload: copy });
|
|
|
+ }
|
|
|
+ if (this.mediaType === 'H264Raw') {
|
|
|
+ this.wfs.trigger(_events2.default.H264_DATA_PARSING, { data: copy });
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'onWebsocketDataUploading',
|
|
|
+ value: function onWebsocketDataUploading(event) {
|
|
|
+ this.client.send(event.data);
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'onWebsocketMessageSending',
|
|
|
+ value: function onWebsocketMessageSending(event) {
|
|
|
+ // this.client.send(JSON.stringify({ t: event.commandType, c: event.channelName, v: event.commandValue }));
|
|
|
+ var sendMsg = event.sessiontype == "video" ? "" : event.begintime.toString();
|
|
|
+ this.client.send( JSON.stringify({cmd: "register", clientid: event.clientid,deviceId: parseInt(event.deviceId),loginHandle: parseInt(event.loginHandle), msg: sendMsg,sessiontype: event.sessiontype}) );
|
|
|
+ }
|
|
|
+ }]);
|
|
|
+
|
|
|
+ return WebsocketLoader;
|
|
|
+}(_eventHandler2.default);
|
|
|
+
|
|
|
+exports.default = WebsocketLoader;
|
|
|
+
|
|
|
+},{"../demux/h264-demuxer":6,"../event-handler":8,"../events":9,"./crc.js":12}],15:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+Object.defineProperty(exports, "__esModule", {
|
|
|
+ value: true
|
|
|
+});
|
|
|
+
|
|
|
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
+
|
|
|
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
+
|
|
|
+/**
|
|
|
+ * Generate MP4 Box
|
|
|
+*/
|
|
|
+
|
|
|
+//import Hex from '../utils/hex';
|
|
|
+var MP4 = function () {
|
|
|
+ function MP4() {
|
|
|
+ _classCallCheck(this, MP4);
|
|
|
+ }
|
|
|
+
|
|
|
+ _createClass(MP4, null, [{
|
|
|
+ key: 'init',
|
|
|
+ value: function init() {
|
|
|
+ MP4.types = {
|
|
|
+ avc1: [], // codingname
|
|
|
+ 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: []
|
|
|
+ };
|
|
|
+
|
|
|
+ var i;
|
|
|
+ for (i in MP4.types) {
|
|
|
+ if (MP4.types.hasOwnProperty(i)) {
|
|
|
+ MP4.types[i] = [i.charCodeAt(0), i.charCodeAt(1), i.charCodeAt(2), i.charCodeAt(3)];
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var videoHdlr = new Uint8Array([0x00, // version 0
|
|
|
+ 0x00, 0x00, 0x00, // flags
|
|
|
+ 0x00, 0x00, 0x00, 0x00, // pre_defined
|
|
|
+ 0x76, 0x69, 0x64, 0x65, // handler_type: 'vide'
|
|
|
+ 0x00, 0x00, 0x00, 0x00, // reserved
|
|
|
+ 0x00, 0x00, 0x00, 0x00, // reserved
|
|
|
+ 0x00, 0x00, 0x00, 0x00, // reserved
|
|
|
+ 0x56, 0x69, 0x64, 0x65, 0x6f, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x00 // name: 'VideoHandler'
|
|
|
+ ]);
|
|
|
+
|
|
|
+ var audioHdlr = new Uint8Array([0x00, // version 0
|
|
|
+ 0x00, 0x00, 0x00, // flags
|
|
|
+ 0x00, 0x00, 0x00, 0x00, // pre_defined
|
|
|
+ 0x73, 0x6f, 0x75, 0x6e, // handler_type: 'soun'
|
|
|
+ 0x00, 0x00, 0x00, 0x00, // reserved
|
|
|
+ 0x00, 0x00, 0x00, 0x00, // reserved
|
|
|
+ 0x00, 0x00, 0x00, 0x00, // reserved
|
|
|
+ 0x53, 0x6f, 0x75, 0x6e, 0x64, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x00 // name: 'SoundHandler'
|
|
|
+ ]);
|
|
|
+
|
|
|
+ MP4.HDLR_TYPES = {
|
|
|
+ 'video': videoHdlr,
|
|
|
+ 'audio': audioHdlr
|
|
|
+ };
|
|
|
+
|
|
|
+ var dref = new Uint8Array([0x00, // version 0
|
|
|
+ 0x00, 0x00, 0x00, // flags
|
|
|
+ 0x00, 0x00, 0x00, 0x01, // entry_count
|
|
|
+ 0x00, 0x00, 0x00, 0x0c, // entry_size
|
|
|
+ 0x75, 0x72, 0x6c, 0x20, // 'url' type
|
|
|
+ 0x00, // version 0
|
|
|
+ 0x00, 0x00, 0x01 // entry_flags
|
|
|
+ ]);
|
|
|
+
|
|
|
+ var stco = new Uint8Array([0x00, // version
|
|
|
+ 0x00, 0x00, 0x00, // flags
|
|
|
+ 0x00, 0x00, 0x00, 0x00 // entry_count
|
|
|
+ ]);
|
|
|
+
|
|
|
+ MP4.STTS = MP4.STSC = MP4.STCO = stco;
|
|
|
+
|
|
|
+ MP4.STSZ = new Uint8Array([0x00, // version
|
|
|
+ 0x00, 0x00, 0x00, // flags
|
|
|
+ 0x00, 0x00, 0x00, 0x00, // sample_size
|
|
|
+ 0x00, 0x00, 0x00, 0x00]);
|
|
|
+ MP4.VMHD = new Uint8Array([0x00, // version
|
|
|
+ 0x00, 0x00, 0x01, // flags
|
|
|
+ 0x00, 0x00, // graphicsmode
|
|
|
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // opcolor
|
|
|
+ ]);
|
|
|
+ MP4.SMHD = new Uint8Array([0x00, // version
|
|
|
+ 0x00, 0x00, 0x00, // flags
|
|
|
+ 0x00, 0x00, // balance
|
|
|
+ 0x00, 0x00 // reserved
|
|
|
+ ]);
|
|
|
+
|
|
|
+ MP4.STSD = new Uint8Array([0x00, // version 0
|
|
|
+ 0x00, 0x00, 0x00, // flags
|
|
|
+ 0x00, 0x00, 0x00, 0x01]); // entry_count
|
|
|
+
|
|
|
+ var majorBrand = new Uint8Array([105, 115, 111, 109]); // isom
|
|
|
+ var avc1Brand = new Uint8Array([97, 118, 99, 49]); // avc1
|
|
|
+ var minorVersion = new Uint8Array([0, 0, 0, 1]);
|
|
|
+
|
|
|
+ MP4.FTYP = MP4.box(MP4.types.ftyp, majorBrand, minorVersion, majorBrand, avc1Brand);
|
|
|
+ MP4.DINF = MP4.box(MP4.types.dinf, MP4.box(MP4.types.dref, dref));
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'box',
|
|
|
+ value: function box(type) {
|
|
|
+ var payload = Array.prototype.slice.call(arguments, 1),
|
|
|
+ size = 8,
|
|
|
+ i = payload.length,
|
|
|
+ len = i,
|
|
|
+ result;
|
|
|
+ // calculate the total size we need to allocate
|
|
|
+ while (i--) {
|
|
|
+ size += payload[i].byteLength;
|
|
|
+ }
|
|
|
+ result = new Uint8Array(size);
|
|
|
+ result[0] = size >> 24 & 0xff;
|
|
|
+ result[1] = size >> 16 & 0xff;
|
|
|
+ result[2] = size >> 8 & 0xff;
|
|
|
+ result[3] = size & 0xff;
|
|
|
+ result.set(type, 4);
|
|
|
+ // copy the payload into the result
|
|
|
+ for (i = 0, size = 8; i < len; i++) {
|
|
|
+ // copy payload[i] array @ offset size
|
|
|
+ result.set(payload[i], size);
|
|
|
+ size += payload[i].byteLength;
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'hdlr',
|
|
|
+ value: function hdlr(type) {
|
|
|
+ return MP4.box(MP4.types.hdlr, MP4.HDLR_TYPES[type]);
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'mdat',
|
|
|
+ value: function mdat(data) {
|
|
|
+ // console.log( "mdat==> ",data.length );
|
|
|
+ return MP4.box(MP4.types.mdat, data);
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'mdhd',
|
|
|
+ value: function mdhd(timescale, duration) {
|
|
|
+ duration *= timescale;
|
|
|
+ return MP4.box(MP4.types.mdhd, new Uint8Array([0x00, // version 0
|
|
|
+ 0x00, 0x00, 0x00, // flags
|
|
|
+ 0x00, 0x00, 0x00, 0x02, // creation_time
|
|
|
+ 0x00, 0x00, 0x00, 0x03, // modification_time
|
|
|
+ timescale >> 24 & 0xFF, timescale >> 16 & 0xFF, timescale >> 8 & 0xFF, timescale & 0xFF, // timescale
|
|
|
+ duration >> 24, duration >> 16 & 0xFF, duration >> 8 & 0xFF, duration & 0xFF, // duration
|
|
|
+ 0x55, 0xc4, // 'und' language (undetermined)
|
|
|
+ 0x00, 0x00]));
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'mdia',
|
|
|
+ value: function mdia(track) {
|
|
|
+ return MP4.box(MP4.types.mdia, MP4.mdhd(track.timescale, track.duration), MP4.hdlr(track.type), MP4.minf(track));
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'mfhd',
|
|
|
+ value: function mfhd(sequenceNumber) {
|
|
|
+ return MP4.box(MP4.types.mfhd, new Uint8Array([0x00, 0x00, 0x00, 0x00, // flags
|
|
|
+ sequenceNumber >> 24, sequenceNumber >> 16 & 0xFF, sequenceNumber >> 8 & 0xFF, sequenceNumber & 0xFF]) // sequence_number
|
|
|
+ );
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'minf',
|
|
|
+ value: function minf(track) {
|
|
|
+ if (track.type === 'audio') {
|
|
|
+ return MP4.box(MP4.types.minf, MP4.box(MP4.types.smhd, MP4.SMHD), MP4.DINF, MP4.stbl(track));
|
|
|
+ } else {
|
|
|
+ return MP4.box(MP4.types.minf, MP4.box(MP4.types.vmhd, MP4.VMHD), MP4.DINF, MP4.stbl(track));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'moof',
|
|
|
+ value: function moof(sn, baseMediaDecodeTime, track) {
|
|
|
+ return MP4.box(MP4.types.moof, MP4.mfhd(sn), MP4.traf(track, baseMediaDecodeTime));
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * @param tracks... (optional) {array} the tracks associated with this movie
|
|
|
+ */
|
|
|
+
|
|
|
+ }, {
|
|
|
+ key: 'moov',
|
|
|
+ value: function moov(tracks) {
|
|
|
+ var i = tracks.length,
|
|
|
+ boxes = [];
|
|
|
+
|
|
|
+ while (i--) {
|
|
|
+ boxes[i] = MP4.trak(tracks[i]);
|
|
|
+ }
|
|
|
+
|
|
|
+ return MP4.box.apply(null, [MP4.types.moov, MP4.mvhd(tracks[0].timescale, tracks[0].duration)].concat(boxes).concat(MP4.mvex(tracks)));
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'mvex',
|
|
|
+ value: function mvex(tracks) {
|
|
|
+ var i = tracks.length,
|
|
|
+ boxes = [];
|
|
|
+
|
|
|
+ while (i--) {
|
|
|
+ boxes[i] = MP4.trex(tracks[i]);
|
|
|
+ }
|
|
|
+ return MP4.box.apply(null, [MP4.types.mvex].concat(boxes));
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'mvhd',
|
|
|
+ value: function mvhd(timescale, duration) {
|
|
|
+ //duration*=timescale;
|
|
|
+ duration = 0;
|
|
|
+ var bytes = new Uint8Array([0x00, // version 0
|
|
|
+ 0x00, 0x00, 0x00, // flags
|
|
|
+ 0x00, 0x00, 0x00, 0x01, // creation_time
|
|
|
+ 0x00, 0x00, 0x00, 0x02, // modification_time
|
|
|
+ timescale >> 24 & 0xFF, timescale >> 16 & 0xFF, timescale >> 8 & 0xFF, timescale & 0xFF, // timescale
|
|
|
+ duration >> 24 & 0xFF, duration >> 16 & 0xFF, duration >> 8 & 0xFF, duration & 0xFF, // duration
|
|
|
+ 0x00, 0x01, 0x00, 0x00, // 1.0 rate
|
|
|
+ 0x01, 0x00, // 1.0 volume
|
|
|
+ 0x00, 0x00, // reserved
|
|
|
+ 0x00, 0x00, 0x00, 0x00, // reserved
|
|
|
+ 0x00, 0x00, 0x00, 0x00, // reserved
|
|
|
+ 0x00, 0x01, 0x00, 0x00, 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, // transformation: unity matrix
|
|
|
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // pre_defined
|
|
|
+ 0xff, 0xff, 0xff, 0xff // next_track_ID
|
|
|
+ ]);
|
|
|
+ return MP4.box(MP4.types.mvhd, bytes);
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'sdtp',
|
|
|
+ value: function sdtp(track) {
|
|
|
+ var samples = track.samples || [],
|
|
|
+ bytes = new Uint8Array(4 + samples.length),
|
|
|
+ flags,
|
|
|
+ i;
|
|
|
+ // leave the full box header (4 bytes) all zero
|
|
|
+ // write the sample table
|
|
|
+ for (i = 0; i < samples.length; i++) {
|
|
|
+ flags = samples[i].flags;
|
|
|
+ bytes[i + 4] = flags.dependsOn << 4 | flags.isDependedOn << 2 | flags.hasRedundancy;
|
|
|
+ }
|
|
|
+
|
|
|
+ return MP4.box(MP4.types.sdtp, bytes);
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'stbl',
|
|
|
+ value: function stbl(track) {
|
|
|
+ return MP4.box(MP4.types.stbl, MP4.stsd(track), MP4.box(MP4.types.stts, MP4.STTS), MP4.box(MP4.types.stsc, MP4.STSC), MP4.box(MP4.types.stsz, MP4.STSZ), MP4.box(MP4.types.stco, MP4.STCO));
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'avc1',
|
|
|
+ value: function avc1(track) {
|
|
|
+ var sps = [],
|
|
|
+ pps = [],
|
|
|
+ i,
|
|
|
+ data,
|
|
|
+ len;
|
|
|
+ // assemble the SPSs
|
|
|
+
|
|
|
+ for (i = 0; i < track.sps.length; i++) {
|
|
|
+ data = track.sps[i];
|
|
|
+ len = data.byteLength;
|
|
|
+ sps.push(len >>> 8 & 0xFF);
|
|
|
+ sps.push(len & 0xFF);
|
|
|
+ sps = sps.concat(Array.prototype.slice.call(data)); // SPS
|
|
|
+ }
|
|
|
+
|
|
|
+ // assemble the PPSs
|
|
|
+ for (i = 0; i < track.pps.length; i++) {
|
|
|
+ data = track.pps[i];
|
|
|
+ len = data.byteLength;
|
|
|
+ pps.push(len >>> 8 & 0xFF);
|
|
|
+ pps.push(len & 0xFF);
|
|
|
+ pps = pps.concat(Array.prototype.slice.call(data));
|
|
|
+ }
|
|
|
+
|
|
|
+ var avcc = MP4.box(MP4.types.avcC, new Uint8Array([0x01, // version
|
|
|
+ sps[3], // profile
|
|
|
+ sps[4], // profile compat
|
|
|
+ sps[5], // level
|
|
|
+ 0xfc | 3, // lengthSizeMinusOne, hard-coded to 4 bytes
|
|
|
+ 0xE0 | track.sps.length // 3bit reserved (111) + numOfSequenceParameterSets
|
|
|
+ ].concat(sps).concat([track.pps.length // numOfPictureParameterSets
|
|
|
+ ]).concat(pps))),
|
|
|
+ // "PPS"
|
|
|
+ width = track.width,
|
|
|
+ height = track.height;
|
|
|
+ //console.log('avcc:' + Hex.hexDump(avcc));
|
|
|
+ return MP4.box(MP4.types.avc1, new Uint8Array([0x00, 0x00, 0x00, // reserved
|
|
|
+ 0x00, 0x00, 0x00, // reserved
|
|
|
+ 0x00, 0x01, // data_reference_index
|
|
|
+ 0x00, 0x00, // pre_defined
|
|
|
+ 0x00, 0x00, // reserved
|
|
|
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // pre_defined
|
|
|
+ width >> 8 & 0xFF, width & 0xff, // width
|
|
|
+ height >> 8 & 0xFF, height & 0xff, // height
|
|
|
+ 0x00, 0x48, 0x00, 0x00, // horizresolution
|
|
|
+ 0x00, 0x48, 0x00, 0x00, // vertresolution
|
|
|
+ 0x00, 0x00, 0x00, 0x00, // reserved
|
|
|
+ 0x00, 0x01, // frame_count
|
|
|
+ 0x12, 0x6a, 0x65, 0x66, 0x66, // wfs.js
|
|
|
+ 0x2d, 0x79, 0x61, 0x6e, 0x2f, 0x2f, 0x2f, 0x67, 0x77, 0x66, 0x73, 0x2E, 0x6A, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // compressorname
|
|
|
+ 0x00, 0x18, // depth = 24
|
|
|
+ 0x11, 0x11]), // pre_defined = -1
|
|
|
+ avcc, MP4.box(MP4.types.btrt, new Uint8Array([0x00, 0x1c, 0x9c, 0x80, // bufferSizeDB
|
|
|
+ 0x00, 0x2d, 0xc6, 0xc0, // maxBitrate
|
|
|
+ 0x00, 0x2d, 0xc6, 0xc0])) // avgBitrate
|
|
|
+ );
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'esds',
|
|
|
+ value: function esds(track) {
|
|
|
+ var configlen = track.config.length;
|
|
|
+ return new Uint8Array([0x00, // version 0
|
|
|
+ 0x00, 0x00, 0x00, // flags
|
|
|
+
|
|
|
+ 0x03, // descriptor_type
|
|
|
+ 0x17 + configlen, // length
|
|
|
+ 0x00, 0x01, //es_id
|
|
|
+ 0x00, // stream_priority
|
|
|
+
|
|
|
+ 0x04, // descriptor_type
|
|
|
+ 0x0f + configlen, // length
|
|
|
+ 0x40, //codec : mpeg4_audio
|
|
|
+ 0x15, // stream_type
|
|
|
+ 0x00, 0x00, 0x00, // buffer_size
|
|
|
+ 0x00, 0x00, 0x00, 0x00, // maxBitrate
|
|
|
+ 0x00, 0x00, 0x00, 0x00, // avgBitrate
|
|
|
+
|
|
|
+ 0x05 // descriptor_type
|
|
|
+ ].concat([configlen]).concat(track.config).concat([0x06, 0x01, 0x02])); // GASpecificConfig)); // length + audio config descriptor
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'mp4a',
|
|
|
+ value: function mp4a(track) {
|
|
|
+ var audiosamplerate = track.audiosamplerate;
|
|
|
+ return MP4.box(MP4.types.mp4a, new Uint8Array([0x00, 0x00, 0x00, // reserved
|
|
|
+ 0x00, 0x00, 0x00, // reserved
|
|
|
+ 0x00, 0x01, // data_reference_index
|
|
|
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // reserved
|
|
|
+ 0x00, track.channelCount, // channelcount
|
|
|
+ 0x00, 0x10, // sampleSize:16bits
|
|
|
+ 0x00, 0x00, 0x00, 0x00, // reserved2
|
|
|
+ audiosamplerate >> 8 & 0xFF, audiosamplerate & 0xff, //
|
|
|
+ 0x00, 0x00]), MP4.box(MP4.types.esds, MP4.esds(track)));
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'stsd',
|
|
|
+ value: function stsd(track) {
|
|
|
+ if (track.type === 'audio') {
|
|
|
+ return MP4.box(MP4.types.stsd, MP4.STSD, MP4.mp4a(track));
|
|
|
+ } else {
|
|
|
+ return MP4.box(MP4.types.stsd, MP4.STSD, MP4.avc1(track));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'tkhd',
|
|
|
+ value: function tkhd(track) {
|
|
|
+ var id = track.id,
|
|
|
+ duration = track.duration * track.timescale,
|
|
|
+ width = track.width,
|
|
|
+ height = track.height;
|
|
|
+
|
|
|
+ // console.log( "tkhd==> ",track.id, track.duration, track.timescale, width,height );
|
|
|
+
|
|
|
+ return MP4.box(MP4.types.tkhd, new Uint8Array([0x00, // version 0
|
|
|
+ 0x00, 0x00, 0x07, // flags
|
|
|
+ 0x00, 0x00, 0x00, 0x00, // creation_time
|
|
|
+ 0x00, 0x00, 0x00, 0x00, // modification_time
|
|
|
+ id >> 24 & 0xFF, id >> 16 & 0xFF, id >> 8 & 0xFF, id & 0xFF, // track_ID
|
|
|
+ 0x00, 0x00, 0x00, 0x00, // reserved
|
|
|
+ duration >> 24, duration >> 16 & 0xFF, duration >> 8 & 0xFF, duration & 0xFF, // duration
|
|
|
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // reserved
|
|
|
+ 0x00, 0x00, // layer
|
|
|
+ 0x00, 0x00, // alternate_group
|
|
|
+ 0x00, 0x00, // non-audio track volume
|
|
|
+ 0x00, 0x00, // reserved
|
|
|
+ 0x00, 0x01, 0x00, 0x00, 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, // transformation: unity matrix
|
|
|
+ width >> 8 & 0xFF, width & 0xFF, 0x00, 0x00, // width
|
|
|
+ height >> 8 & 0xFF, height & 0xFF, 0x00, 0x00 // height
|
|
|
+ ]));
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'traf',
|
|
|
+ value: function traf(track, baseMediaDecodeTime) {
|
|
|
+ var sampleDependencyTable = MP4.sdtp(track),
|
|
|
+ id = track.id;
|
|
|
+
|
|
|
+ // console.log( "traf==> ",id ,baseMediaDecodeTime);
|
|
|
+
|
|
|
+ return MP4.box(MP4.types.traf, MP4.box(MP4.types.tfhd, new Uint8Array([0x00, // version 0
|
|
|
+ 0x00, 0x00, 0x00, // flags
|
|
|
+ id >> 24, id >> 16 & 0XFF, id >> 8 & 0XFF, id & 0xFF]) // track_ID
|
|
|
+ ), MP4.box(MP4.types.tfdt, new Uint8Array([0x00, // version 0
|
|
|
+ 0x00, 0x00, 0x00, // flags
|
|
|
+ baseMediaDecodeTime >> 24, baseMediaDecodeTime >> 16 & 0XFF, baseMediaDecodeTime >> 8 & 0XFF, baseMediaDecodeTime & 0xFF]) // baseMediaDecodeTime
|
|
|
+ ), MP4.trun(track, sampleDependencyTable.length + 16 + // tfhd
|
|
|
+ 16 + // tfdt
|
|
|
+ 8 + // traf header
|
|
|
+ 16 + // mfhd
|
|
|
+ 8 + // moof header
|
|
|
+ 8), // mdat header
|
|
|
+ sampleDependencyTable);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Generate a track box.
|
|
|
+ * @param track {object} a track definition
|
|
|
+ * @return {Uint8Array} the track box
|
|
|
+ */
|
|
|
+
|
|
|
+ }, {
|
|
|
+ key: 'trak',
|
|
|
+ value: function trak(track) {
|
|
|
+ track.duration = track.duration || 0xffffffff;
|
|
|
+ return MP4.box(MP4.types.trak, MP4.tkhd(track), MP4.mdia(track));
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'trex',
|
|
|
+ value: function trex(track) {
|
|
|
+ var id = track.id;
|
|
|
+ return MP4.box(MP4.types.trex, new Uint8Array([0x00, // version 0
|
|
|
+ 0x00, 0x00, 0x00, // flags
|
|
|
+ id >> 24, id >> 16 & 0XFF, id >> 8 & 0XFF, id & 0xFF, // track_ID
|
|
|
+ 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
|
|
|
+ ]));
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'trun',
|
|
|
+ value: function trun(track, offset) {
|
|
|
+ var samples = track.samples || [],
|
|
|
+ len = samples.length,
|
|
|
+ arraylen = 12 + 16 * len,
|
|
|
+ array = new Uint8Array(arraylen),
|
|
|
+ i,
|
|
|
+ sample,
|
|
|
+ duration,
|
|
|
+ size,
|
|
|
+ flags,
|
|
|
+ cts;
|
|
|
+
|
|
|
+ //sample = samples[0];
|
|
|
+ // console.log( "trun==> ",sample.duration, sample.cts ,sample.size,len );
|
|
|
+
|
|
|
+ offset += 8 + arraylen;
|
|
|
+ array.set([0x00, // version 0
|
|
|
+ 0x00, 0x0f, 0x01, // flags
|
|
|
+ len >>> 24 & 0xFF, len >>> 16 & 0xFF, len >>> 8 & 0xFF, len & 0xFF, // sample_count
|
|
|
+ offset >>> 24 & 0xFF, offset >>> 16 & 0xFF, offset >>> 8 & 0xFF, offset & 0xFF // data_offset
|
|
|
+ ], 0);
|
|
|
+ for (i = 0; i < len; i++) {
|
|
|
+ sample = samples[i];
|
|
|
+ duration = sample.duration;
|
|
|
+ size = sample.size;
|
|
|
+ flags = sample.flags;
|
|
|
+ cts = sample.cts;
|
|
|
+ array.set([duration >>> 24 & 0xFF, duration >>> 16 & 0xFF, duration >>> 8 & 0xFF, duration & 0xFF, // sample_duration
|
|
|
+ size >>> 24 & 0xFF, size >>> 16 & 0xFF, size >>> 8 & 0xFF, size & 0xFF, // sample_size
|
|
|
+ flags.isLeading << 2 | flags.dependsOn, flags.isDependedOn << 6 | flags.hasRedundancy << 4 | flags.paddingValue << 1 | flags.isNonSync, flags.degradPrio & 0xF0 << 8, flags.degradPrio & 0x0F, // sample_flags
|
|
|
+ cts >>> 24 & 0xFF, cts >>> 16 & 0xFF, cts >>> 8 & 0xFF, cts & 0xFF // sample_composition_time_offset
|
|
|
+ ], 12 + 16 * i);
|
|
|
+ }
|
|
|
+ return MP4.box(MP4.types.trun, array);
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'initSegment',
|
|
|
+ value: function initSegment(tracks) {
|
|
|
+ if (!MP4.types) {
|
|
|
+ MP4.init();
|
|
|
+ }
|
|
|
+ var movie = MP4.moov(tracks),
|
|
|
+ result;
|
|
|
+ result = new Uint8Array(MP4.FTYP.byteLength + movie.byteLength);
|
|
|
+ result.set(MP4.FTYP);
|
|
|
+ result.set(movie, MP4.FTYP.byteLength);
|
|
|
+
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ }]);
|
|
|
+
|
|
|
+ return MP4;
|
|
|
+}();
|
|
|
+
|
|
|
+exports.default = MP4;
|
|
|
+
|
|
|
+},{}],16:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+Object.defineProperty(exports, "__esModule", {
|
|
|
+ value: true
|
|
|
+});
|
|
|
+
|
|
|
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /**
|
|
|
+ * fMP4 remuxer
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+var _aac = require('../helper/aac');
|
|
|
+
|
|
|
+var _aac2 = _interopRequireDefault(_aac);
|
|
|
+
|
|
|
+var _events = require('../events');
|
|
|
+
|
|
|
+var _events2 = _interopRequireDefault(_events);
|
|
|
+
|
|
|
+var _logger = require('../utils/logger');
|
|
|
+
|
|
|
+var _mp4Generator = require('../remux/mp4-generator');
|
|
|
+
|
|
|
+var _mp4Generator2 = _interopRequireDefault(_mp4Generator);
|
|
|
+
|
|
|
+var _errors = require('../errors');
|
|
|
+
|
|
|
+require('../utils/polyfill');
|
|
|
+
|
|
|
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
+
|
|
|
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
+
|
|
|
+var MP4Remuxer = function () {
|
|
|
+ function MP4Remuxer(observer, id, config) {
|
|
|
+ _classCallCheck(this, MP4Remuxer);
|
|
|
+
|
|
|
+ this.observer = observer;
|
|
|
+ this.id = id;
|
|
|
+ this.config = config;
|
|
|
+ this.ISGenerated = false;
|
|
|
+ this.PES2MP4SCALEFACTOR = 4;
|
|
|
+ this.PES_TIMESCALE = 90000;
|
|
|
+ this.MP4_TIMESCALE = this.PES_TIMESCALE / this.PES2MP4SCALEFACTOR;
|
|
|
+ this.nextAvcDts = 90300;
|
|
|
+ this.H264_TIMEBASE = 3000;
|
|
|
+ this.width = 0;
|
|
|
+ this.height = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ _createClass(MP4Remuxer, [{
|
|
|
+ key: 'destroy',
|
|
|
+ value: function destroy() {}
|
|
|
+ }, {
|
|
|
+ key: 'insertDiscontinuity',
|
|
|
+ value: function insertDiscontinuity() {
|
|
|
+ this._initPTS = this._initDTS = undefined;
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'switchLevel',
|
|
|
+ value: function switchLevel() {
|
|
|
+ this.ISGenerated = false;
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'pushVideo',
|
|
|
+ value: function pushVideo(level, sn, videoTrack, timeOffset, contiguous) {
|
|
|
+ this.level = level;
|
|
|
+ this.sn = sn;
|
|
|
+ var videoData = void 0;
|
|
|
+ // generate Init Segment if needed
|
|
|
+ if (!this.ISGenerated) {
|
|
|
+ this.width = videoTrack.width;
|
|
|
+ this.height = videoTrack.height;
|
|
|
+ this.generateVideoIS(videoTrack, timeOffset);
|
|
|
+ }
|
|
|
+ if (this.ISGenerated) {
|
|
|
+ // if (videoTrack.samples.length) {
|
|
|
+ this.remuxVideo_2(videoTrack, timeOffset, contiguous);
|
|
|
+ // }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'remuxVideo_2',
|
|
|
+ value: function remuxVideo_2(track, timeOffset, contiguous, audioTrackLength) {
|
|
|
+ var offset = 8,
|
|
|
+ pesTimeScale = this.PES_TIMESCALE,
|
|
|
+ pes2mp4ScaleFactor = this.PES2MP4SCALEFACTOR,
|
|
|
+ mp4SampleDuration,
|
|
|
+ mdat,
|
|
|
+ moof,
|
|
|
+ firstPTS,
|
|
|
+ firstDTS,
|
|
|
+ nextDTS,
|
|
|
+ inputSamples = track.samples,
|
|
|
+ outputSamples = [];
|
|
|
+
|
|
|
+ /* concatenate the video data and construct the mdat in place
|
|
|
+ (need 8 more bytes to fill length and mpdat type) */
|
|
|
+ mdat = new Uint8Array(track.len + 4 * track.nbNalu + 8);
|
|
|
+ var view = new DataView(mdat.buffer);
|
|
|
+ view.setUint32(0, mdat.byteLength);
|
|
|
+ mdat.set(_mp4Generator2.default.types.mdat, 4);
|
|
|
+ var sampleDuration = 0;
|
|
|
+ var ptsnorm = void 0,
|
|
|
+ dtsnorm = void 0,
|
|
|
+ mp4Sample = void 0,
|
|
|
+ lastDTS = void 0;
|
|
|
+
|
|
|
+ for (var i = 0; i < inputSamples.length; i++) {
|
|
|
+ var avcSample = inputSamples[i],
|
|
|
+ mp4SampleLength = 0,
|
|
|
+ compositionTimeOffset = void 0;
|
|
|
+ // convert NALU bitstream to MP4 format (prepend NALU with size field)
|
|
|
+ while (avcSample.units.units.length) {
|
|
|
+ var unit = avcSample.units.units.shift();
|
|
|
+ view.setUint32(offset, unit.data.byteLength);
|
|
|
+ offset += 4;
|
|
|
+ mdat.set(unit.data, offset);
|
|
|
+ offset += unit.data.byteLength;
|
|
|
+ mp4SampleLength += 4 + unit.data.byteLength;
|
|
|
+ }
|
|
|
+
|
|
|
+ var pts = avcSample.pts - this._initPTS;
|
|
|
+ var dts = avcSample.dts - this._initDTS;
|
|
|
+ dts = Math.min(pts, dts);
|
|
|
+
|
|
|
+ if (lastDTS !== undefined) {
|
|
|
+ ptsnorm = this._PTSNormalize(pts, lastDTS);
|
|
|
+ dtsnorm = this._PTSNormalize(dts, lastDTS);
|
|
|
+ sampleDuration = dtsnorm - lastDTS;
|
|
|
+ if (sampleDuration <= 0) {
|
|
|
+ _logger.logger.log('invalid sample duration at PTS/DTS: ' + avcSample.pts + '/' + avcSample.dts + '|dts norm: ' + dtsnorm + '|lastDTS: ' + lastDTS + ':' + sampleDuration);
|
|
|
+ sampleDuration = 1;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ var nextAvcDts = this.nextAvcDts,
|
|
|
+ delta;
|
|
|
+ ptsnorm = this._PTSNormalize(pts, nextAvcDts);
|
|
|
+ dtsnorm = this._PTSNormalize(dts, nextAvcDts);
|
|
|
+ if (nextAvcDts) {
|
|
|
+ delta = Math.round(dtsnorm - nextAvcDts);
|
|
|
+ if ( /*contiguous ||*/Math.abs(delta) < 600) {
|
|
|
+ if (delta) {
|
|
|
+ if (delta > 1) {
|
|
|
+ _logger.logger.log('AVC:' + delta + ' ms hole between fragments detected,filling it');
|
|
|
+ } else if (delta < -1) {
|
|
|
+ _logger.logger.log('AVC:' + -delta + ' ms overlapping between fragments detected');
|
|
|
+ }
|
|
|
+ dtsnorm = nextAvcDts;
|
|
|
+ ptsnorm = Math.max(ptsnorm - delta, dtsnorm);
|
|
|
+ _logger.logger.log('Video/PTS/DTS adjusted: ' + ptsnorm + '/' + dtsnorm + ',delta:' + delta);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ this.firstPTS = Math.max(0, ptsnorm);
|
|
|
+ this.firstDTS = Math.max(0, dtsnorm);
|
|
|
+ sampleDuration = 0.03;
|
|
|
+ }
|
|
|
+ outputSamples.push({
|
|
|
+ size: mp4SampleLength,
|
|
|
+ duration: this.H264_TIMEBASE,
|
|
|
+ cts: 0,
|
|
|
+ flags: {
|
|
|
+ isLeading: 0,
|
|
|
+ isDependedOn: 0,
|
|
|
+ hasRedundancy: 0,
|
|
|
+ degradPrio: 0,
|
|
|
+ dependsOn: avcSample.key ? 2 : 1,
|
|
|
+ isNonSync: avcSample.key ? 0 : 1
|
|
|
+ }
|
|
|
+ });
|
|
|
+ lastDTS = dtsnorm;
|
|
|
+ }
|
|
|
+ var lastSampleDuration = 0;
|
|
|
+ if (outputSamples.length >= 2) {
|
|
|
+ lastSampleDuration = outputSamples[outputSamples.length - 2].duration;
|
|
|
+ outputSamples[0].duration = lastSampleDuration;
|
|
|
+ }
|
|
|
+ this.nextAvcDts = dtsnorm + lastSampleDuration;
|
|
|
+ var dropped = track.dropped;
|
|
|
+ track.len = 0;
|
|
|
+ track.nbNalu = 0;
|
|
|
+ track.dropped = 0;
|
|
|
+ if (outputSamples.length && navigator.userAgent.toLowerCase().indexOf('chrome') > -1) {
|
|
|
+ var flags = outputSamples[0].flags;
|
|
|
+ flags.dependsOn = 2;
|
|
|
+ flags.isNonSync = 0;
|
|
|
+ }
|
|
|
+ track.samples = outputSamples;
|
|
|
+ moof = _mp4Generator2.default.moof(track.sequenceNumber++, dtsnorm, track);
|
|
|
+ track.samples = [];
|
|
|
+
|
|
|
+ var data = {
|
|
|
+ id: this.id,
|
|
|
+ level: this.level,
|
|
|
+ sn: this.sn,
|
|
|
+ data1: moof,
|
|
|
+ data2: mdat,
|
|
|
+ startPTS: ptsnorm,
|
|
|
+ endPTS: ptsnorm,
|
|
|
+ startDTS: dtsnorm,
|
|
|
+ endDTS: dtsnorm,
|
|
|
+ type: 'video',
|
|
|
+ nb: outputSamples.length,
|
|
|
+ dropped: dropped
|
|
|
+ };
|
|
|
+ this.observer.trigger(_events2.default.FRAG_PARSING_DATA, data);
|
|
|
+ return data;
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'generateVideoIS',
|
|
|
+ value: function generateVideoIS(videoTrack, timeOffset) {
|
|
|
+ var observer = this.observer,
|
|
|
+ videoSamples = videoTrack.samples,
|
|
|
+ pesTimeScale = this.PES_TIMESCALE,
|
|
|
+ tracks = {},
|
|
|
+ data = { id: this.id, level: this.level, sn: this.sn, tracks: tracks, unique: false },
|
|
|
+ computePTSDTS = this._initPTS === undefined,
|
|
|
+ initPTS,
|
|
|
+ initDTS;
|
|
|
+
|
|
|
+ if (computePTSDTS) {
|
|
|
+ initPTS = initDTS = Infinity;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (videoTrack.sps && videoTrack.pps && videoSamples.length) {
|
|
|
+ videoTrack.timescale = 90000; //this.MP4_TIMESCALE;
|
|
|
+ tracks.video = {
|
|
|
+ container: 'video/mp4',
|
|
|
+ codec: videoTrack.codec,
|
|
|
+ initSegment: _mp4Generator2.default.initSegment([videoTrack]),
|
|
|
+ metadata: {
|
|
|
+ width: videoTrack.width,
|
|
|
+ height: videoTrack.height
|
|
|
+ }
|
|
|
+ };
|
|
|
+ if (computePTSDTS) {
|
|
|
+ initPTS = Math.min(initPTS, videoSamples[0].pts - this.H264_TIMEBASE);
|
|
|
+ initDTS = Math.min(initDTS, videoSamples[0].dts - this.H264_TIMEBASE);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (Object.keys(tracks).length) {
|
|
|
+ observer.trigger(_events2.default.FRAG_PARSING_INIT_SEGMENT, data);
|
|
|
+ this.ISGenerated = true;
|
|
|
+ if (computePTSDTS) {
|
|
|
+ this._initPTS = initPTS;
|
|
|
+ this._initDTS = initDTS;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ console.log("generateVideoIS ERROR==> ", _errors.ErrorTypes.MEDIA_ERROR);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'remux',
|
|
|
+ value: function remux(level, sn, audioTrack, videoTrack, id3Track, textTrack, timeOffset, contiguous) {
|
|
|
+ this.level = level;
|
|
|
+ this.sn = sn;
|
|
|
+ // generate Init Segment if needed
|
|
|
+ if (!this.ISGenerated) {
|
|
|
+ this.generateIS(audioTrack, videoTrack, timeOffset);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (this.ISGenerated) {
|
|
|
+ // Purposefully remuxing audio before video, so that remuxVideo can use nextAacPts, which is
|
|
|
+ // calculated in remuxAudio.
|
|
|
+ //logger.log('nb AAC samples:' + audioTrack.samples.length);
|
|
|
+ if (audioTrack.samples.length) {
|
|
|
+ var audioData = this.remuxAudio(audioTrack, timeOffset, contiguous);
|
|
|
+ //logger.log('nb AVC samples:' + videoTrack.samples.length);
|
|
|
+ if (videoTrack.samples.length) {
|
|
|
+ var audioTrackLength = void 0;
|
|
|
+ if (audioData) {
|
|
|
+ audioTrackLength = audioData.endPTS - audioData.startPTS;
|
|
|
+ }
|
|
|
+ this.remuxVideo(videoTrack, timeOffset, contiguous, audioTrackLength);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ var videoData = void 0;
|
|
|
+ //logger.log('nb AVC samples:' + videoTrack.samples.length);
|
|
|
+ if (videoTrack.samples.length) {
|
|
|
+ videoData = this.remuxVideo(videoTrack, timeOffset, contiguous);
|
|
|
+ }
|
|
|
+ if (videoData && audioTrack.codec) {
|
|
|
+ this.remuxEmptyAudio(audioTrack, timeOffset, contiguous, videoData);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ //logger.log('nb ID3 samples:' + audioTrack.samples.length);
|
|
|
+ if (id3Track.samples.length) {
|
|
|
+ this.remuxID3(id3Track, timeOffset);
|
|
|
+ }
|
|
|
+ //logger.log('nb ID3 samples:' + audioTrack.samples.length);
|
|
|
+ if (textTrack.samples.length) {
|
|
|
+ this.remuxText(textTrack, timeOffset);
|
|
|
+ }
|
|
|
+ //notify end of parsing
|
|
|
+ this.observer.trigger(_events2.default.FRAG_PARSED, { id: this.id, level: this.level, sn: this.sn });
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'generateIS',
|
|
|
+ value: function generateIS(audioTrack, videoTrack, timeOffset) {
|
|
|
+ var observer = this.observer,
|
|
|
+ audioSamples = audioTrack.samples,
|
|
|
+ videoSamples = videoTrack.samples,
|
|
|
+ pesTimeScale = this.PES_TIMESCALE,
|
|
|
+ tracks = {},
|
|
|
+ data = { id: this.id, level: this.level, sn: this.sn, tracks: tracks, unique: false },
|
|
|
+ computePTSDTS = this._initPTS === undefined,
|
|
|
+ initPTS,
|
|
|
+ initDTS;
|
|
|
+
|
|
|
+ if (computePTSDTS) {
|
|
|
+ initPTS = initDTS = Infinity;
|
|
|
+ }
|
|
|
+ if (audioTrack.config && audioSamples.length) {
|
|
|
+ audioTrack.timescale = audioTrack.audiosamplerate;
|
|
|
+ // MP4 duration (track duration in seconds multiplied by timescale) is coded on 32 bits
|
|
|
+ // we know that each AAC sample contains 1024 frames....
|
|
|
+ // in order to avoid overflowing the 32 bit counter for large duration, we use smaller timescale (timescale/gcd)
|
|
|
+ // we just need to ensure that AAC sample duration will still be an integer (will be 1024/gcd)
|
|
|
+ if (audioTrack.timescale * audioTrack.duration > Math.pow(2, 32)) {
|
|
|
+ var greatestCommonDivisor = function greatestCommonDivisor(a, b) {
|
|
|
+ if (!b) {
|
|
|
+ return a;
|
|
|
+ }
|
|
|
+ return greatestCommonDivisor(b, a % b);
|
|
|
+ };
|
|
|
+ audioTrack.timescale = audioTrack.audiosamplerate / greatestCommonDivisor(audioTrack.audiosamplerate, 1024);
|
|
|
+ }
|
|
|
+ _logger.logger.log('audio mp4 timescale :' + audioTrack.timescale);
|
|
|
+ tracks.audio = {
|
|
|
+ container: 'audio/mp4',
|
|
|
+ codec: audioTrack.codec,
|
|
|
+ initSegment: _mp4Generator2.default.initSegment([audioTrack]),
|
|
|
+ metadata: {
|
|
|
+ channelCount: audioTrack.channelCount
|
|
|
+ }
|
|
|
+ };
|
|
|
+ if (computePTSDTS) {
|
|
|
+ // remember first PTS of this demuxing context. for audio, PTS + DTS ...
|
|
|
+ initPTS = initDTS = audioSamples[0].pts - pesTimeScale * timeOffset;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (videoTrack.sps && videoTrack.pps && videoSamples.length) {
|
|
|
+ videoTrack.timescale = this.MP4_TIMESCALE;
|
|
|
+ tracks.video = {
|
|
|
+ container: 'video/mp4',
|
|
|
+ codec: videoTrack.codec,
|
|
|
+ initSegment: _mp4Generator2.default.initSegment([videoTrack]),
|
|
|
+ metadata: {
|
|
|
+ width: videoTrack.width,
|
|
|
+ height: videoTrack.height
|
|
|
+ }
|
|
|
+ };
|
|
|
+ if (computePTSDTS) {
|
|
|
+ initPTS = Math.min(initPTS, videoSamples[0].pts - pesTimeScale * timeOffset);
|
|
|
+ initDTS = Math.min(initDTS, videoSamples[0].dts - pesTimeScale * timeOffset);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (Object.keys(tracks).length) {
|
|
|
+ observer.trigger(_events2.default.FRAG_PARSING_INIT_SEGMENT, data);
|
|
|
+ this.ISGenerated = true;
|
|
|
+ if (computePTSDTS) {
|
|
|
+ this._initPTS = initPTS;
|
|
|
+ this._initDTS = initDTS;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ observer.trigger(_events2.default.ERROR, { type: _errors.ErrorTypes.MEDIA_ERROR, id: this.id, details: _errors.ErrorDetails.FRAG_PARSING_ERROR, fatal: false, reason: 'no audio/video samples found' });
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'remuxVideo',
|
|
|
+ value: function remuxVideo(track, timeOffset, contiguous, audioTrackLength) {
|
|
|
+ var offset = 8,
|
|
|
+ pesTimeScale = this.PES_TIMESCALE,
|
|
|
+ pes2mp4ScaleFactor = this.PES2MP4SCALEFACTOR,
|
|
|
+ mp4SampleDuration,
|
|
|
+ mdat,
|
|
|
+ moof,
|
|
|
+ firstPTS,
|
|
|
+ firstDTS,
|
|
|
+ nextDTS,
|
|
|
+ lastPTS,
|
|
|
+ lastDTS,
|
|
|
+ inputSamples = track.samples,
|
|
|
+ outputSamples = [];
|
|
|
+
|
|
|
+ // PTS is coded on 33bits, and can loop from -2^32 to 2^32
|
|
|
+ // PTSNormalize will make PTS/DTS value monotonic, we use last known DTS value as reference value
|
|
|
+ var nextAvcDts = void 0;
|
|
|
+ if (contiguous) {
|
|
|
+ // if parsed fragment is contiguous with last one, let's use last DTS value as reference
|
|
|
+ nextAvcDts = this.nextAvcDts;
|
|
|
+ } else {
|
|
|
+ // if not contiguous, let's use target timeOffset
|
|
|
+ nextAvcDts = timeOffset * pesTimeScale;
|
|
|
+ }
|
|
|
+
|
|
|
+ // compute first DTS and last DTS, normalize them against reference value
|
|
|
+ var sample = inputSamples[0];
|
|
|
+ firstDTS = Math.max(this._PTSNormalize(sample.dts, nextAvcDts) - this._initDTS, 0);
|
|
|
+ firstPTS = Math.max(this._PTSNormalize(sample.pts, nextAvcDts) - this._initDTS, 0);
|
|
|
+
|
|
|
+ // check timestamp continuity accross consecutive fragments (this is to remove inter-fragment gap/hole)
|
|
|
+ var delta = Math.round((firstDTS - nextAvcDts) / 90);
|
|
|
+ // if fragment are contiguous, detect hole/overlapping between fragments
|
|
|
+ if (contiguous) {
|
|
|
+ if (delta) {
|
|
|
+ if (delta > 1) {
|
|
|
+ _logger.logger.log('AVC:' + delta + ' ms hole between fragments detected,filling it');
|
|
|
+ } else if (delta < -1) {
|
|
|
+ _logger.logger.log('AVC:' + -delta + ' ms overlapping between fragments detected');
|
|
|
+ }
|
|
|
+ // remove hole/gap : set DTS to next expected DTS
|
|
|
+ firstDTS = nextAvcDts;
|
|
|
+ inputSamples[0].dts = firstDTS + this._initDTS;
|
|
|
+ // offset PTS as well, ensure that PTS is smaller or equal than new DTS
|
|
|
+ firstPTS = Math.max(firstPTS - delta, nextAvcDts);
|
|
|
+ inputSamples[0].pts = firstPTS + this._initDTS;
|
|
|
+ _logger.logger.log('Video/PTS/DTS adjusted: ' + firstPTS + '/' + firstDTS + ',delta:' + delta);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ nextDTS = firstDTS;
|
|
|
+
|
|
|
+ // compute lastPTS/lastDTS
|
|
|
+ sample = inputSamples[inputSamples.length - 1];
|
|
|
+ lastDTS = Math.max(this._PTSNormalize(sample.dts, nextAvcDts) - this._initDTS, 0);
|
|
|
+ lastPTS = Math.max(this._PTSNormalize(sample.pts, nextAvcDts) - this._initDTS, 0);
|
|
|
+ lastPTS = Math.max(lastPTS, lastDTS);
|
|
|
+
|
|
|
+ var vendor = navigator.vendor,
|
|
|
+ userAgent = navigator.userAgent,
|
|
|
+ isSafari = vendor && vendor.indexOf('Apple') > -1 && userAgent && !userAgent.match('CriOS');
|
|
|
+
|
|
|
+ // on Safari let's signal the same sample duration for all samples
|
|
|
+ // sample duration (as expected by trun MP4 boxes), should be the delta between sample DTS
|
|
|
+ // set this constant duration as being the avg delta between consecutive DTS.
|
|
|
+ if (isSafari) {
|
|
|
+ mp4SampleDuration = Math.round((lastDTS - firstDTS) / (pes2mp4ScaleFactor * (inputSamples.length - 1)));
|
|
|
+ }
|
|
|
+
|
|
|
+ // normalize all PTS/DTS now ...
|
|
|
+ for (var i = 0; i < inputSamples.length; i++) {
|
|
|
+ var _sample = inputSamples[i];
|
|
|
+ if (isSafari) {
|
|
|
+ // sample DTS is computed using a constant decoding offset (mp4SampleDuration) between samples
|
|
|
+ _sample.dts = firstDTS + i * pes2mp4ScaleFactor * mp4SampleDuration;
|
|
|
+ } else {
|
|
|
+ // ensure sample monotonic DTS
|
|
|
+ _sample.dts = Math.max(this._PTSNormalize(_sample.dts, nextAvcDts) - this._initDTS, firstDTS);
|
|
|
+ // ensure dts is a multiple of scale factor to avoid rounding issues
|
|
|
+ _sample.dts = Math.round(_sample.dts / pes2mp4ScaleFactor) * pes2mp4ScaleFactor;
|
|
|
+ }
|
|
|
+ // we normalize PTS against nextAvcDts, we also substract initDTS (some streams don't start @ PTS O)
|
|
|
+ // and we ensure that computed value is greater or equal than sample DTS
|
|
|
+ _sample.pts = Math.max(this._PTSNormalize(_sample.pts, nextAvcDts) - this._initDTS, _sample.dts);
|
|
|
+ // ensure pts is a multiple of scale factor to avoid rounding issues
|
|
|
+ _sample.pts = Math.round(_sample.pts / pes2mp4ScaleFactor) * pes2mp4ScaleFactor;
|
|
|
+ }
|
|
|
+ /* concatenate the video data and construct the mdat in place
|
|
|
+ (need 8 more bytes to fill length and mpdat type) */
|
|
|
+ mdat = new Uint8Array(track.len + 4 * track.nbNalu + 8);
|
|
|
+ var view = new DataView(mdat.buffer);
|
|
|
+ view.setUint32(0, mdat.byteLength);
|
|
|
+ mdat.set(_mp4Generator2.default.types.mdat, 4);
|
|
|
+
|
|
|
+ for (var _i = 0; _i < inputSamples.length; _i++) {
|
|
|
+ var avcSample = inputSamples[_i],
|
|
|
+ mp4SampleLength = 0,
|
|
|
+ compositionTimeOffset = void 0;
|
|
|
+ // convert NALU bitstream to MP4 format (prepend NALU with size field)
|
|
|
+ while (avcSample.units.units.length) {
|
|
|
+ var unit = avcSample.units.units.shift();
|
|
|
+ view.setUint32(offset, unit.data.byteLength);
|
|
|
+ offset += 4;
|
|
|
+ mdat.set(unit.data, offset);
|
|
|
+ offset += unit.data.byteLength;
|
|
|
+ mp4SampleLength += 4 + unit.data.byteLength;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!isSafari) {
|
|
|
+ // expected sample duration is the Decoding Timestamp diff of consecutive samples
|
|
|
+ if (_i < inputSamples.length - 1) {
|
|
|
+ mp4SampleDuration = inputSamples[_i + 1].dts - avcSample.dts;
|
|
|
+ } else {
|
|
|
+ var config = this.config,
|
|
|
+ lastFrameDuration = avcSample.dts - inputSamples[_i > 0 ? _i - 1 : _i].dts;
|
|
|
+ if (config.stretchShortVideoTrack) {
|
|
|
+ // In some cases, a segment's audio track duration may exceed the video track duration.
|
|
|
+ // Since we've already remuxed audio, and we know how long the audio track is, we look to
|
|
|
+ // see if the delta to the next segment is longer than the minimum of maxBufferHole and
|
|
|
+ // maxSeekHole. If so, playback would potentially get stuck, so we artificially inflate
|
|
|
+ // the duration of the last frame to minimize any potential gap between segments.
|
|
|
+ var maxBufferHole = config.maxBufferHole,
|
|
|
+ maxSeekHole = config.maxSeekHole,
|
|
|
+ gapTolerance = Math.floor(Math.min(maxBufferHole, maxSeekHole) * pesTimeScale),
|
|
|
+ deltaToFrameEnd = (audioTrackLength ? firstPTS + audioTrackLength * pesTimeScale : this.nextAacPts) - avcSample.pts;
|
|
|
+ if (deltaToFrameEnd > gapTolerance) {
|
|
|
+ // We subtract lastFrameDuration from deltaToFrameEnd to try to prevent any video
|
|
|
+ // frame overlap. maxBufferHole/maxSeekHole should be >> lastFrameDuration anyway.
|
|
|
+ mp4SampleDuration = deltaToFrameEnd - lastFrameDuration;
|
|
|
+ if (mp4SampleDuration < 0) {
|
|
|
+ mp4SampleDuration = lastFrameDuration;
|
|
|
+ }
|
|
|
+ _logger.logger.log('It is approximately ' + deltaToFrameEnd / 90 + ' ms to the next segment; using duration ' + mp4SampleDuration / 90 + ' ms for the last video frame.');
|
|
|
+ } else {
|
|
|
+ mp4SampleDuration = lastFrameDuration;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ mp4SampleDuration = lastFrameDuration;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ mp4SampleDuration /= pes2mp4ScaleFactor;
|
|
|
+ compositionTimeOffset = Math.round((avcSample.pts - avcSample.dts) / pes2mp4ScaleFactor);
|
|
|
+ } else {
|
|
|
+ compositionTimeOffset = Math.max(0, mp4SampleDuration * Math.round((avcSample.pts - avcSample.dts) / (pes2mp4ScaleFactor * mp4SampleDuration)));
|
|
|
+ }
|
|
|
+ outputSamples.push({
|
|
|
+ size: mp4SampleLength,
|
|
|
+ // constant duration
|
|
|
+ duration: mp4SampleDuration,
|
|
|
+ cts: compositionTimeOffset,
|
|
|
+ flags: {
|
|
|
+ isLeading: 0,
|
|
|
+ isDependedOn: 0,
|
|
|
+ hasRedundancy: 0,
|
|
|
+ degradPrio: 0,
|
|
|
+ dependsOn: avcSample.key ? 2 : 1,
|
|
|
+ isNonSync: avcSample.key ? 0 : 1
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+ // next AVC sample DTS should be equal to last sample DTS + last sample duration (in PES timescale)
|
|
|
+ this.nextAvcDts = lastDTS + mp4SampleDuration * pes2mp4ScaleFactor;
|
|
|
+ var dropped = track.dropped;
|
|
|
+ track.len = 0;
|
|
|
+ track.nbNalu = 0;
|
|
|
+ track.dropped = 0;
|
|
|
+ if (outputSamples.length && navigator.userAgent.toLowerCase().indexOf('chrome') > -1) {
|
|
|
+ var flags = outputSamples[0].flags;
|
|
|
+ // chrome workaround, mark first sample as being a Random Access Point to avoid sourcebuffer append issue
|
|
|
+ // https://code.google.com/p/chromium/issues/detail?id=229412
|
|
|
+ flags.dependsOn = 2;
|
|
|
+ flags.isNonSync = 0;
|
|
|
+ }
|
|
|
+ track.samples = outputSamples;
|
|
|
+ moof = _mp4Generator2.default.moof(track.sequenceNumber++, firstDTS / pes2mp4ScaleFactor, track);
|
|
|
+ track.samples = [];
|
|
|
+
|
|
|
+ var data = {
|
|
|
+ id: this.id,
|
|
|
+ level: this.level,
|
|
|
+ sn: this.sn,
|
|
|
+ data1: moof,
|
|
|
+ data2: mdat,
|
|
|
+ startPTS: firstPTS / pesTimeScale,
|
|
|
+ endPTS: (lastPTS + pes2mp4ScaleFactor * mp4SampleDuration) / pesTimeScale,
|
|
|
+ startDTS: firstPTS / pesTimeScale,
|
|
|
+ endDTS: (lastPTS + pes2mp4ScaleFactor * mp4SampleDuration) / pesTimeScale,
|
|
|
+ // startDTS: firstDTS / pesTimeScale,
|
|
|
+ // endDTS: this.nextAvcDts / pesTimeScale,
|
|
|
+ type: 'video',
|
|
|
+ nb: outputSamples.length,
|
|
|
+ dropped: dropped
|
|
|
+ };
|
|
|
+ this.observer.trigger(_events2.default.FRAG_PARSING_DATA, data);
|
|
|
+ return data;
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'remuxAudio',
|
|
|
+ value: function remuxAudio(track, timeOffset, contiguous) {
|
|
|
+ var pesTimeScale = this.PES_TIMESCALE,
|
|
|
+ mp4timeScale = track.timescale,
|
|
|
+ pes2mp4ScaleFactor = pesTimeScale / mp4timeScale,
|
|
|
+ expectedSampleDuration = track.timescale * 1024 / track.audiosamplerate;
|
|
|
+ var view,
|
|
|
+ offset = 8,
|
|
|
+ aacSample,
|
|
|
+ mp4Sample,
|
|
|
+ unit,
|
|
|
+ mdat,
|
|
|
+ moof,
|
|
|
+ firstPTS,
|
|
|
+ firstDTS,
|
|
|
+ lastDTS,
|
|
|
+ pts,
|
|
|
+ dts,
|
|
|
+ ptsnorm,
|
|
|
+ dtsnorm,
|
|
|
+ samples = [],
|
|
|
+ samples0 = [];
|
|
|
+
|
|
|
+ track.samples.sort(function (a, b) {
|
|
|
+ return a.pts - b.pts;
|
|
|
+ });
|
|
|
+ samples0 = track.samples;
|
|
|
+
|
|
|
+ var nextAacPts = contiguous ? this.nextAacPts : timeOffset * pesTimeScale;
|
|
|
+
|
|
|
+ // If the audio track is missing samples, the frames seem to get "left-shifted" within the
|
|
|
+ // resulting mp4 segment, causing sync issues and leaving gaps at the end of the audio segment.
|
|
|
+ // In an effort to prevent this from happening, we inject frames here where there are gaps.
|
|
|
+ // When possible, we inject a silent frame; when that's not possible, we duplicate the last
|
|
|
+ // frame.
|
|
|
+ var firstPtsNorm = this._PTSNormalize(samples0[0].pts - this._initPTS, nextAacPts),
|
|
|
+ pesFrameDuration = expectedSampleDuration * pes2mp4ScaleFactor;
|
|
|
+ var nextPtsNorm = firstPtsNorm + pesFrameDuration;
|
|
|
+ for (var i = 1; i < samples0.length;) {
|
|
|
+ // First, let's see how far off this frame is from where we expect it to be
|
|
|
+ var sample = samples0[i],
|
|
|
+ ptsNorm = this._PTSNormalize(sample.pts - this._initPTS, nextAacPts),
|
|
|
+ delta = ptsNorm - nextPtsNorm;
|
|
|
+
|
|
|
+ // If we're overlapping by more than half a duration, drop this sample
|
|
|
+ if (delta < -0.5 * pesFrameDuration) {
|
|
|
+ _logger.logger.log('Dropping frame due to ' + Math.abs(delta / 90) + ' ms overlap.');
|
|
|
+ samples0.splice(i, 1);
|
|
|
+ track.len -= sample.unit.length;
|
|
|
+ // Don't touch nextPtsNorm or i
|
|
|
+ }
|
|
|
+ // Otherwise, if we're more than half a frame away from where we should be, insert missing frames
|
|
|
+ else if (delta > 0.5 * pesFrameDuration) {
|
|
|
+ var missing = Math.round(delta / pesFrameDuration);
|
|
|
+ _logger.logger.log('Injecting ' + missing + ' frame' + (missing > 1 ? 's' : '') + ' of missing audio due to ' + Math.round(delta / 90) + ' ms gap.');
|
|
|
+ for (var j = 0; j < missing; j++) {
|
|
|
+ var newStamp = samples0[i - 1].pts + pesFrameDuration,
|
|
|
+ fillFrame = _aac2.default.getSilentFrame(track.channelCount);
|
|
|
+ if (!fillFrame) {
|
|
|
+ _logger.logger.log('Unable to get silent frame for given audio codec; duplicating last frame instead.');
|
|
|
+ fillFrame = sample.unit.slice(0);
|
|
|
+ }
|
|
|
+ samples0.splice(i, 0, { unit: fillFrame, pts: newStamp, dts: newStamp });
|
|
|
+ track.len += fillFrame.length;
|
|
|
+ i += 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Adjust sample to next expected pts
|
|
|
+ nextPtsNorm += (missing + 1) * pesFrameDuration;
|
|
|
+ sample.pts = samples0[i - 1].pts + pesFrameDuration;
|
|
|
+ i += 1;
|
|
|
+ }
|
|
|
+ // Otherwise, we're within half a frame duration, so just adjust pts
|
|
|
+ else {
|
|
|
+ if (Math.abs(delta) > 0.1 * pesFrameDuration) {
|
|
|
+ _logger.logger.log('Invalid frame delta ' + (ptsNorm - nextPtsNorm + pesFrameDuration) + ' at PTS ' + Math.round(ptsNorm / 90) + ' (should be ' + pesFrameDuration + ').');
|
|
|
+ }
|
|
|
+ nextPtsNorm += pesFrameDuration;
|
|
|
+ sample.pts = samples0[i - 1].pts + pesFrameDuration;
|
|
|
+ i += 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ while (samples0.length) {
|
|
|
+ aacSample = samples0.shift();
|
|
|
+ unit = aacSample.unit;
|
|
|
+ pts = aacSample.pts - this._initDTS;
|
|
|
+ dts = aacSample.dts - this._initDTS;
|
|
|
+ //logger.log(`Audio/PTS:${Math.round(pts/90)}`);
|
|
|
+ // if not first sample
|
|
|
+ if (lastDTS !== undefined) {
|
|
|
+ ptsnorm = this._PTSNormalize(pts, lastDTS);
|
|
|
+ dtsnorm = this._PTSNormalize(dts, lastDTS);
|
|
|
+ mp4Sample.duration = (dtsnorm - lastDTS) / pes2mp4ScaleFactor;
|
|
|
+ } else {
|
|
|
+ ptsnorm = this._PTSNormalize(pts, nextAacPts);
|
|
|
+ dtsnorm = this._PTSNormalize(dts, nextAacPts);
|
|
|
+ var _delta = Math.round(1000 * (ptsnorm - nextAacPts) / pesTimeScale);
|
|
|
+ // if fragment are contiguous, detect hole/overlapping between fragments
|
|
|
+ if (contiguous) {
|
|
|
+ // log delta
|
|
|
+ if (_delta) {
|
|
|
+ if (_delta > 0) {
|
|
|
+ _logger.logger.log(_delta + ' ms hole between AAC samples detected,filling it');
|
|
|
+ // if we have frame overlap, overlapping for more than half a frame duraion
|
|
|
+ } else if (_delta < -12) {
|
|
|
+ // drop overlapping audio frames... browser will deal with it
|
|
|
+ _logger.logger.log(-_delta + ' ms overlapping between AAC samples detected, drop frame');
|
|
|
+ track.len -= unit.byteLength;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ // set PTS/DTS to expected PTS/DTS
|
|
|
+ ptsnorm = dtsnorm = nextAacPts;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // remember first PTS of our aacSamples, ensure value is positive
|
|
|
+ firstPTS = Math.max(0, ptsnorm);
|
|
|
+ firstDTS = Math.max(0, dtsnorm);
|
|
|
+ if (track.len > 0) {
|
|
|
+ /* concatenate the audio data and construct the mdat in place
|
|
|
+ (need 8 more bytes to fill length and mdat type) */
|
|
|
+ mdat = new Uint8Array(track.len + 8);
|
|
|
+ view = new DataView(mdat.buffer);
|
|
|
+ view.setUint32(0, mdat.byteLength);
|
|
|
+ mdat.set(_mp4Generator2.default.types.mdat, 4);
|
|
|
+ } else {
|
|
|
+ // no audio samples
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ mdat.set(unit, offset);
|
|
|
+ offset += unit.byteLength;
|
|
|
+ //console.log('PTS/DTS/initDTS/normPTS/normDTS/relative PTS : ${aacSample.pts}/${aacSample.dts}/${this._initDTS}/${ptsnorm}/${dtsnorm}/${(aacSample.pts/4294967296).toFixed(3)}');
|
|
|
+ mp4Sample = {
|
|
|
+ size: unit.byteLength,
|
|
|
+ cts: 0,
|
|
|
+ duration: 0,
|
|
|
+ flags: {
|
|
|
+ isLeading: 0,
|
|
|
+ isDependedOn: 0,
|
|
|
+ hasRedundancy: 0,
|
|
|
+ degradPrio: 0,
|
|
|
+ dependsOn: 1
|
|
|
+ }
|
|
|
+ };
|
|
|
+ samples.push(mp4Sample);
|
|
|
+ lastDTS = dtsnorm;
|
|
|
+ }
|
|
|
+ var lastSampleDuration = 0;
|
|
|
+ var nbSamples = samples.length;
|
|
|
+ //set last sample duration as being identical to previous sample
|
|
|
+ if (nbSamples >= 2) {
|
|
|
+ lastSampleDuration = samples[nbSamples - 2].duration;
|
|
|
+ mp4Sample.duration = lastSampleDuration;
|
|
|
+ }
|
|
|
+ if (nbSamples) {
|
|
|
+ // next aac sample PTS should be equal to last sample PTS + duration
|
|
|
+ this.nextAacPts = ptsnorm + pes2mp4ScaleFactor * lastSampleDuration;
|
|
|
+ //logger.log('Audio/PTS/PTSend:' + aacSample.pts.toFixed(0) + '/' + this.nextAacDts.toFixed(0));
|
|
|
+ track.len = 0;
|
|
|
+ track.samples = samples;
|
|
|
+ moof = _mp4Generator2.default.moof(track.sequenceNumber++, firstDTS / pes2mp4ScaleFactor, track);
|
|
|
+ track.samples = [];
|
|
|
+ var audioData = {
|
|
|
+ id: this.id,
|
|
|
+ level: this.level,
|
|
|
+ sn: this.sn,
|
|
|
+ data1: moof,
|
|
|
+ data2: mdat,
|
|
|
+ startPTS: firstPTS / pesTimeScale,
|
|
|
+ endPTS: this.nextAacPts / pesTimeScale,
|
|
|
+ startDTS: firstDTS / pesTimeScale,
|
|
|
+ endDTS: (dtsnorm + pes2mp4ScaleFactor * lastSampleDuration) / pesTimeScale,
|
|
|
+ type: 'audio',
|
|
|
+ nb: nbSamples
|
|
|
+ };
|
|
|
+ this.observer.trigger(_events2.default.FRAG_PARSING_DATA, audioData);
|
|
|
+ return audioData;
|
|
|
+ }
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'remuxEmptyAudio',
|
|
|
+ value: function remuxEmptyAudio(track, timeOffset, contiguous, videoData) {
|
|
|
+ var pesTimeScale = this.PES_TIMESCALE,
|
|
|
+ mp4timeScale = track.timescale ? track.timescale : track.audiosamplerate,
|
|
|
+ pes2mp4ScaleFactor = pesTimeScale / mp4timeScale,
|
|
|
+
|
|
|
+
|
|
|
+ // sync with video's timestamp
|
|
|
+ startDTS = videoData.startDTS * pesTimeScale + this._initDTS,
|
|
|
+ endDTS = videoData.endDTS * pesTimeScale + this._initDTS,
|
|
|
+
|
|
|
+
|
|
|
+ // one sample's duration value
|
|
|
+ sampleDuration = 1024,
|
|
|
+ frameDuration = pes2mp4ScaleFactor * sampleDuration,
|
|
|
+
|
|
|
+
|
|
|
+ // samples count of this segment's duration
|
|
|
+ nbSamples = Math.ceil((endDTS - startDTS) / frameDuration),
|
|
|
+
|
|
|
+
|
|
|
+ // silent frame
|
|
|
+ silentFrame = _aac2.default.getSilentFrame(track.channelCount);
|
|
|
+
|
|
|
+ // Can't remux if we can't generate a silent frame...
|
|
|
+ if (!silentFrame) {
|
|
|
+ _logger.logger.trace('Unable to remuxEmptyAudio since we were unable to get a silent frame for given audio codec!');
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ var samples = [];
|
|
|
+ for (var i = 0; i < nbSamples; i++) {
|
|
|
+ var stamp = startDTS + i * frameDuration;
|
|
|
+ samples.push({ unit: silentFrame.slice(0), pts: stamp, dts: stamp });
|
|
|
+ track.len += silentFrame.length;
|
|
|
+ }
|
|
|
+ track.samples = samples;
|
|
|
+
|
|
|
+ this.remuxAudio(track, timeOffset, contiguous);
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'remuxID3',
|
|
|
+ value: function remuxID3(track, timeOffset) {
|
|
|
+ var length = track.samples.length,
|
|
|
+ sample;
|
|
|
+ // consume samples
|
|
|
+ if (length) {
|
|
|
+ for (var index = 0; index < length; index++) {
|
|
|
+ sample = track.samples[index];
|
|
|
+ // setting id3 pts, dts to relative time
|
|
|
+ // using this._initPTS and this._initDTS to calculate relative time
|
|
|
+ sample.pts = (sample.pts - this._initPTS) / this.PES_TIMESCALE;
|
|
|
+ sample.dts = (sample.dts - this._initDTS) / this.PES_TIMESCALE;
|
|
|
+ }
|
|
|
+ this.observer.trigger(_events2.default.FRAG_PARSING_METADATA, {
|
|
|
+ id: this.id,
|
|
|
+ level: this.level,
|
|
|
+ sn: this.sn,
|
|
|
+ samples: track.samples
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ track.samples = [];
|
|
|
+ timeOffset = timeOffset;
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'remuxText',
|
|
|
+ value: function remuxText(track, timeOffset) {
|
|
|
+ track.samples.sort(function (a, b) {
|
|
|
+ return a.pts - b.pts;
|
|
|
+ });
|
|
|
+
|
|
|
+ var length = track.samples.length,
|
|
|
+ sample;
|
|
|
+ // consume samples
|
|
|
+ if (length) {
|
|
|
+ for (var index = 0; index < length; index++) {
|
|
|
+ sample = track.samples[index];
|
|
|
+ // setting text pts, dts to relative time
|
|
|
+ // using this._initPTS and this._initDTS to calculate relative time
|
|
|
+ sample.pts = (sample.pts - this._initPTS) / this.PES_TIMESCALE;
|
|
|
+ }
|
|
|
+ this.observer.trigger(_events2.default.FRAG_PARSING_USERDATA, {
|
|
|
+ id: this.id,
|
|
|
+ level: this.level,
|
|
|
+ sn: this.sn,
|
|
|
+ samples: track.samples
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ track.samples = [];
|
|
|
+ timeOffset = timeOffset;
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: '_PTSNormalize',
|
|
|
+ value: function _PTSNormalize(value, reference) {
|
|
|
+ var offset;
|
|
|
+ if (reference === undefined) {
|
|
|
+ return value;
|
|
|
+ }
|
|
|
+ if (reference < value) {
|
|
|
+ // - 2^33
|
|
|
+ offset = -8589934592;
|
|
|
+ } else {
|
|
|
+ // + 2^33
|
|
|
+ offset = 8589934592;
|
|
|
+ }
|
|
|
+ /* PTS is 33bit (from 0 to 2^33 -1)
|
|
|
+ if diff between value and reference is bigger than half of the amplitude (2^32) then it means that
|
|
|
+ PTS looping occured. fill the gap */
|
|
|
+ while (Math.abs(value - reference) > 4294967296) {
|
|
|
+ value += offset;
|
|
|
+ }
|
|
|
+ return value;
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'passthrough',
|
|
|
+ get: function get() {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }]);
|
|
|
+
|
|
|
+ return MP4Remuxer;
|
|
|
+}();
|
|
|
+
|
|
|
+exports.default = MP4Remuxer;
|
|
|
+
|
|
|
+},{"../errors":7,"../events":9,"../helper/aac":10,"../remux/mp4-generator":15,"../utils/logger":17,"../utils/polyfill":18}],17:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+Object.defineProperty(exports, "__esModule", {
|
|
|
+ value: true
|
|
|
+});
|
|
|
+
|
|
|
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
|
|
+
|
|
|
+function noop() {}
|
|
|
+
|
|
|
+var fakeLogger = {
|
|
|
+ trace: noop,
|
|
|
+ debug: noop,
|
|
|
+ log: noop,
|
|
|
+ warn: noop,
|
|
|
+ info: noop,
|
|
|
+ error: noop
|
|
|
+};
|
|
|
+
|
|
|
+var exportedLogger = fakeLogger;
|
|
|
+
|
|
|
+//let lastCallTime;
|
|
|
+// function formatMsgWithTimeInfo(type, msg) {
|
|
|
+// const now = Date.now();
|
|
|
+// const diff = lastCallTime ? '+' + (now - lastCallTime) : '0';
|
|
|
+// lastCallTime = now;
|
|
|
+// msg = (new Date(now)).toISOString() + ' | [' + type + '] > ' + msg + ' ( ' + diff + ' ms )';
|
|
|
+// return msg;
|
|
|
+// }
|
|
|
+
|
|
|
+function formatMsg(type, msg) {
|
|
|
+ msg = '[' + type + '] > ' + msg;
|
|
|
+ return msg;
|
|
|
+}
|
|
|
+
|
|
|
+function consolePrintFn(type) {
|
|
|
+ var func = window.console[type];
|
|
|
+ if (func) {
|
|
|
+ return function () {
|
|
|
+ for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
|
|
|
+ args[_key] = arguments[_key];
|
|
|
+ }
|
|
|
+
|
|
|
+ if (args[0]) {
|
|
|
+ args[0] = formatMsg(type, args[0]);
|
|
|
+ }
|
|
|
+ func.apply(window.console, args);
|
|
|
+ };
|
|
|
+ }
|
|
|
+ return noop;
|
|
|
+}
|
|
|
+
|
|
|
+function exportLoggerFunctions(debugConfig) {
|
|
|
+ for (var _len2 = arguments.length, functions = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
|
|
|
+ functions[_key2 - 1] = arguments[_key2];
|
|
|
+ }
|
|
|
+
|
|
|
+ functions.forEach(function (type) {
|
|
|
+ exportedLogger[type] = debugConfig[type] ? debugConfig[type].bind(debugConfig) : consolePrintFn(type);
|
|
|
+ });
|
|
|
+}
|
|
|
+
|
|
|
+var enableLogs = exports.enableLogs = function enableLogs(debugConfig) {
|
|
|
+ if (debugConfig === true || (typeof debugConfig === 'undefined' ? 'undefined' : _typeof(debugConfig)) === 'object') {
|
|
|
+ exportLoggerFunctions(debugConfig,
|
|
|
+ // Remove out from list here to hard-disable a log-level
|
|
|
+ //'trace',
|
|
|
+ 'debug', 'log', 'info', 'warn', 'error');
|
|
|
+ // Some browsers don't allow to use bind on console object anyway
|
|
|
+ // fallback to default if needed
|
|
|
+ try {
|
|
|
+ exportedLogger.log();
|
|
|
+ } catch (e) {
|
|
|
+ exportedLogger = fakeLogger;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ exportedLogger = fakeLogger;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+var logger = exports.logger = exportedLogger;
|
|
|
+
|
|
|
+},{}],18:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+if (typeof ArrayBuffer !== 'undefined' && !ArrayBuffer.prototype.slice) {
|
|
|
+ ArrayBuffer.prototype.slice = function (start, end) {
|
|
|
+ var that = new Uint8Array(this);
|
|
|
+ if (end === undefined) {
|
|
|
+ end = that.length;
|
|
|
+ }
|
|
|
+ var result = new ArrayBuffer(end - start);
|
|
|
+ var resultArray = new Uint8Array(result);
|
|
|
+ for (var i = 0; i < resultArray.length; i++) {
|
|
|
+ resultArray[i] = that[i + start];
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+ };
|
|
|
+}
|
|
|
+
|
|
|
+},{}],19:[function(require,module,exports){
|
|
|
+'use strict';
|
|
|
+
|
|
|
+Object.defineProperty(exports, "__esModule", {
|
|
|
+ value: true
|
|
|
+});
|
|
|
+
|
|
|
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
+
|
|
|
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
+
|
|
|
+/**
|
|
|
+ * XHR based logger
|
|
|
+*/
|
|
|
+
|
|
|
+var XhrLoader = function () {
|
|
|
+ function XhrLoader(config) {
|
|
|
+ _classCallCheck(this, XhrLoader);
|
|
|
+
|
|
|
+ if (config && config.xhrSetup) {
|
|
|
+ this.xhrSetup = config.xhrSetup;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ _createClass(XhrLoader, [{
|
|
|
+ key: 'destroy',
|
|
|
+ value: function destroy() {
|
|
|
+ this.abort();
|
|
|
+ this.loader = null;
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'abort',
|
|
|
+ value: function abort() {
|
|
|
+ var loader = this.loader;
|
|
|
+ if (loader && loader.readyState !== 4) {
|
|
|
+ this.stats.aborted = true;
|
|
|
+ loader.abort();
|
|
|
+ }
|
|
|
+
|
|
|
+ window.clearTimeout(this.requestTimeout);
|
|
|
+ this.requestTimeout = null;
|
|
|
+ window.clearTimeout(this.retryTimeout);
|
|
|
+ this.retryTimeout = null;
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'loadHead',
|
|
|
+ value: function loadHead(context, config, callbacks) {
|
|
|
+ this.context = context;
|
|
|
+ this.config = config;
|
|
|
+ this.callbacks = callbacks;
|
|
|
+ this.stats = { trequest: performance.now(), retry: 0 };
|
|
|
+ this.retryDelay = config.retryDelay;
|
|
|
+ var xhr = new XMLHttpRequest();
|
|
|
+ xhr.open('head', context.url);
|
|
|
+ xhr.onload = function () {
|
|
|
+ callbacks.onSuccess(xhr.getResponseHeader('content-length'));
|
|
|
+ };
|
|
|
+ xhr.send();
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'load',
|
|
|
+ value: function load(context, config, callbacks) {
|
|
|
+ this.context = context;
|
|
|
+ this.config = config;
|
|
|
+ this.callbacks = callbacks;
|
|
|
+ this.stats = { trequest: performance.now(), retry: 0 };
|
|
|
+ this.retryDelay = config.retryDelay;
|
|
|
+ this.loadInternal();
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'loadInternal',
|
|
|
+ value: function loadInternal() {
|
|
|
+ var xhr,
|
|
|
+ context = this.context;
|
|
|
+ if (typeof XDomainRequest !== 'undefined') {
|
|
|
+ xhr = this.loader = new XDomainRequest();
|
|
|
+ } else {
|
|
|
+ xhr = this.loader = new XMLHttpRequest();
|
|
|
+ }
|
|
|
+ xhr.onloadend = this.loadend.bind(this);
|
|
|
+ xhr.onprogress = this.loadprogress.bind(this);
|
|
|
+ xhr.open('GET', context.url, true);
|
|
|
+ if (context.rangeEnd) {
|
|
|
+ xhr.setRequestHeader('Range', 'bytes=' + context.rangeStart + '-' + (context.rangeEnd - 1));
|
|
|
+ }
|
|
|
+ xhr.responseType = context.responseType;
|
|
|
+ var stats = this.stats;
|
|
|
+ stats.tfirst = 0;
|
|
|
+ stats.loaded = 0;
|
|
|
+ if (this.xhrSetup) {
|
|
|
+ this.xhrSetup(xhr, context.url);
|
|
|
+ }
|
|
|
+ // setup timeout before we perform request
|
|
|
+ this.requestTimeout = window.setTimeout(this.loadtimeout.bind(this), this.config.timeout);
|
|
|
+ xhr.send();
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'loadend',
|
|
|
+ value: function loadend(event) {
|
|
|
+ var xhr = event.currentTarget,
|
|
|
+ status = xhr.status,
|
|
|
+ stats = this.stats,
|
|
|
+ context = this.context,
|
|
|
+ config = this.config;
|
|
|
+ // don't proceed if xhr has been aborted
|
|
|
+ if (stats.aborted) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ // in any case clear the current xhrs timeout
|
|
|
+ window.clearTimeout(this.requestTimeout);
|
|
|
+
|
|
|
+ // http status between 200 to 299 are all successful
|
|
|
+ if (status >= 200 && status < 300) {
|
|
|
+ stats.tload = Math.max(stats.tfirst, performance.now());
|
|
|
+ var data = void 0,
|
|
|
+ len = void 0;
|
|
|
+ if (context.responseType === 'arraybuffer') {
|
|
|
+ data = xhr.response;
|
|
|
+ len = data.byteLength;
|
|
|
+ } else {
|
|
|
+ data = xhr.responseText;
|
|
|
+ len = data.length;
|
|
|
+ }
|
|
|
+ stats.loaded = stats.total = len;
|
|
|
+ var response = { url: xhr.responseURL, data: data };
|
|
|
+ this.callbacks.onSuccess(response, stats, context);
|
|
|
+ } else {
|
|
|
+ // if max nb of retries reached or if http status between 400 and 499 (such error cannot be recovered, retrying is useless), return error
|
|
|
+ if (stats.retry >= config.maxRetry || status >= 400 && status < 499) {
|
|
|
+ // logger.error(`${status} while loading ${context.url}` );
|
|
|
+ this.callbacks.onError({ code: status, text: xhr.statusText }, context);
|
|
|
+ } else {
|
|
|
+ // retry
|
|
|
+ // logger.warn(`${status} while loading ${context.url}, retrying in ${this.retryDelay}...`);
|
|
|
+ // aborts and resets internal state
|
|
|
+ this.destroy();
|
|
|
+ // schedule retry
|
|
|
+ this.retryTimeout = window.setTimeout(this.loadInternal.bind(this), this.retryDelay);
|
|
|
+ // set exponential backoff
|
|
|
+ this.retryDelay = Math.min(2 * this.retryDelay, config.maxRetryDelay);
|
|
|
+ stats.retry++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'loadtimeout',
|
|
|
+ value: function loadtimeout() {
|
|
|
+ // logger.warn(`timeout while loading ${this.context.url}` );
|
|
|
+ this.callbacks.onTimeout(this.stats, this.context);
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'loadprogress',
|
|
|
+ value: function loadprogress(event) {
|
|
|
+ var stats = this.stats;
|
|
|
+ if (stats.tfirst === 0) {
|
|
|
+ stats.tfirst = Math.max(performance.now(), stats.trequest);
|
|
|
+ }
|
|
|
+ stats.loaded = event.loaded;
|
|
|
+ if (event.lengthComputable) {
|
|
|
+ stats.total = event.total;
|
|
|
+ }
|
|
|
+ var onProgress = this.callbacks.onProgress;
|
|
|
+ if (onProgress) {
|
|
|
+ // last args is to provide on progress data
|
|
|
+ onProgress(stats, this.context, null);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }]);
|
|
|
+
|
|
|
+ return XhrLoader;
|
|
|
+}();
|
|
|
+
|
|
|
+exports.default = XhrLoader;
|
|
|
+
|
|
|
+},{}],20:[function(require,module,exports){
|
|
|
+/**
|
|
|
+ * WFS interface, Jeff Yang 2016.10
|
|
|
+ */
|
|
|
+'use strict';
|
|
|
+
|
|
|
+Object.defineProperty(exports, "__esModule", {
|
|
|
+ value: true
|
|
|
+});
|
|
|
+
|
|
|
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
+
|
|
|
+var _events = require('./events');
|
|
|
+
|
|
|
+var _events2 = _interopRequireDefault(_events);
|
|
|
+
|
|
|
+var _flowController = require('./controller/flow-controller');
|
|
|
+
|
|
|
+var _flowController2 = _interopRequireDefault(_flowController);
|
|
|
+
|
|
|
+var _bufferController = require('./controller/buffer-controller');
|
|
|
+
|
|
|
+var _bufferController2 = _interopRequireDefault(_bufferController);
|
|
|
+
|
|
|
+var _events3 = require('events');
|
|
|
+
|
|
|
+var _events4 = _interopRequireDefault(_events3);
|
|
|
+
|
|
|
+var _xhrLoader = require('./utils/xhr-loader');
|
|
|
+
|
|
|
+var _xhrLoader2 = _interopRequireDefault(_xhrLoader);
|
|
|
+
|
|
|
+var _fileLoader = require('./loader/file-loader');
|
|
|
+
|
|
|
+var _fileLoader2 = _interopRequireDefault(_fileLoader);
|
|
|
+
|
|
|
+var _websocketLoader = require('./loader/websocket-loader');
|
|
|
+
|
|
|
+var _websocketLoader2 = _interopRequireDefault(_websocketLoader);
|
|
|
+
|
|
|
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
+
|
|
|
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
+
|
|
|
+var Wfs = function () {
|
|
|
+ _createClass(Wfs, null, [{
|
|
|
+ key: 'isSupported',
|
|
|
+ value: function isSupported() {
|
|
|
+ return window.MediaSource && typeof window.MediaSource.isTypeSupported === 'function' && window.MediaSource.isTypeSupported('video/mp4; codecs="avc1.42c01f,mp4a.40.2"');
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'version',
|
|
|
+ get: function get() {
|
|
|
+ // replaced with browserify-versionify transform
|
|
|
+ return '' + 'v.0.0.0.1';
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'Events',
|
|
|
+ get: function get() {
|
|
|
+ return _events2.default;
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'DefaultConfig',
|
|
|
+ get: function get() {
|
|
|
+ if (!Wfs.defaultConfig) {
|
|
|
+ Wfs.defaultConfig = {
|
|
|
+ autoStartLoad: true,
|
|
|
+ startPosition: -1,
|
|
|
+ debug: false,
|
|
|
+ fLoader: undefined,
|
|
|
+ loader: _xhrLoader2.default,
|
|
|
+ //loader: FetchLoader,
|
|
|
+ fmp4FileUrl: 'xxxx.mp4',
|
|
|
+ fragLoadingTimeOut: 20000,
|
|
|
+ fragLoadingMaxRetry: 6,
|
|
|
+ fragLoadingRetryDelay: 1000,
|
|
|
+ fragLoadingMaxRetryTimeout: 64000,
|
|
|
+ fragLoadingLoopThreshold: 3,
|
|
|
+ forceKeyFrameOnDiscontinuity: true,
|
|
|
+ appendErrorMaxRetry: 3
|
|
|
+ };
|
|
|
+ }
|
|
|
+ return Wfs.defaultConfig;
|
|
|
+ },
|
|
|
+ set: function set(defaultConfig) {
|
|
|
+ Wfs.defaultConfig = defaultConfig;
|
|
|
+ }
|
|
|
+ }]);
|
|
|
+
|
|
|
+ function Wfs() {
|
|
|
+ var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
|
|
+
|
|
|
+ _classCallCheck(this, Wfs);
|
|
|
+
|
|
|
+ var defaultConfig = Wfs.DefaultConfig;
|
|
|
+ for (var prop in defaultConfig) {
|
|
|
+ if (prop in config) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ config[prop] = defaultConfig[prop];
|
|
|
+ }
|
|
|
+ this.config = config;
|
|
|
+ // observer setup
|
|
|
+ var observer = this.observer = new _events4.default();
|
|
|
+ observer.trigger = function trigger(event) {
|
|
|
+ for (var _len = arguments.length, data = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
|
|
+ data[_key - 1] = arguments[_key];
|
|
|
+ }
|
|
|
+
|
|
|
+ observer.emit.apply(observer, [event, event].concat(data));
|
|
|
+ };
|
|
|
+
|
|
|
+ observer.off = function off(event) {
|
|
|
+ for (var _len2 = arguments.length, data = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
|
|
|
+ data[_key2 - 1] = arguments[_key2];
|
|
|
+ }
|
|
|
+
|
|
|
+ observer.removeListener.apply(observer, [event].concat(data));
|
|
|
+ };
|
|
|
+ this.on = observer.on.bind(observer);
|
|
|
+ this.off = observer.off.bind(observer);
|
|
|
+ this.trigger = observer.trigger.bind(observer);
|
|
|
+
|
|
|
+ this.flowController = new _flowController2.default(this);
|
|
|
+ this.bufferController = new _bufferController2.default(this);
|
|
|
+ // this.fileLoader = new FileLoader(this);
|
|
|
+ this.websocketLoader = new _websocketLoader2.default(this);
|
|
|
+ this.mediaType = undefined;
|
|
|
+ }
|
|
|
+
|
|
|
+ _createClass(Wfs, [{
|
|
|
+ key: 'destroy',
|
|
|
+ value: function destroy() {
|
|
|
+ this.flowController.destroy();
|
|
|
+ this.bufferController.destroy();
|
|
|
+ // this.fileLoader.destroy();
|
|
|
+ this.websocketLoader.destroy();
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'attachMedia',
|
|
|
+ value: function attachMedia(media,deviceId,clientid, loginHandle, wsUrl) {
|
|
|
+ var sessiontype = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 'video';
|
|
|
+ var begintime = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : '0';
|
|
|
+ var channelName = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : 'chX';
|
|
|
+ var mediaType = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : 'H264Raw';
|
|
|
+ var websocketName = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : 'play2';
|
|
|
+ // 'H264Raw' 'FMp4'
|
|
|
+ this.mediaType = mediaType;
|
|
|
+ this.media = media;
|
|
|
+ this.trigger(_events2.default.MEDIA_ATTACHING, { media: media, channelName: channelName, mediaType: mediaType, websocketName: websocketName, deviceId: deviceId,clientid: clientid,loginHandle: loginHandle,wsUrl: wsUrl ,sessiontype: sessiontype, begintime: begintime});
|
|
|
+ }
|
|
|
+ }, {
|
|
|
+ key: 'attachWebsocket',
|
|
|
+ value: function attachWebsocket(websocket, channelName, deviceId, clientid, loginHandle, sessiontype, begintime) {
|
|
|
+ this.trigger(_events2.default.WEBSOCKET_ATTACHING, { websocket: websocket, mediaType: this.mediaType, channelName: channelName, deviceId: deviceId,clientid: clientid,loginHandle: loginHandle, sessiontype: sessiontype, begintime: begintime});
|
|
|
+ }
|
|
|
+ }]);
|
|
|
+
|
|
|
+ return Wfs;
|
|
|
+}();
|
|
|
+
|
|
|
+exports.default = Wfs;
|
|
|
+
|
|
|
+},{"./controller/buffer-controller":3,"./controller/flow-controller":4,"./events":9,"./loader/file-loader":13,"./loader/websocket-loader":14,"./utils/xhr-loader":19,"events":1}]},{},[11])(11)
|
|
|
+});
|
